Este post é uma continuação.

Parte I – Tutorial Android – Desenvolvendo Com Bluetooth Para Comunicação Veicular
Parte II – Tutorial Android – Desenvolvendo Com Bluetooth Para Comunicação Veicular

5.    Habilitando descoberta

Se você deseja fazer o dispositivo local detectável por outros dispositivos, chame startActivityForResult (ACTION_REQUEST_DISCOVERABLE, int). Isso irá emitir um pedido para ativar o modo detectável através das configurações do sistema (sem parar a sua aplicação). Por padrão, o dispositivo se tornará detectável por 120 segundos. Você pode definir uma duração diferente, adicionando a intent EXTRA_DISCOVERABLE_DURATION. A duração máxima que um aplicativo pode definir é de 3.600 segundos e o valor 0 significa que o dispositivo é sempre detectável. Qualquer valor abaixo de 0 ou acima de 3600 é automaticamente definida para 120 segundos). Por exemplo, esse trecho define a duração de 300:

[sourcecode language=”java”]
Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);
startActivity(discoverableIntent);

[/sourcecode]

Figura 2: A caixa de diálogo descoberta de habilitação.

 

Uma caixa de diálogo será exibida, solicitando a permissão do usuário para tornar o dispositivo detectável, como mostrado na Figura 2. Se o usuário responder “Sim”, o dispositivo se tornará detectável durante o período de tempo especificado. Sua atividade receberá então uma chamada para o retorno onActivityResult (), com o código do resultado igual ao tempo que o dispositivo está detectável. Se o usuário respondeu “Não” ou se ocorrer um erro, o código de resultado será RESULT_CANCELED .

O dispositivo permanecerá no modo de descoberta no tempo previsto. Se você desejar ser notificado quando o modo de descoberta alterar, você pode registrar um BroadcastReceiver para a intent ACTION_SCAN_MODE_CHANGED. Este irá conter os campos extras EXTRA_SCAN_MODE e EXTRA_PREVIOUS_SCAN_MODE, que indica o modo de digitalização atual e antigo, respectivamente. Os valores possíveis para cada um são SCAN_MODE_CONNECTABLE_DISCOVERABLE, SCAN_MODE_CONNECTABLE, ou SCAN_MODE_NONE, que indicam que o dispositivo está no modo de descoberta, fora do modo de descoberta, mas ainda capaz de se conectar, ou fora do modo de descoberta e incapaz de se conectar, respectivamente.

Não é necessário habilitar a descoberta de dispositivo se você for iniciar uma conexão a um dispositivo remoto. Habilitar a descoberta só é necessário quando você quiser que seu aplicativo hospede um servidor socket que irá aceitar conexões de entrada.

6.    Conexão entre dispositivos

Para criar uma conexão entre dois dispositivos, você deve implementar tanto o servidor quanto o cliente, pois um dispositivo deve abrir um servidor socket e o outro deve iniciar a conexão (usando o endereço do dispositivo servidor MAC para iniciar uma conexão). O servidor e o cliente são considerados conectados entre si quando eles estão conectados pelo BluetoothSocket no mesmo canal RFCOMM. Neste ponto, cada dispositivo pode obter fluxos de entrada e saída e a transferência de dados pode começar, que é discutido na seção sobre gestão de uma conexão . Esta seção descreve apenas como iniciar a conexão entre dois dispositivos.

O dispositivo servidor e o dispositivo cliente obtêm o BluetoothSocket de diferentes maneiras. O servidor irá recebê-lo quando a conexão de entrada for aceita. O cliente irá recebê-lo quando ele abre um canal RFCOMM para o servidor.

Uma técnica de aplicação é para preparar automaticamente cada dispositivo como um servidor, de modo que cada um possui um soquete de servidor aberto e aguardando as conexões. Em seguida, um ou outro dispositivo pode iniciar uma ligação com o outro e tornar-se o cliente. Alternativamente, um dispositivo pode explicitamente “hospedar” a conexão e abrir um servidor socket e o outro dispositivo pode simplesmente iniciar a conexão.

