Tutorial Android – Desenvolvendo com Bluetooth para comunicação veicular – Parte 2

On 11 de abril de 2014 by Fabio Oliveira de Paula

Este post é uma continuação.
Parte I: Tutorial Android – Desenvolvendo Com Bluetooth Para Comunicação Veicular

2. Configurando o Bluetooth

Antes do aplicativo comunicar através de Bluetooth, você precisa verificar se o Bluetooth é compatível com o dispositivo, em caso afirmativo, verifique se ele está habilitado.

Se o Bluetooth não é suportado, então você deve desativar quaisquer recursos de Bluetooth. Se o Bluetooth é suportado, mas está desativado, então você pode solicitar que o usuário ative o Bluetooth sem sair de sua aplicação. Esta configuração é realizada em duas etapas, utilizando o BluetoothAdapter.

2.1. Obter o BluetoothAdapter

O BluetoothAdapter é necessário para toda e qualquer atividade Bluetooth. Para obter o BluetoothAdapter , chame o método static getDefaultAdapter(). Isso retorna um BluetoothAdapter que representa um adaptador Bluetooth próprio do dispositivo. Se getDefaultAdapter() retorna nulo, então o dispositivo não suporta Bluetooth e sua história acaba aqui.

Por exemplo:

[sourcecode language=”java”]
BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (mBluetoothAdapter == null) {
// Dispositivo não suporta Bluetooth
}
[/sourcecode]

2.2. Ativar Bluetooth

Em seguida, você precisa se ​​certificar de que o Bluetooth está ativado. Chame isEnabled() para verificar se o Bluetooth está ativado. Se esse método retornar false, então o Bluetooth está desativado. Para solicitar que o Bluetooth seja ativado, chame startActivityForResult() com a Intent ACTION_REQUEST_ENABLE. Isso irá emitir um pedido para ativar o Bluetooth através das configurações do sistema (sem parar a sua aplicação).

Por exemplo:

[sourcecode language=”java”]
if (!mBluetoothAdapter.isEnabled()) {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
}
[/sourcecode]

Uma caixa de diálogo aparecerá solicitando permissão ao usuário, para permitir a ativação do Bluetooth, como mostrado na Figura 1. Se o usuário responder “Sim”, o sistema começará a ativar o Bluetooth e o foco voltará para a sua aplicação uma vez que o processo seja concluído (ou não).

fig1

Figura 1: A caixa de diálogo de habilitação do Bluetooth.

A constante passada como parâmetro REQUEST_ENABLE_BT para startActivityForResult () é um número inteiro definido localmente (que pode ser qualquer valor maior que 0), que o sistema passa de volta para você na sua aplicação onActivityResult() como o parâmetro requestCode.

Se for confirmada a permissão do Bluetooth, sua atividade recebe de retorno o código de resultado RESULT_OK  na onActivityResult(). Se o Bluetooth não foi ativado devido a um erro (ou o usuário respondeu “Não”), então o código de resultado é RESULT_CANCELED.

3. Consultando dispositivos pareados

Antes de realizar a descoberta de dispositivos, vale a pena consultar o conjunto de dispositivos pareados para ver se o dispositivo desejado já é conhecido. Para fazer isso, chame getBondedDevices() . Isso retornará um conjunto BluetoothDevice device que representam os dispositivos pareados. Por exemplo, você pode consultar todos os dispositivos pareados e em seguida, mostrar o nome de cada dispositivo para o usuário, utilizando um ArrayAdapter:

