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 le BluetoothAdapter. 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

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é le Bluetooth 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

    • Si les Broadcast Receiver vous sont pas familier, vous pouvez regarder cet article : BroadcastReceiver sous Android
    • 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 Bluetooth et accepter une connexion :

  • Récupérer une instance BluetoothServerSocket en appelant la méthode listenUsingRfcommWithServiceRecord
    • 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éthode createRfcommSocketToServiceRecord
  • 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.

Categories: Tutoriels

10 Responses so far.


  1. Sébastien dit :

    Bonjour,

    Je trouve le début du tuto simple et assez bien expliqué, en revanche côté client/serveur je trouve que le code manque de commentaire, de façon à ce que quelqu’un de débutant puisse bien comprendre le fonctionnement du code.

    À bon entendeur !

  2. Alban dit :

    Bonjour ….Comme d’habitude , je vous felicite pour vos SUPER TUTOS !!!
    Vraiment bien expliqués …
    Concernant le bluetooth, une petite question …lors d’une connection de telephone a un autre peripherique (une carte controleur par exemple) comment veriez vous la chose ? le serveur serait il le telephone ou le client ?
    en fait je me pose la question le controle d’une carte “arduino” ou la quantité de memoire est plutot reduite et le code java limité …Merci

  3. Thomas dit :

    Bonjour,

    J’aurai souhaité savoir comment, par exemple, envoyé un message texte via ce programme ?

    Merci

Leave a Reply


Notifiez-moi des commentaires à venir via email. Vous pouvez aussi vous abonner sans commenter.