6.1. Conectar-se como um servidor

Quando você quiser conectar dois dispositivos, é preciso atuar como um servidor, mantendo aberto o “diálogo” BluetoothServerSocket . O objetivo do socket do servidor é para escutar solicitações de conexão de entrada e quando um é aceito, fornecer uma ligação BluetoothSocket . Quando o BluetoothSocket é adquirido a partir do BluetoothServerSocket , o BluetoothServerSocket pode (e deve) ser descartado, a menos que queira aceitar novas conexões.

Aqui é o procedimento básico para configurar um servidor socket e aceitar uma conexão:

1. Obter uma BluetoothServerSocket chamando o listenUsingRfcommWithServiceRecord (String, UUID) .

A seqüência é um nome de identificação do seu serviço, que o sistema irá automaticamente gravar a entrada de dados no dispositivo em um novo Service Discovery Protocol (SDP) (o nome é arbitrário e pode ser simplesmente o nome do aplicativo). O UUID é também incluído na entrada SDP e irá ser a base para a ligação com o dispositivo cliente. Ou seja, quando o cliente tenta se conectar com este dispositivo, ele levará um UUID que identifica o serviço com o qual deseja se conectar. Estes UUIDs deve corresponder a fim de que a ligação seja aceita (no passo seguinte).

2. Comece a escutar os pedidos de conexão chamando accept (). Esta é uma chamada de bloqueio. Ele irá retornar quando uma conexão for aceita ou ocorrer uma exceção. A conexão é aceita somente quando um dispositivo remoto enviar um pedido de conexão com um UUID correspondente ao registrado para este socket servidor receber. Quando bem sucedida, accept () irá retornar uma ligação BluetoothSocket .

3. A menos que você deseja aceitar conexões adicionais, chame close(). Isso libera o socket servidor e todos os seus recursos, mas fechará o conectado BluetoothSocket que foi retornado por accept(). Ao contrário do TCP/IP, RFCOMM só permite que um cliente esteja conectado a um canal por vez, então na maioria dos casos, faz sentido chamar close() no BluetoothServerSocket imediatamente depois de aceitar e conectar um socket.

O accept() não deve ser executado na Activity main, porque é uma chamada de bloqueio e impedirá qualquer outra interação com o aplicativo. Ele geralmente faz sentido fazer todo o trabalho com um BluetoothServerSocket ou BluetoothSocket em um novo método gerenciado pelo seu aplicativo. Para cancelar uma chamada bloqueada como accept(), chame close() no BluetoothServerSocket (ou BluetoothSocket) de outra thread e a chamada bloqueado retornará imediatamente. Note que todos os métodos em um BluetoothServerSocket ou BluetoothSocket são thread-safe.

Exemplo

Aqui está uma thread simplificada para o servidor que aceita conexões de entrada:

[sourcecode language=”java”]
private class AcceptThread extends Thread {
private final BluetoothServerSocket mmServerSocket;

public AcceptThread() {
// Use um objeto temporario que é depois atribuido a mmServerSocket,
// porque mmServerSocket é final
BluetoothServerSocket tmp = null;
try {
// MY_UUID é a string UUID, também usada pelo cliente
tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
} catch (IOException e) { }
mmServerSocket = tmp;
}

public void run() {
BluetoothSocket socket = null;
// Continuar recebendo até ocorrer uma exceção ou o retorno de um socket
while (true) {
try {
socket = mmServerSocket.accept();
} catch (IOException e) {
break;
}
// Se a conexão for aceita
if (socket != null) {
// Trabalhar para gerir a conexão (em uma thread separada)
manageConnectedSocket(socket);
mmServerSocket.close();
break;
}
}
}

/** Cancelará o socket de espera, e terminará o método */
public void cancel() {
try {
mmServerSocket.close();
} catch (IOException e) { }
}
}

[/sourcecode]