[sourcecode language=”java”]
Set pairedDevices = bluetoothAdapter.getBondedDevices();
if (pairedDevices.size() > 0) {
for (BluetoothDevice device : pairedDevices) {
String deviceBTName = device.getName();
String deviceBTAddress = device.getAddress();
btArrayAdapter.add(deviceBTName + "\n" + deviceBTAddress;
}
}
setListAdapter(btArrayAdapter);
[/sourcecode]

Aplicativo 2: Conectando a um dispositivo

Nesse aplicativo, faremos a conexão entre dois dispositivos. Depois de conectado, o aplicativo A envia um texto para o dispositivo B, que por sua vez, o reenvia ao dispositivo A.

O dispositivo A será o cliente, isto é, aquele responsável por buscar dispositivos e solicitar a conexão, e o dispositivo B será o servidor, aquele que escutará solicitações de conexão.

Para isso, iremos criar dois aplicativos, o cliente e o servidor.

Vamos começar pelo cliente. Ele terá 2 activities e 3 layouts XML.

Crie um novo Projeto, conforme as instruções abaixo:

Instruções para criar novo projeto:

1. Project Name e Application Name: à sua escolha;
2. Package Name: comunicacao.bluetooth;
3. Create Activity: AppBT2_clienteActivity;
4. Após criado o projeto, crie outra Activity com o nome DeviceListActivity.
5. Crie 2 layout (além do main.xml), com os nomes device_list.xml e device_name.xml;
6. Copie os códigos para as activities e layouts e Arquivo Manifest criados que estão abaixo.

AppBT2_clienteActivity.java

[sourcecode language=”java”]
package comunicacao.bluetooth;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;

import android.os.Bundle;
import android.app.Activity;
import android.widget.Toast;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;

public class AppBT2_clienteActivity extends Activity {

private final int REQUEST_CONNECT_DEVICE = 1;
private BluetoothAdapter meuAdaptadorBluetooth = null;

private BluetoothSocket mmSocket = null;
private BluetoothDevice mmDevice = null;

private InputStream mmInStream = null;
private OutputStream mmOutStream = null;

// Unique UUID for this application
private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

meuAdaptadorBluetooth = BluetoothAdapter.getDefaultAdapter();

// Launch the DeviceListActivity to see devices and do scan
Intent serverIntent = new Intent(this, DeviceListActivity.class);
startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);
}

public void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case REQUEST_CONNECT_DEVICE:
// When DeviceListActivity returns with a device to connect
if (resultCode == Activity.RESULT_OK) {
//Cancelar a descoberta
meuAdaptadorBluetooth.cancelDiscovery();

// Obtem o endereço do dispositivo
String address = data.getExtras().getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);
// Obtem o BluetoothDevice
mmDevice = meuAdaptadorBluetooth.getRemoteDevice(address);
try {
// Cria o socket utilizando o UUID
mmSocket = mmDevice.createRfcommSocketToServiceRecord(MY_UUID);
// Conecta ao dispositivo escolhido
mmSocket.connect();
// Obtem os fluxos de entrada e saida que lidam com transmissões através do socket
mmInStream = mmSocket.getInputStream();
mmOutStream = mmSocket.getOutputStream();

// Saida:
// Envio de uma mensagem pelo .write
String enviada = "Teste Rone";
byte[] send = enviada.getBytes();
mmOutStream.write(send);

// Entrada:
// bytes returnados da read()
int bytes;
// buffer de memória para o fluxo
byte[] read = new byte[1024];

// Continuar ouvindo o InputStream enquanto conectado
// O loop principal é dedicado a leitura do InputStream
while (true) {
try {
// Read from the InputStream
bytes = mmInStream.read(read);

String readMessage = new String(read);
Toast.makeText(this, readMessage, Toast.LENGTH_LONG).show();

} catch (IOException e) {
Toast.makeText(this, "Ocorreu um erro no recebimento da mensagem!", Toast.LENGTH_LONG).show();
}
}

}
catch(IOException e){
Toast.makeText(this, "Ocorreu um erro!", Toast.LENGTH_LONG).show();
}
}
break;
}
}
}
[/sourcecode]

DeviceListActivity.java

[sourcecode language=”java”]
package comunicacao.bluetooth;

import java.util.Set;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.Window;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.AdapterView.OnItemClickListener;

public class DeviceListActivity extends Activity {
// Debugging
private static final String TAG = "DeviceListActivity";
private static final boolean D = true;

// Return Intent extra
public static String EXTRA_DEVICE_ADDRESS = "device_address";

// Member fields
private BluetoothAdapter mBtAdapter;
private ArrayAdapter mPairedDevicesArrayAdapter;
private ArrayAdapter mNewDevicesArrayAdapter;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

// Setup the window
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.device_list);

// Set result CANCELED incase the user backs out
setResult(Activity.RESULT_CANCELED);

// Initialize the button to perform device discovery
Button scanButton = (Button) findViewById(R.id.button_scan);
scanButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
doDiscovery();
v.setVisibility(View.GONE);
}
});

// Initialize array adapters. One for already paired devices and
// one for newly discovered devices
mPairedDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);
mNewDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);

// Find and set up the ListView for paired devices
ListView pairedListView = (ListView) findViewById(R.id.paired_devices);
pairedListView.setAdapter(mPairedDevicesArrayAdapter);
pairedListView.setOnItemClickListener(mDeviceClickListener);

