1
I am trying to connect an application between the computer and an android app. The app will be the client and the computer will be the server.
Using Bluez( C library for bluetooth on linux) for server :
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/rfcomm.h>
int main(int argc, char **argv)
{
struct sockaddr_rc loc_addr = { 0 }, rem_addr = { 0 };
char buf[1024] = { 0 };
int s, client, bytes_read;
socklen_t opt = sizeof(rem_addr);
// allocate socket
s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
// bind socket to port 1 of the first available
// local bluetooth adapter
loc_addr.rc_family = AF_BLUETOOTH;
loc_addr.rc_bdaddr = *BDADDR_ANY;
loc_addr.rc_channel = (uint8_t) 1;
bind(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr));
// put socket into listening mode
listen(s, 1);
// accept one connection
client = accept(s, (struct sockaddr *)&rem_addr, &opt);
ba2str( &rem_addr.rc_bdaddr, buf );
fprintf(stderr, "accepted connection from %s\n", buf);
memset(buf, 0, sizeof(buf));
// read data from the client
bytes_read = read(client, buf, sizeof(buf));
if( bytes_read > 0 ) {
printf("received [%s]\n", buf);
}
// close connection
close(client);
close(s);
return 0;
}
Source : http://people.csail.mit.edu/albert/bluez-intro/x502.html
And the app class I’m using to connect is :
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.os.Bundle;
import android.os.Message;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.UUID;
public class ConnectionThread extends Thread {
BluetoothSocket btSocket = null;
BluetoothServerSocket btServerSocket = null;
InputStream input = null;
OutputStream output = null;
String btDevAddress = null;
String myUUID = "00000101-0000-1000-8000-00805F9C34BF";
boolean server;
boolean running = false;
/* Este construtor prepara o dispositivo para atuar como servidor.
*/
public ConnectionThread() {
this.server = true;
}
/* Este construtor prepara o dispositivo para atuar como cliente.
Tem como argumento uma string contendo o endereço MAC do dispositivo
Bluetooth para o qual deve ser solicitada uma conexão.
*/
public ConnectionThread(String btDevAddress) {
this.server = false;
this.btDevAddress = btDevAddress;
}
/* O método run() contem as instruções que serão efetivamente realizadas
em uma nova thread.
*/
public void run() {
/* Anuncia que a thread está sendo executada.
Pega uma referência para o adaptador Bluetooth padrão.
*/
this.running = true;
BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
/* Determina que ações executar dependendo se a thread está configurada
para atuar como servidor ou cliente.
*/
if(this.server) {
/* Servidor.
*/
try {
/* Cria um socket de servidor Bluetooth.
O socket servidor será usado apenas para iniciar a conexão.
Permanece em estado de espera até que algum cliente
estabeleça uma conexão.
*/
btServerSocket = btAdapter.listenUsingRfcommWithServiceRecord("Super Bluetooth", UUID.fromString(myUUID));
btSocket = btServerSocket.accept();
/* Se a conexão foi estabelecida corretamente, o socket
servidor pode ser liberado.
*/
if(btSocket != null) {
btServerSocket.close();
}
} catch (IOException e) {
/* Caso ocorra alguma exceção, exibe o stack trace para debug.
Envia um código para a Activity principal, informando que
a conexão falhou.
*/
e.printStackTrace();
toMainActivity("---N".getBytes());
}
} else {
/* Cliente.
*/
try {
/* Obtem uma representação do dispositivo Bluetooth com
endereço btDevAddress.
Cria um socket Bluetooth.
*/
BluetoothDevice btDevice = btAdapter.getRemoteDevice(btDevAddress);
btSocket = btDevice.createRfcommSocketToServiceRecord(UUID.fromString(myUUID));
/* Envia ao sistema um comando para cancelar qualquer processo
de descoberta em execução.
*/
btAdapter.cancelDiscovery();
/* Solicita uma conexão ao dispositivo cujo endereço é
btDevAddress.
Permanece em estado de espera até que a conexão seja
estabelecida.
*/
if (btSocket != null)
btSocket.connect();
} catch (IOException e) {
/* Caso ocorra alguma exceção, exibe o stack trace para debug.
Envia um código para a Activity principal, informando que
a conexão falhou.
*/
e.printStackTrace();
toMainActivity("---N".getBytes());
}
}
/* Pronto, estamos conectados! Agora, só precisamos gerenciar a conexão.
...
*/
if(btSocket != null) {
/* Envia um código para a Activity principal informando que a
a conexão ocorreu com sucesso.
*/
toMainActivity("---S".getBytes());
try {
/* Obtem referências para os fluxos de entrada e saída do
socket Bluetooth.
*/
input = btSocket.getInputStream();
output = btSocket.getOutputStream();
/* Cria um byte array para armazenar temporariamente uma
mensagem recebida.
O inteiro bytes representará o número de bytes lidos na
última mensagem recebida.
*/
byte[] buffer = new byte[1024];
int bytes;
/* Permanece em estado de espera até que uma mensagem seja
recebida.
Armazena a mensagem recebida no buffer.
Envia a mensagem recebida para a Activity principal, do
primeiro ao último byte lido.
Esta thread permanecerá em estado de escuta até que
a variável running assuma o valor false.
*/
while(running) {
bytes = input.read(buffer);
toMainActivity(Arrays.copyOfRange(buffer, 0, bytes));
}
} catch (IOException e) {
/* Caso ocorra alguma exceção, exibe o stack trace para debug.
Envia um código para a Activity principal, informando que
a conexão falhou.
*/
e.printStackTrace();
toMainActivity("---N".getBytes());
}
}
}
/* Utiliza um handler para enviar um byte array à Activity principal.
O byte array é encapsulado em um Bundle e posteriormente em uma Message
antes de ser enviado.
*/
private void toMainActivity(byte[] data) {
Message message = new Message();
Bundle bundle = new Bundle();
bundle.putByteArray("data", data);
message.setData(bundle);
MainActivity.handler.sendMessage(message);
}
/* Método utilizado pela Activity principal para transmitir uma mensagem ao
outro lado da conexão.
A mensagem deve ser representada por um byte array.
*/
public void write(byte[] data) {
if(output != null) {
try {
/* Transmite a mensagem.
*/
output.write(data);
} catch (IOException e) {
e.printStackTrace();
}
} else {
/* Envia à Activity principal um código de erro durante a conexão.
*/
toMainActivity("---N".getBytes());
}
}
/* Método utilizado pela Activity principal para encerrar a conexão
*/
public void cancel() {
try {
running = false;
btServerSocket.close();
btSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
running = false;
}
}
To send a data to the server :
ConnectionThread connect = new ConnectionThread(data.getStringExtra("Address_server"));
connect.start();
byte[] data = "10".getBytes();
connect.write(data);
The problem that the connection is not happening. I think it is because the server is without UUID.
How to insert the UUID into the server so it can receive the data sent ?