Neste exemplo, apenas uma ligação de entrada é desejada, então, logo que uma conexão for aceita e o BluetoothSocket for adquirido, a aplicação envia o BluetoothSocket adquirida para um método separado, fecha o BluetoothServerSocket e quebra do laço.

Note que quando accept () retorna o BluetoothSocket , o soquete já está conectado, por isso você não deve chamar connect ().

manageConnectedSocket() é um método fictício do aplicativo que iniciará a discussão para a transferência de dados, que são discutidos na seção sobre a gestão de uma conexão .

Normalmente deve fechar o BluetoothServerSocket assim que forem feitas as conexões. Neste exemplo, close() é chamado logo que o BluetoothSocket é adquirido. Você também pode querer fornecer um método público em sua thread que pode fechar o privado BluetoothSocket no evento que você precisa parar de ouvir no socket servidor.

6.2. Conectar-se como um cliente

Para iniciar uma conexão com um dispositivo remoto, você deve primeiro obter um objeto BluetoothDevice  que representa o dispositivo remoto. (Conseguir um BluetoothDevice é abordado na seção acima sobre Dispositivos Encontrando). Você deve então usar o BluetoothDevice para adquirir um BluetoothSocket e iniciar a conexão.

Aqui está o procedimento básico:

1. Usando o BluetoothDevice , pegue o BluetoothSocket chamando createRfcommSocketToServiceRecord (UUID). Isso inicializa um BluetoothSocket que irá se conectar ao BluetoothDevice . O UUID passado aqui deve coincidir com o UUID usado pelo dispositivo servidor quando ele abriu sua BluetoothServerSocket (com listenUsingRfcommWithServiceRecord (String, UUID) ). Usar o mesmo UUID é simplesmente uma questão de codificar a seqüência de UUID em sua aplicação para, em seguida, fazer referência a ele, tanto no servidor quanto no código do cliente.
2. Iniciar a conexão chamando connect ().

Após essa chamada, o sistema irá realizar uma pesquisa SDP no dispositivo remoto, a fim de coincidir com o UUID. Se a pesquisa for bem-sucedida e o dispositivo remoto aceitar a conexão, ele irá compartilhar o canal RFCOMM para usar durante a conexão e connect() irá retornar. Este método é uma chamada de bloqueio. Se, por qualquer motivo, a conexão falhar ou o método connect() ficar fora (após cerca de 12 segundos), então ele lançará uma exceção.

Por connect() ser uma chamada de bloqueio, este procedimento de conexão deve ser sempre realizada em uma thread separada da atividade principal.

 

Exemplo Aqui está um exemplo básico de uma thread que inicia uma conexão Bluetooth:

[sourcecode language=”java”]private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;

    public ConnectThread(BluetoothDevice device) {
        // Usar um objeto temporário que depois sera atribuído a mmSocket,

// porque mmSocket sera o valor final

BluetoothSocket tmp = null;
        mmDevice = device;

        // Obter uma BluetoothSocket para conectar com o BluetoothDevice dado

try {
            // MY_UUID é string UUID do aplicativo, também usado pelo código do servidor
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) { }
        mmSocket = tmp;
    }

    public void run() {
        // Cancelar descoberta porque irá desacelerar a conexão

mBluetoothAdapter.cancelDiscovery();

        try {
            // Conectar o dispositivo através do socket.

// Isto será bloqueado até ser bem sucedido ou lançar uma exceção</div>
<pre>mmSocket.connect();
        } catch (IOException connectException) {
            // Não foi possível conectar; fechar o soquete e sair
            try {
                mmSocket.close();
            } catch (IOException closeException) { }
            return;
        }

        // Gerenciar a conexão (em uma thread separada)
        manageConnectedSocket(mmSocket);
    }

    // Cancelar a conexão em andamento e fechar o socket
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }

[/sourcecode]