// Find and set up the ListView for newly discovered devices
ListView newDevicesListView = (ListView) findViewById(R.id.new_devices);
newDevicesListView.setAdapter(mNewDevicesArrayAdapter);
newDevicesListView.setOnItemClickListener(mDeviceClickListener);

// Register for broadcasts when a device is discovered
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
this.registerReceiver(mReceiver, filter);

// Register for broadcasts when discovery has finished
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
this.registerReceiver(mReceiver, filter);

// Get the local Bluetooth adapter
mBtAdapter = BluetoothAdapter.getDefaultAdapter();

// Get a set of currently paired devices
Set pairedDevices = mBtAdapter.getBondedDevices();

// If there are paired devices, add each one to the ArrayAdapter
if (pairedDevices.size() > 0) {
findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
for (BluetoothDevice device : pairedDevices) {
mPairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
}
} else {
mPairedDevicesArrayAdapter.add("Nenhum dispositivo pareado");
}
}

@Override
protected void onDestroy() {
super.onDestroy();

// Make sure we’re not doing discovery anymore
if (mBtAdapter != null) {
mBtAdapter.cancelDiscovery();
}

// Unregister broadcast listeners
this.unregisterReceiver(mReceiver);
}

/**
* Start device discover with the BluetoothAdapter
*/
private void doDiscovery() {
if (D) Log.d(TAG, "doDiscovery()");

// Indicate scanning in the title
setProgressBarIndeterminateVisibility(true);
setTitle("Scaneando");

// Turn on sub-title for new devices
findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);

// If we’re already discovering, stop it
if (mBtAdapter.isDiscovering()) {
mBtAdapter.cancelDiscovery();
}

// Request discover from BluetoothAdapter
mBtAdapter.startDiscovery();
}

// The on-click listener for all devices in the ListViews
private OnItemClickListener mDeviceClickListener = new OnItemClickListener() {
public void onItemClick(AdapterView<?> av, View v, int arg2, long arg3) {
// Cancel discovery because it’s costly and we’re about to connect
mBtAdapter.cancelDiscovery();

// Get the device MAC address, which is the last 17 chars in the View
String info = ((TextView) v).getText().toString();
String address = info.substring(info.length() – 17);

// Create the result Intent and include the MAC address
Intent intent = new Intent();
intent.putExtra(EXTRA_DEVICE_ADDRESS, address);

// Set result and finish this Activity
setResult(Activity.RESULT_OK, intent);
finish();
}
};

// The BroadcastReceiver that listens for discovered devices and
// changes the title when discovery is finished
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();

// When discovery finds a device
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
// Get the BluetoothDevice object from the Intent
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
// If it’s already paired, skip it, because it’s been listed already
if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
mNewDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
}
// When discovery is finished, change the Activity title
} else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
setProgressBarIndeterminateVisibility(false);
setTitle("Selecione o dispositivo");
if (mNewDevicesArrayAdapter.getCount() == 0) {

mNewDevicesArrayAdapter.add("Nao encontrado");
}
}
}
};
}
[/sourcecode]

main.xml

[sourcecode language=”xml”]
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
</LinearLayout>
[/sourcecode]

device_name.xml

[sourcecode language=”xml”]
<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="18sp"
android:padding="5dp"
/>
[/sourcecode]

device_list.xml

[sourcecode language=”xml”]
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
>
<TextView android:id="@+id/title_paired_devices"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Dispositivos pareados"
android:visibility="gone"
android:background="#666"
android:textColor="#fff"
android:paddingLeft="5dp"
/>
<ListView android:id="@+id/paired_devices"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:stackFromBottom="true"
android:layout_weight="1"
/>
<TextView android:id="@+id/title_new_devices"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Outros dispositivos encontrados"
android:visibility="gone"
android:background="#666"
android:textColor="#fff"
android:paddingLeft="5dp"
/>
<ListView android:id="@+id/new_devices"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:stackFromBottom="true"
android:layout_weight="2"
/>
<Button android:id="@+id/button_scan"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Procurar dispositivos"
/>
</LinearLayout>
[/sourcecode]

ArquivoManifest.xml

