Utilisation du Bluetooth dans une application Android

Ce tutoriel a pour but d’expliquer comment utiliser le bluetooth dans vos applications Android, ceci à travers l’API fournie par Android.

Android inclus un support du Bluetooth, ce qui permet aux devices de pouvoir échanger des données entre eux en utilisant cette technologie.

La Bluetooth API d’Android vous facilite l’utilisation de cette technologie dans vos applications. Elle vous permet de :

• Scanner les autres devices
• Lier facilement un device à un autre
• Transférer des données d’un device à un autre
• Gestion de la multiconnexion de devices

As-tu le Bluetooth ?

La première étape dans l’intégration du Bluetooth dans votre application est de vérifier si le device en question possède cette technologie.


Cela est très facile en utilisant l’API Bluetooth et plus particulièrement leBluetoothAdapter. Cette classe vous permet d’exécuter les fonctionnalités basiques, comme la vérification de la présence du bluetooth, lancer un scan des devices, etc…


Voici un petit bout de code qui vérifie la présence du bluetooth dans un device,etc ...


BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (bluetoothAdapter == null)
Toast.makeText(TutoBluetoothActivity.this, "Pas de Bluetooth",
Toast.LENGTH_SHORT).show();
else
Toast.makeText(TutoBluetoothActivity.this, "Avec Bluetooth",
Toast.LENGTH_SHORT).show();



Cet exemple, initialise un BluetoothAdapter. Il peut avoir deux valeurs :

• Une valeur Null : Le device ne possède pas la technologie Bluetooth
• Une valeur différente de Null : Le device possède le Bluetooth

Il ne faut pas oublier la permission d’utilisation du Bluetooth dans votre Manifest


<uses-permission android:name="android.permission.BLUETOOTH"/>

Veux-tu t’activer ?

La deuxième étape est d’activer le bluetooth si nécessaire, pour cela vous avez deux possibilités :
être gentil et demander à l’utilisateur de l’activer

• activer sans demander l’avis de l’utilisateur
• Auriez-vous la gentillesse d’activer le bluetooth s’il vous plaît ?

private final static int REQUEST_CODE_ENABLE_BLUETOOTH = 0;
….;
if (!bluetoothAdapter.isEnabled()) {
Intent enableBlueTooth = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBlueTooth, REQUEST_CODE_ENABLE_BLUETOOTH);
}


Tout ce que fait ce code, est de vérifier si le Bluetooth est déjà activé. Sinon il lancer une boite de dialogue pour demander à l’utilisateur d’activer le Bluetooth.


Il suffit de surcharger la méthode onActivityResult pour savoir si l’utilisateur a activé leBluetooth ou pas.



@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode != REQUEST_CODE_ENABLE_BLUETOOTH)
return;
if (resultCode == RESULT_OK) {
// L'utilisation a activé le bluetooth
} else {
// L'utilisation n'a pas activé le bluetooth
}
}


Vous-aurez besoin de la permission suivante



<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

Je l’active tout seul comme un grand


Voici le bout de code, qui vous permet d’activer le bluetooth sans l’avis de l’utilisateur

if (!bluetoothAdapter.isEnabled()) {
bluetoothAdapter.enable();
}

Obtenir la liste des devices déjà connus


Vous pouvez obtenir la liste des devices déja connus et ainsi la stocker pour une utilisation ultérieure ou pour vérifier si un de ces devices est connecté.


private Set<BluetoothDevice> devices;
devices = bluetoothAdapter.getBondedDevices();
for (BluetoothDevice blueDevice : devices) {
Toast.makeText(TutoBluetoothActivity.this, "Device = " + blueDevice.getName(), Toast.LENGTH_SHORT).show();
}

Recherche de nouveaux périphériques


Maintenant on va commencer à chercher si des périphériques non connus sont disponibles pour un eventuel échange.
Cette action s’effectue en plusieurs étapes :
Créer un Broadcast receiver qui sera avertit lors de la détection d’un nouveau terminal

Nous utilisons un Broadcast Receiver afin de recevoir l’événement qui se propage lorsqu’un nouveau device est détecté


private final BroadcastReceiver bluetoothReceiver = new BroadcastReceiver() {
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
Toast.makeText(TutoBluetoothActivity.this, "New Device = " + device.getName(), Toast.LENGTH_SHORT).show();
}
}
};

Enregistrer notre broadcast



IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(bluetoothReceiver, filter);

Lancer le scan grâce à la méthode startDiscovery

bluetoothAdapter.startDiscovery();


Attention, il ne faut surtout pas oublier que dans le « onDestroy » il faut :

• Arrêter la découverte des nouveaux devices
• Désabonner notre broadcast receiver

@Override
protected void onDestroy() {
super.onDestroy();
bluetoothAdapter.cancelDiscovery();
unregisterReceiver(bluetoothReceiver);
}

Suis-je visible ?

Pour que votre device puisse être trouvé et lié avec d’autres devices, il faut le rendre visible.
Pour cela il suffit d’utiliser le code suivant :



Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);


Le faite de donner une valeur BluetoothAdapter.EXTRA_DISCOVERABLE, spécifie combien de temps votre device sera détectable

• Si vous ne spécifiez pas de valeur, par défaut il sera détectable 120 secondes
• La valeur maximum est de 3600 secondes

Comment établir une connexion


Pour établir une connexion et échanger des données, il faut un côté serveur (device qui reçoit la connexion) et un côté client (device qui envoie la connexion)


Côté Serveur


Voici la liste des étapes nécessaires pour configurer une socket pour un Serveur Bluetoothet accepter une connexion :

• Récupérer une instance BluetoothServerSocket en appelant la méthodelistenUsingRfcommWithServiceRecord
• Le string est l’identifiant de votre service
• Attendre les connexion en appelant accept

Si vous souhaitez ne plus attendre de connexions appeler close

private class AcceptThread extends Thread {
private final BluetoothServerSocket mmServerSocket;


public AcceptThread() {
BluetoothServerSocket tmp = null;
try {
tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
} catch (IOException e) { }
mmServerSocket = tmp;
}


public void run() {
BluetoothSocket socket = null;
while (true) {
try {
socket = mmServerSocket.accept();
} catch (IOException e) {
break;
}


if (socket != null) {
manageConnectedSocket(socket);
mmServerSocket.close();
break;
}
}
}


public void cancel() {
try {
mmServerSocket.close();
} catch (IOException e) { }
}
}

Côté Client

Voici la liste des étapes nécessaires pour la connexion Bluetooth côté client :

• Récupérer une BluetoothSocket grâce à la méthodecreateRfcommSocketToServiceRecord
• Lancer la connexion en appelant connect()

private class ConnectThread extends Thread {
private final BluetoothSocket mmSocket;
private final BluetoothDevice mmDevice;


public ConnectThread(BluetoothDevice device) {
BluetoothSocket tmp = null;
mmDevice = device;
try {
tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
} catch (IOException e) { }
mmSocket = tmp;
}


public void run() {
mBluetoothAdapter.cancelDiscovery();
try {
mmSocket.connect();
} catch (IOException connectException) {
try {
mmSocket.close();
} catch (IOException closeException) { }
return;
}
manageConnectedSocket(mmSocket);
}


public void cancel() {
try {
mmSocket.close();
} catch (IOException e) { }
}


}

Conclusion


Voila cet article s’arrête ici, j’espére qu’il vous aura aidé à comprendre comment fonctionne l’API bluetooth sous Android. N’hésitez pas si vous avez des remarques ou des questions.