Observe que cancelDiscovery() é chamado antes que a conexão seja feita. Você deve sempre fazer isso antes de ligar e ele é seguro para chamar sem realmente verificar se ele está sendo executado ou não (mas se você quiser conferir, chame a isDiscovering ()).

manageConnectedSocket() é um método fictício do aplicativo que irá iniciar a discussão para a transferência de dados, que são discutidos na seção sobre a gestão de uma conexão .

Quando você é feito com seu BluetoothSocket , sempre chamar close() para limpar. Se o fizer, será imediatamente fechar o socket conectado e limpar todos os recursos internos.

7. Gerenciando uma conexão

Depois de ter conectado dois (ou mais) dispositivos, cada um terá uma conexão BluetoothSocket. Aqui é onde começa a diversão, pois você pode compartilhar dados entre dispositivos. Usando o BluetoothSocket, o procedimento geral para transferir dados arbitrários é simples:

1. Obter o InputStream e OutputStream que lidam com transmissões através do socket, através de getInputStream () e getOutputStream (), respectivamente.
2. Ler e gravar dados para os fluxos de read(byte []) e write(byte []).

É isso aí.

Há, obviamente, os detalhes de implementação a considerar. Em primeiro lugar, você deve usar uma linha dedicada para todos os fluxos de leitura e escrita. Isto é importante porque tanto read(byte []) e write(byte []) são métodos de bloqueio de chamadas. read(byte []) irá bloquear até que haja algo para ler a partir do fluxo. write(byte []) não costuma bloquear, mas pode bloquear para controle de fluxo se o dispositivo remoto não estiver chamando read(byte []) com rapidez suficiente e se os buffers intermediários estiverem cheios. Assim, o loop principal na thread deve ser dedicado à leitura do InputStream. Um método público separado na linha pode ser usado para iniciar escrita pela OutputStream .

Exemplo

Aqui está um exemplo de como isso pode parecer:

[sourcecode language=”java”]
private class ConnectedThread extends Thread {
private final BluetoothSocket mmSocket;
private final InputStream mmInStream;
private final OutputStream mmOutStream;

public ConnectedThread(BluetoothSocket socket) {
mmSocket = socket;
InputStream tmpIn = null;
OutputStream tmpOut = null;

// Obter os fluxos de entrada e saída usando objetos temporaries
// porque os fluxos membros são finais
try {
tmpIn = socket.getInputStream();
tmpOut = socket.getOutputStream();
} catch (IOException e) { }

mmInStream = tmpIn;
mmOutStream = tmpOut;
}

public void run() {
byte[] buffer = new byte[1024]; // buffer de memória para o fluxo
int bytes; // bytes returnados da read()

// Continuar obtendo o InputStream até ocorrer uma exceção
while (true) {
try {
// Leia a partir do InputStream
bytes = mmInStream.read(buffer);
// Envie os bytes obtidos com a atividade UI
mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer) .sendToTarget();
} catch (IOException e) {
break;
}
}
}

/* Chamar isso da atividade principal para enviar dados para o dispositivo remoto */
public void write(byte[] bytes) {
try {
mmOutStream.write(bytes);
} catch (IOException e) { }
}

/* Chamar isso da atividade principal para o desligamento da conexão */
public void cancel() {
try {
mmSocket.close();
} catch (IOException e) { }
}
}

[/sourcecode]

O construtor adquire os fluxos necessários e, uma vez executado, a thread esperará por dados que virão através do InputStream. Quando read(byte []) retorna com bytes do fluxo, os dados são enviados para a atividade principal usando um manipulador de membro da classe pai. Então ele irá voltar e aguardar mais bytes do fluxo.

Envio de dados de saída é simples; basta chamar a thread do método write() da atividade principal e passar os bytes a serem enviados. Este método, em seguida, simplesmente chama write(byte []) para enviar os dados para o dispositivo remoto.

A thread do método cancel() é importante para que a conexão possa ser rescindida a qualquer momento, mesmo fechando a BluetoothSocket . Este deve ser sempre chamado quando você terminar de usar a conexão Bluetooth.