Pour créer une connexion entre deux appareils, vous devez implémenter les mécanismes côté serveur et côté client, car l'un des appareils doit ouvrir un socket serveur et l'autre doit initier la connexion à l'aide de l'adresse MAC de l'appareil serveur. L'appareil serveur et l'appareil client obtiennent chacun le BluetoothSocket requis de différentes manières. Le serveur reçoit les informations de socket lorsqu'une connexion entrante est acceptée. Le client fournit des informations sur le socket lorsqu'il ouvre un canal RFCOMM vers le serveur.
Le serveur et le client sont considérés comme connectés l'un à l'autre lorsqu'ils disposent chacun d'un BluetoothSocket connecté sur le même canal RFCOMM. À ce stade, chaque appareil peut obtenir des flux d'entrée et de sortie, et le transfert de données peut commencer, comme indiqué dans la section sur le transfert de données Bluetooth. Cette section explique comment initier la connexion entre deux appareils.
Assurez-vous de disposer des autorisations Bluetooth appropriées et de configurer votre application pour le Bluetooth avant d'essayer de trouver des appareils Bluetooth.
Techniques de connexion
Une technique d'implémentation consiste à préparer automatiquement chaque appareil en tant que serveur afin que chacun d'eux dispose d'un socket serveur ouvert et à l'écoute des connexions. Dans ce cas, l'un ou l'autre appareil peut établir une connexion avec l'autre et devenir le client. Un appareil peut également héberger explicitement la connexion et ouvrir un socket serveur à la demande, tandis que l'autre appareil initie la connexion.
Se connecter en tant que serveur
Lorsque vous souhaitez connecter deux appareils, l'un d'eux doit agir en tant que serveur en conservant un BluetoothServerSocket ouvert.
Le but du socket serveur est d'écouter les demandes de connexion entrantes et de fournir un BluetoothSocket connecté une fois qu'une demande est acceptée. Une fois que le BluetoothSocket est acquis à partir du BluetoothServerSocket, le BluetoothServerSocket peut (et doit) être supprimé, sauf si vous souhaitez que l'appareil accepte d'autres connexions.
Pour configurer un socket serveur et accepter une connexion, procédez comme suit :
Obtenez un
BluetoothServerSocketen appelantlistenUsingRfcommWithServiceRecord(String, UUID).La chaîne est un nom identifiable de votre service, que le système écrit automatiquement dans une nouvelle entrée de base de données SDP (Service Discovery Protocol) sur l'appareil. Le nom est arbitraire et peut simplement être le nom de votre application. L'identifiant unique universel (UUID) est également inclus dans l'entrée SDP et constitue la base de l'accord de connexion avec l'appareil client. Autrement dit, lorsque le client tente de se connecter à cet appareil, il transmet un UUID qui identifie de manière unique le service auquel il souhaite se connecter. Ces UUID doivent correspondre pour que la connexion soit acceptée.
Un UUID est un format 128 bits standardisé pour un ID de chaîne utilisé pour identifier des informations de manière unique. Un UUID permet d'identifier les informations qui doivent être uniques au sein d'un système ou d'un réseau, car la probabilité qu'un UUID soit répété est pratiquement nulle. Il est généré de manière indépendante, sans l'intervention d'une autorité centralisée. Dans ce cas, il permet d'identifier de manière unique le service Bluetooth de votre application. Pour obtenir un UUID à utiliser avec votre application, vous pouvez utiliser l'un des nombreux générateurs d'
UUIDaléatoires sur le Web, puis initialiser un UUID avecfromString(String).Commencez à écouter les demandes de connexion en appelant
accept().Il s'agit d'un appel bloquant. Elle est renvoyée lorsqu'une connexion a été acceptée ou qu'une exception s'est produite. Une connexion n'est acceptée que lorsqu'un appareil distant a envoyé une demande de connexion contenant un UUID correspondant à celui enregistré avec ce socket serveur d'écoute. En cas de réussite,
accept()renvoie unBluetoothSocketconnecté.Sauf si vous souhaitez accepter des connexions supplémentaires, appelez
close().Cet appel de méthode libère le socket serveur et toutes ses ressources, mais ne ferme pas le
BluetoothSocketconnecté qui a été renvoyé paraccept(). Contrairement à TCP/IP, RFCOMM n'autorise qu'un seul client connecté par canal à la fois. Dans la plupart des cas, il est donc judicieux d'appelerclose()surBluetoothServerSocketimmédiatement après avoir accepté un socket connecté.
L'appel accept() étant un appel bloquant, ne l'exécutez pas dans le thread UI de l'activité principale. L'exécuter dans un autre thread permet à votre application de continuer à répondre aux autres interactions de l'utilisateur. Il est généralement judicieux d'effectuer toutes les tâches impliquant un BluetoothServerSocket ou un BluetoothSocket dans un nouveau thread géré par votre application. Pour annuler un appel bloqué tel que accept(), appelez close() sur le BluetoothServerSocket ou le BluetoothSocket à partir d'un autre thread. Notez que toutes les méthodes d'un BluetoothServerSocket ou d'un BluetoothSocket sont thread-safe.
Exemple
Voici un thread simplifié pour le composant serveur qui accepte les connexions entrantes :
Kotlin
private inner class AcceptThread : Thread() { private val mmServerSocket: BluetoothServerSocket? by lazy(LazyThreadSafetyMode.NONE) { bluetoothAdapter?.listenUsingInsecureRfcommWithServiceRecord(NAME, MY_UUID) } override fun run() { // Keep listening until exception occurs or a socket is returned. var shouldLoop = true while (shouldLoop) { val socket: BluetoothSocket? = try { mmServerSocket?.accept() } catch (e: IOException) { Log.e(TAG, "Socket's accept() method failed", e) shouldLoop = false null } socket?.also { manageMyConnectedSocket(it) mmServerSocket?.close() shouldLoop = false } } } // Closes the connect socket and causes the thread to finish. fun cancel() { try { mmServerSocket?.close() } catch (e: IOException) { Log.e(TAG, "Could not close the connect socket", e) } } }
Java
private class AcceptThread extends Thread { private final BluetoothServerSocket mmServerSocket; public AcceptThread() { // Use a temporary object that is later assigned to mmServerSocket // because mmServerSocket is final. BluetoothServerSocket tmp = null; try { // MY_UUID is the app's UUID string, also used by the client code. tmp = bluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID); } catch (IOException e) { Log.e(TAG, "Socket's listen() method failed", e); } mmServerSocket = tmp; } public void run() { BluetoothSocket socket = null; // Keep listening until exception occurs or a socket is returned. while (true) { try { socket = mmServerSocket.accept(); } catch (IOException e) { Log.e(TAG, "Socket's accept() method failed", e); break; } if (socket != null) { // A connection was accepted. Perform work associated with // the connection in a separate thread. manageMyConnectedSocket(socket); mmServerSocket.close(); break; } } } // Closes the connect socket and causes the thread to finish. public void cancel() { try { mmServerSocket.close(); } catch (IOException e) { Log.e(TAG, "Could not close the connect socket", e); } } }
Dans cet exemple, une seule connexion entrante est souhaitée. Dès qu'une connexion est acceptée et que le BluetoothSocket est acquis, l'application transmet le BluetoothSocket acquis à un thread distinct, ferme le BluetoothServerSocket et sort de la boucle.
Notez que lorsque accept() renvoie BluetoothSocket, le socket est déjà connecté. Par conséquent, vous ne devez pas appeler connect(), comme vous le faites côté client.
La méthode manageMyConnectedSocket() spécifique à l'application est conçue pour lancer le thread de transfert de données, qui est abordé dans la section Transférer des données Bluetooth.
En règle générale, vous devez fermer votre BluetoothServerSocket dès que vous avez fini d'écouter les connexions entrantes. Dans cet exemple, close() est appelé dès que BluetoothSocket est acquis. Vous pouvez également fournir une méthode publique dans votre thread qui peut fermer le BluetoothSocket privé si vous devez arrêter l'écoute sur ce socket serveur.
Se connecter en tant que client
Pour établir une connexion avec un appareil distant qui accepte les connexions sur un socket serveur ouvert, vous devez d'abord obtenir un objet BluetoothDevice qui représente l'appareil distant. Pour savoir comment créer un BluetoothDevice, consultez Rechercher des appareils Bluetooth. Vous devez ensuite utiliser le BluetoothDevice pour acquérir un BluetoothSocket et lancer la connexion.
La procédure de base est la suivante :
À l'aide de
BluetoothDevice, obtenez unBluetoothSocketen appelantcreateRfcommSocketToServiceRecord(UUID).Cette méthode initialise un objet
BluetoothSocketqui permet au client de se connecter à unBluetoothDevice. L'UUID transmis ici doit correspondre à l'UUID utilisé par l'appareil serveur lorsqu'il a appelélistenUsingRfcommWithServiceRecord(String, UUID)pour ouvrir sonBluetoothServerSocket. Pour utiliser un UUID correspondant, codez en dur la chaîne UUID dans votre application, puis référencez-la à partir du code du serveur et du client.Établissez la connexion en appelant
connect(). Notez que cette méthode est un appel bloquant.Lorsqu'un client appelle cette méthode, le système effectue une recherche SDP pour trouver l'appareil distant avec l'UUID correspondant. Si la recherche aboutit et que l'appareil distant accepte la connexion, il partage le canal RFCOMM à utiliser pendant la connexion, et la méthode
connect()est renvoyée. Si la connexion échoue ou si la méthodeconnect()expire (après environ 12 secondes), la méthode génère une exceptionIOException.
Comme connect() est un appel bloquant, vous devez toujours effectuer cette procédure de connexion dans un thread distinct du thread d'activité principal (UI).
Exemple
Voici un exemple simple de thread client qui lance une connexion Bluetooth :
Kotlin
private inner class ConnectThread(device: BluetoothDevice) : Thread() { private val mmSocket: BluetoothSocket? by lazy(LazyThreadSafetyMode.NONE) { device.createRfcommSocketToServiceRecord(MY_UUID) } public override fun run() { // Cancel discovery because it otherwise slows down the connection. bluetoothAdapter?.cancelDiscovery() mmSocket?.let { socket -> // Connect to the remote device through the socket. This call blocks // until it succeeds or throws an exception. socket.connect() // The connection attempt succeeded. Perform work associated with // the connection in a separate thread. manageMyConnectedSocket(socket) } } // Closes the client socket and causes the thread to finish. fun cancel() { try { mmSocket?.close() } catch (e: IOException) { Log.e(TAG, "Could not close the client socket", e) } } }
Java
private class ConnectThread extends Thread { private final BluetoothSocket mmSocket; private final BluetoothDevice mmDevice; public ConnectThread(BluetoothDevice device) { // Use a temporary object that is later assigned to mmSocket // because mmSocket is final. BluetoothSocket tmp = null; mmDevice = device; try { // Get a BluetoothSocket to connect with the given BluetoothDevice. // MY_UUID is the app's UUID string, also used in the server code. tmp = device.createRfcommSocketToServiceRecord(MY_UUID); } catch (IOException e) { Log.e(TAG, "Socket's create() method failed", e); } mmSocket = tmp; } public void run() { // Cancel discovery because it otherwise slows down the connection. bluetoothAdapter.cancelDiscovery(); try { // Connect to the remote device through the socket. This call blocks // until it succeeds or throws an exception. mmSocket.connect(); } catch (IOException connectException) { // Unable to connect; close the socket and return. try { mmSocket.close(); } catch (IOException closeException) { Log.e(TAG, "Could not close the client socket", closeException); } return; } // The connection attempt succeeded. Perform work associated with // the connection in a separate thread. manageMyConnectedSocket(mmSocket); } // Closes the client socket and causes the thread to finish. public void cancel() { try { mmSocket.close(); } catch (IOException e) { Log.e(TAG, "Could not close the client socket", e); } } }
Notez que dans cet extrait, cancelDiscovery() est appelé avant la tentative de connexion. Vous devez toujours appeler cancelDiscovery() avant connect(), en particulier parce que cancelDiscovery() réussit, que la découverte d'appareils soit en cours ou non. Si votre application doit déterminer si la détection d'appareils est en cours, vous pouvez le vérifier à l'aide de isDiscovering().
La méthode manageMyConnectedSocket() spécifique à l'application est conçue pour lancer le thread de transfert de données, qui est abordé dans la section sur le transfert de données Bluetooth.
Lorsque vous avez terminé d'utiliser votre BluetoothSocket, appelez toujours close(). Cela ferme immédiatement le socket connecté et libère toutes les ressources internes associées.