Bluetooth-Geräte verbinden

Wenn du eine Verbindung zwischen zwei Geräten herstellen möchtest, musst du sowohl die serverseitigen als auch die clientseitigen Mechanismen implementieren, da ein Gerät einen Server-Socket öffnen und das andere die Verbindung über die MAC-Adresse des Servergeräts initiieren muss. Das Servergerät und das Clientgerät rufen die erforderliche BluetoothSocket auf unterschiedliche Weise ab. Der Server empfängt Socket-Informationen, wenn eine eingehende Verbindung akzeptiert wird. Der Client stellt Socket-Informationen bereit, wenn er einen RFCOMM-Kanal zum Server öffnet.

Der Server und der Client gelten als miteinander verbunden, wenn beide ein verbundenes BluetoothSocket auf demselben RFCOMM-Kanal haben. An diesem Punkt kann jedes Gerät Eingabe- und Ausgabestreams abrufen und die Datenübertragung kann beginnen. Dies wird im Abschnitt Bluetooth-Daten übertragen erläutert. In diesem Abschnitt wird beschrieben, wie Sie die Verbindung zwischen zwei Geräten herstellen.

Achten Sie darauf, dass Sie die entsprechenden Bluetooth-Berechtigungen haben und Ihre App für Bluetooth eingerichtet haben, bevor Sie versuchen, Bluetooth-Geräte zu finden.

Verbindungstechniken

Eine Implementierungstechnik besteht darin, jedes Gerät automatisch als Server vorzubereiten, sodass auf jedem Gerät ein Server-Socket geöffnet ist und auf Verbindungen wartet. In diesem Fall kann jedes Gerät eine Verbindung mit dem anderen herstellen und zum Client werden. Alternativ kann ein Gerät die Verbindung explizit hosten und bei Bedarf einen Server-Socket öffnen, während das andere Gerät die Verbindung initiiert.

Das Dialogfeld für die Bluetooth-Kopplung, in dem der Nutzer aufgefordert wird, ein Gerät zu koppeln.
Abbildung 1. Das Dialogfeld für die Bluetooth-Kopplung.

Als Server verbinden

Wenn du zwei Geräte verbinden möchtest, muss eines als Server fungieren und einen offenen BluetoothServerSocket haben. Der Server-Socket dient dazu, auf eingehende Verbindungsanfragen zu warten und nach Annahme einer Anfrage einen verbundenen BluetoothSocket bereitzustellen. Wenn der BluetoothSocket vom BluetoothServerSocket abgerufen wird, kann und sollte der BluetoothServerSocket verworfen werden, es sei denn, das Gerät soll weitere Verbindungen akzeptieren.

Führe die folgenden Schritte aus, um einen Server-Socket einzurichten und eine Verbindung zu akzeptieren:

  1. Rufen Sie listenUsingRfcommWithServiceRecord(String, UUID) auf, um ein BluetoothServerSocket-Objekt zu erhalten.

    Der String ist ein identifizierbarer Name deines Dienstes, den das System automatisch in einen neuen SDP-Datenbankeintrag (Service Discovery Protocol) auf dem Gerät schreibt. Der Name ist beliebig und kann einfach der Name Ihrer App sein. Der Universally Unique Identifier (UUID) ist ebenfalls im SDP-Eintrag enthalten und bildet die Grundlage für die Verbindungsvereinbarung mit dem Clientgerät. Wenn der Client versucht, eine Verbindung zu diesem Gerät herzustellen, enthält er eine UUID, die den Dienst, mit dem er eine Verbindung herstellen möchte, eindeutig identifiziert. Diese UUIDs müssen übereinstimmen, damit die Verbindung akzeptiert wird.

    Eine UUID ist ein standardisiertes 128-Bit-Format für eine String-ID, mit der Informationen eindeutig identifiziert werden. Eine UUID wird verwendet, um Informationen zu identifizieren, die innerhalb eines Systems oder Netzwerks eindeutig sein müssen, da die Wahrscheinlichkeit, dass eine UUID wiederholt wird, praktisch null ist. Sie wird unabhängig und ohne eine zentrale Instanz generiert. In diesem Fall wird sie verwendet, um den Bluetooth-Dienst Ihrer App eindeutig zu identifizieren. Wenn Sie eine UUID für Ihre App benötigen, können Sie einen der vielen zufälligen UUID-Generatoren im Web verwenden und dann eine UUID mit fromString(String) initialisieren.

  2. Rufen Sie accept() auf, um auf Verbindungsanfragen zu warten.

    Dies ist ein blockierender Aufruf. Sie wird zurückgegeben, wenn entweder eine Verbindung akzeptiert wurde oder eine Ausnahme aufgetreten ist. Eine Verbindung wird nur akzeptiert, wenn ein Remote-Gerät eine Verbindungsanfrage mit einer UUID gesendet hat, die mit der auf diesem überwachenden Server-Socket registrierten UUID übereinstimmt. Bei Erfolg gibt accept() eine verbundene BluetoothSocket zurück.

  3. Wenn Sie keine weiteren Verbindungen akzeptieren möchten, rufen Sie close() auf.

    Durch diesen Methodenaufruf werden der Server-Socket und alle zugehörigen Ressourcen freigegeben. Der verbundene BluetoothSocket, der von accept() zurückgegeben wurde, wird jedoch nicht geschlossen. Im Gegensatz zu TCP/IP ist bei RFCOMM nur ein verbundener Client pro Kanal gleichzeitig zulässig. Daher ist es in den meisten Fällen sinnvoll, close() für BluetoothServerSocket aufzurufen, unmittelbar nachdem ein verbundener Socket akzeptiert wurde.