[sourcecode language=”xml”]
<?xml version="1.0" encoding="UTF-8"?>
<manifest android:versionCode="1" android:versionName="1.0"
package="comunicacao.bluetooth" xmlns:android="http://schemas.android.com/apk/res/android">
<uses-sdk android:minSdkVersion="7"/>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<application android:icon="@drawable/ic_launcher" android:label="@string/app_name">
<activity android:label="@string/app_name" android:name=".AppBT2_clienteActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
<activity android:name=".DeviceListActivity"/>
</application>
</manifest>

[/sourcecode]

Agora vamos criar o servidor. Ele terá apenas a activity e 1 layout XML.

Crie um novo Projeto, conforme as instruções abaixo:

Instruções para criar novo projeto:

1. Project Name e Application Name: à sua escolha;
2. Package Name: comunicacao.bluetooth;
3. Create Activity: AppBT2_servidorActivity;
4. Copie os códigos para as activities e layouts e Arquivo Manifest criados que estão abaixo.

AppBT2_servidorActivity.java

[sourcecode language=”java”]
package comunicacao.bluetooth;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class AppBT2_servidorActivity extends Activity {
/** Called when the activity is first created. */

private static final int REQUEST_ENABLE_BT = 1;
private BluetoothAdapter meuAdaptadorBluetooth = null;
private BluetoothServerSocket mmServerSocket;
private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");

// Name for the SDP record when creating server socket
private static final String NAME = "AppBT2_servidor";
private int mState;

// Constants that indicate the current connection state
// Cria contanstes de estado
public static final int STATE_CONNECTING = 1; // now initiating an outgoing connection
public static final int STATE_CONNECTED = 2; // now connected to a remote device

private InputStream mmInStream = null;
private OutputStream mmOutStream = null;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Button mMakeDiscoverable = (Button)findViewById(R.id.bdiscoverable);
mMakeDiscoverable.setOnClickListener(new clicker());

meuAdaptadorBluetooth = BluetoothAdapter.getDefaultAdapter();

// Testa disponibilidade do Bluetooth no dispositivo
if (meuAdaptadorBluetooth == null) {
Toast.makeText(this, "Bluetooth não disponivel", Toast.LENGTH_LONG).show();
finish();
return;
}
// Se Não BT habilitado, solicita habilitar
if (!meuAdaptadorBluetooth.isEnabled()) {
Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableIntent, REQUEST_ENABLE_BT);
}

}
class clicker implements View.OnClickListener{
@Override
public void onClick(View v) {

if(v.getId()==R.id.bdiscoverable){
if (meuAdaptadorBluetooth.getScanMode() != BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);
}
}
}
}
public void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (requestCode) {
case REQUEST_ENABLE_BT:
// When the request to enable Bluetooth returns
if (resultCode == Activity.RESULT_OK) {
// Bluetooth agora está habilidado
// Escuta da solicitação de conexão
try {
// Cria o socket utilizando o UUID
mmServerSocket = meuAdaptadorBluetooth.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);

// This is a blocking call and will only return on a
// successful connection or an exception
BluetoothSocket mmSocket = mmServerSocket.accept();

// If a connection was accepted
if (mmSocket != null) {
synchronized (AppBT2_servidorActivity.this) {
switch (mState) {
case STATE_CONNECTING:
// Situation normal. Start the connected thread.
try {

// Obtem os fluxos de entrada e saida que lidam com transmissões através do socket
mmInStream = mmSocket.getInputStream();
mmOutStream = mmSocket.getOutputStream();

// Entrada:
// bytes returnados da read()
int bytes;
// buffer de memória para o fluxo
byte[] read = new byte[1024];

// Continuar ouvindo o InputStream enquanto conectado
// O loop principal é dedicado a leitura do InputStream
while (true) {
try {
// Read from the InputStream
bytes = mmInStream.read(read);
String readMessage = new String(read);
Toast.makeText(this, readMessage, Toast.LENGTH_LONG).show();

// Reenvio da mensagem
byte[] send = readMessage.getBytes();
mmOutStream.write(send);

} catch (IOException e) {
Toast.makeText(this, "Ocorreu um erro na transmissão da mensagem!", Toast.LENGTH_LONG).show();
}
}

}
catch(IOException e){
Toast.makeText(this, "Ocorreu um erro!", Toast.LENGTH_LONG).show();
}

break;
case STATE_CONNECTED:
// Either not ready or already connected. Terminate new socket.
try {
mmSocket.close();
} catch (IOException e) {
Toast.makeText(this, "Nao foi possivel fechar o socket!", Toast.LENGTH_LONG).show();
}
break;
}
}
}

}
catch(IOException e){
Toast.makeText(this, "Ocorreu um erro!", Toast.LENGTH_LONG).show();
}

} else {
// User did not enable Bluetooth or an error occured
Toast.makeText(this, "Bluetooth não habilitado corretamente", Toast.LENGTH_SHORT).show();
finish();
}
}
}
}
[/sourcecode]