Da der accept()-Aufruf ein blockierender Aufruf ist, darf er nicht im UI-Thread der Hauptaktivität ausgeführt werden. Wenn Sie sie in einem anderen Thread ausführen, kann Ihre App weiterhin auf andere Nutzerinteraktionen reagieren. Es ist in der Regel sinnvoll, alle Arbeiten, die einen BluetoothServerSocket oder BluetoothSocket beinhalten, in einem neuen Thread auszuführen, der von Ihrer App verwaltet wird. Wenn Sie einen blockierten Aufruf wie accept() abbrechen möchten, rufen Sie close() für den BluetoothServerSocket oder BluetoothSocket aus einem anderen Thread auf. Beachten Sie, dass alle Methoden für BluetoothServerSocket oder BluetoothSocket threadsicher sind.

Beispiel

Im Folgenden finden Sie einen vereinfachten Thread für die Serverkomponente, die eingehende Verbindungen akzeptiert:

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);
       }
   }
}

In diesem Beispiel ist nur eine eingehende Verbindung gewünscht. Sobald eine Verbindung akzeptiert und der BluetoothSocket abgerufen wurde, übergibt die App den abgerufenen BluetoothSocket an einen separaten Thread, schließt den BluetoothServerSocket und bricht die Schleife ab.

Wenn accept() den BluetoothSocket zurückgibt, ist der Socket bereits verbunden. Daher sollten Sie connect() nicht wie auf der Clientseite aufrufen.

Die App-spezifische Methode manageMyConnectedSocket() ist so konzipiert, dass sie den Thread für die Datenübertragung initiiert. Dies wird im Thema Bluetooth-Daten übertragen erläutert.

Normalerweise sollten Sie den BluetoothServerSocket schließen, sobald Sie keine eingehenden Verbindungen mehr erwarten. In diesem Beispiel wird close() aufgerufen, sobald die BluetoothSocket abgerufen wurde. Möglicherweise möchten Sie auch eine öffentliche Methode in Ihrem Thread bereitstellen, mit der der private BluetoothSocket geschlossen werden kann, falls Sie das Abhören dieses Server-Sockets beenden müssen.

Als Client verbinden

Wenn Sie eine Verbindung mit einem Remote-Gerät herstellen möchten, das Verbindungen über einen offenen Server-Socket akzeptiert, müssen Sie zuerst ein BluetoothDevice-Objekt abrufen, das das Remote-Gerät darstellt. Informationen zum Erstellen eines BluetoothDevice finden Sie unter Bluetooth-Geräte finden. Anschließend müssen Sie die BluetoothDevice verwenden, um eine BluetoothSocket abzurufen und die Verbindung zu initiieren.

Das grundlegende Verfahren sieht so aus:

  1. Rufen Sie mit dem BluetoothDevice ein BluetoothSocket ab, indem Sie createRfcommSocketToServiceRecord(UUID) aufrufen.

    Mit dieser Methode wird ein BluetoothSocket-Objekt initialisiert, mit dem der Client eine Verbindung zu einem BluetoothDevice herstellen kann. Die hier übergebene UUID muss mit der UUID übereinstimmen, die vom Servergerät beim Aufruf von listenUsingRfcommWithServiceRecord(String, UUID) zum Öffnen des BluetoothServerSocket verwendet wurde. Wenn Sie eine übereinstimmende UUID verwenden möchten, hartcodieren Sie den UUID-String in Ihre App und verweisen Sie dann sowohl im Server- als auch im Clientcode darauf.

  2. Stellen Sie die Verbindung her, indem Sie connect() aufrufen. Diese Methode ist ein blockierender Aufruf.

    Nachdem ein Client diese Methode aufgerufen hat, führt das System eine SDP-Suche durch, um das Remote-Gerät mit der übereinstimmenden UUID zu finden. Wenn die Suche erfolgreich ist und das Remote-Gerät die Verbindung akzeptiert, gibt es den RFCOMM-Kanal frei, der während der Verbindung verwendet werden soll, und die Methode connect() wird zurückgegeben. Wenn die Verbindung fehlschlägt oder die Methode connect() ein Zeitlimit überschreitet (nach etwa 12 Sekunden), gibt die Methode einen IOException aus.

Da connect() ein blockierender Aufruf ist, sollten Sie diesen Verbindungsvorgang immer in einem Thread ausführen, der vom Hauptaktivitäts-Thread (UI-Thread) getrennt ist.

Beispiel

Hier ist ein einfaches Beispiel für einen Client-Thread, der eine Bluetooth-Verbindung initiiert:

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);
       }
   }
}

In diesem Snippet wird cancelDiscovery() vor dem Verbindungsversuch aufgerufen. Du solltest immer cancelDiscovery() vor connect() aufrufen, insbesondere weil cancelDiscovery() unabhängig davon erfolgreich ist, ob die Gerätesuche gerade läuft. Wenn deine App ermitteln muss, ob die Geräteerkennung gerade läuft, kannst du das mit isDiscovering() prüfen.

Die App-spezifische Methode manageMyConnectedSocket() dient dazu, den Thread für die Datenübertragung zu initiieren. Dies wird im Abschnitt Bluetooth-Daten übertragen erläutert.

Wenn du mit deinem BluetoothSocket fertig bist, rufe immer close() auf. Dadurch wird der verbundene Socket sofort geschlossen und alle zugehörigen internen Ressourcen werden freigegeben.