main.xml

[sourcecode language=”xml”]
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >

<Button
android:id="@+id/bdiscoverable"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Tornar-se visível" />

</LinearLayout>
[/sourcecode]

ArquivoManifest.xml

[sourcecode language=”xml”]
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="comunicacao.bluetooth"
android:versionCode="1"
android:versionName="1.0" >

<uses-sdk android:minSdkVersion="7" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH" />

<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:name=".AppBT2_servidorActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>

</manifest>
[/sourcecode]

Analisando o código:

Descobrindo dispositivos

Para iniciar a descoberta de dispositivos, basta chamar o startDiscovery() . O método retornará imediatamente uma variável booleana que indica se a descoberta foi iniciada com êxito.

Seu aplicativo deve registrar um BroadcastReceiver para a Intent ACTION_FOUND, a fim de receber informações sobre cada dispositivo descoberto. Para cada dispositivo, o sistema transmitirá a Intent ACTION_FOUND. Esta intent transporta os campos extra EXTRA_DEVICE e EXTRA_CLASS , contendo o BluetoothDevice e o BluetoothClass, respectivamente. Exemplo:

[sourcecode language=”java”]
// Criar um BroadcastReceiver para ACTION_FOUND
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {

public void onReceive(Context context, Intent intent) {

String action = intent.getAction();
// Quando um dispositivo for encontrado
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
// Obter o BluetoothDevice vindo pela Intent
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
// Adicionar o nome e endereço ao array adapter para mostrar na ListView
mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
}
}
};
// Registrar o BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter);
// Não esquecer de cancelar o registro durante a classe onDestroy

[/sourcecode]

Tudo que é necessário passar ao BluetoothDevice, a fim de iniciar uma conexão, é o endereço MAC. Neste exemplo, é guardado uma parte do ArrayAdapter que é mostrada ao usuário. Para mais informações sobre como criar uma conexão, em Conexão de dispositivos, a ser postado em breve.

Atenção: Realizar a descoberta do dispositivo é um procedimento pesado para o adaptador Bluetooth e vai consumir muito de seus recursos. Depois de ter encontrado um dispositivo para conectar-se, é certo que você sempre pare a descoberta com cancelDiscovery() antes de tentar uma conexão. Além disso, estar conectado a um dispositivo e executar a descoberta de outro reduzirá significativamente a largura de banda disponível para a conexão. Você deve desconectar com um dispositivo para executar a descoberta de outro.

Summary
Tutorial Android – Desenvolvendo com Bluetooth para comunicação veicular – Parte 2
Article Name
Tutorial Android – Desenvolvendo com Bluetooth para comunicação veicular – Parte 2
Description
Tutorial Android – Desenvolvendo com Bluetooth para comunicação veicular – Parte 2
Author
Publisher Name
iMobilis
Publisher Logo

3 Responses to “Tutorial Android – Desenvolvendo com Bluetooth para comunicação veicular – Parte 2”

  • Boa tarde Fabio, tudo bem?

    você sabe me informar qual o trecho de código que eu ativo o Bluetooth diretamente sem a necessidade de clicar em “Yes” quando for solicitado o Request?
    sendo mais claro, eu dou um clique em algum Button e esse Button já ativa o Bluetooth diretamente.

    valeu Fabio, muito bom o seu exemplo!!

    • Segue código para ativar sem a necessidade do YES.

      public void ativarBluetooth(){
      BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
      if(!mBluetoothAdapter.isEnabled()) {
      mBluetoothAdapter.enable();
      }
      }

      public void desativaBluetooth(){
      BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
      if(mBluetoothAdapter.isEnabled()) {
      mBluetoothAdapter.disable();
      }
      }

  • Na linha 89 do DeviceListActivity:
    “for (BluetoothDevice device : pairedDevices)”
    da erro de compilação, fala que esperava um objeto, mas encontrou um BluetoothDevice.
    Como corrigir isso?

Deixe um comentário

O seu endereço de e-mail não será publicado.