Łączenie urządzeń Bluetooth

Aby utworzyć połączenie między 2 urządzeniami, musisz zaimplementować mechanizmy zarówno po stronie serwera, jak i po stronie klienta, ponieważ jedno urządzenie musi otworzyć gniazdo serwera, a drugie musi zainicjować połączenie przy użyciu adresu MAC urządzenia serwera. Urządzenie serwerowe i urządzenie klienckie uzyskują wymagany BluetoothSocket na różne sposoby. Serwer otrzymuje informacje o gnieździe, gdy zaakceptowane zostanie połączenie przychodzące. Klient podaje informacje o gnieździe, gdy otwiera kanał RFCOMM do serwera.

Serwer i klient są uważane za połączone, gdy każdy z nich ma połączony element BluetoothSocket na tym samym kanale RFCOMM. W tym momencie każde urządzenie może uzyskać strumienie wejściowe i wyjściowe, a przesyłanie danych może się rozpocząć. Zostało to omówione w sekcji dotyczącej przesyłania danych przez Bluetooth. W tej sekcji opisano, jak zainicjować połączenie między 2 urządzeniami.

Zanim spróbujesz znaleźć urządzenia Bluetooth, upewnij się, że masz odpowiednie uprawnienia Bluetooth i skonfiguruj aplikację pod kątem Bluetootha.

Techniki połączeń

Jedną z technik implementacji jest automatyczne przygotowanie każdego urządzenia jako serwera, tak aby każde urządzenie miało otwarte gniazdo serwera i nasłuchiwało połączeń. W takim przypadku każde z urządzeń może zainicjować połączenie z drugim i stać się klientem. Można też skonfigurować jedno urządzenie jako hosta połączenia i otworzyć gniazdo serwera na żądanie, a drugie urządzenie zainicjuje połączenie.

Okno parowania Bluetooth z prośbą o sparowanie z urządzeniem.
Rysunek 1. Okno parowania Bluetooth.

Łączenie jako serwer

Jeśli chcesz połączyć 2 urządzenia, jedno z nich musi działać jako serwer, utrzymując otwarty obiekt BluetoothServerSocket. Gniazdo serwera służy do nasłuchiwania przychodzących żądań połączenia i udostępniania połączonego obiektu BluetoothSocket po zaakceptowaniu żądania. Po uzyskaniu BluetoothSocket z BluetoothServerSocket można (i należy) odrzucić BluetoothServerSocket, chyba że chcesz, aby urządzenie akceptowało więcej połączeń.

Aby skonfigurować gniazdo serwera i zaakceptować połączenie, wykonaj te czynności:

  1. Aby uzyskać BluetoothServerSocket, zadzwoń pod numer listenUsingRfcommWithServiceRecord(String, UUID).

    Ciąg znaków to możliwa do zidentyfikowania nazwa usługi, którą system automatycznie zapisuje w nowym wpisie bazy danych protokołu wykrywania usług (SDP) na urządzeniu. Nazwa jest dowolna i może być po prostu nazwą aplikacji. Uniwersalny unikalny identyfikator (UUID) jest również uwzględniony we wpisie SDP i stanowi podstawę umowy o połączeniu z urządzeniem klienta. Oznacza to, że gdy klient próbuje połączyć się z tym urządzeniem, ma identyfikator UUID, który jednoznacznie identyfikuje usługę, z którą chce się połączyć. Aby połączenie zostało zaakceptowane, te identyfikatory UUID muszą być zgodne.

    UUID to standardowy 128-bitowy format identyfikatora ciągu znaków, który służy do jednoznacznej identyfikacji informacji umożliwiających identyfikację. Identyfikator UUID służy do identyfikowania informacji, które muszą być unikalne w systemie lub sieci, ponieważ prawdopodobieństwo powtórzenia się identyfikatora UUID jest praktycznie zerowe. Jest generowany niezależnie, bez użycia scentralizowanego urzędu. W tym przypadku służy on do jednoznacznego identyfikowania usługi Bluetooth aplikacji. Aby uzyskać identyfikator UUID do użycia w aplikacji, możesz skorzystać z jednego z wielu generatorów losowych identyfikatorów UUID dostępnych w internecie, a następnie zainicjować identyfikator UUID za pomocą fromString(String).

  2. Zacznij nasłuchiwać próśb o połączenie, wywołując metodę accept().

    To jest wywołanie blokujące. Zwraca wartość, gdy połączenie zostanie zaakceptowane lub wystąpi wyjątek. Połączenie jest akceptowane tylko wtedy, gdy urządzenie zdalne wysłało prośbę o połączenie zawierającą identyfikator UUID, który pasuje do identyfikatora zarejestrowanego w tym gnieździe serwera nasłuchującego. Jeśli operacja się powiedzie, accept() zwróci połączony zasób BluetoothSocket.

  3. Jeśli nie chcesz akceptować dodatkowych połączeń, wywołaj close().

    To wywołanie metody zwalnia gniazdo serwera i wszystkie jego zasoby, ale nie zamyka połączonego gniazda BluetoothSocket zwróconego przez accept(). W przeciwieństwie do TCP/IP protokół RFCOMM zezwala na połączenie tylko jednego klienta na kanał naraz, więc w większości przypadków warto wywołać metodę close() w BluetoothServerSocket natychmiast po zaakceptowaniu połączonego gniazda.

Wywołanie accept() jest wywołaniem blokującym, więc nie wykonuj go w głównym wątku UI aktywności. Wykonanie go w innym wątku gwarantuje, że aplikacja będzie mogła nadal reagować na inne interakcje użytkownika. Zwykle warto wykonywać wszystkie zadania, które obejmują BluetoothServerSocket lub BluetoothSocket, w nowym wątku zarządzanym przez aplikację. Aby przerwać zablokowane wywołanie, takie jak accept(), wywołaj close() w BluetoothServerSocket lub BluetoothSocket z innego wątku. Pamiętaj, że wszystkie metody w BluetoothServerSocket lub BluetoothSocket są wątkowo bezpieczne.

Przykład

Poniżej znajduje się uproszczony wątek komponentu serwera, który akceptuje połączenia przychodzące:

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

W tym przykładzie potrzebne jest tylko 1 połączenie przychodzące, więc gdy tylko połączenie zostanie zaakceptowane i zostanie uzyskany obiekt BluetoothSocket, aplikacja przekazuje go BluetoothSocket do osobnego wątku, zamyka obiekt BluetoothServerSocket i przerywa pętlę.

Pamiętaj, że gdy accept() zwraca BluetoothSocket, gniazdo jest już połączone. Dlatego nie należy wywoływać metody connect(), tak jak po stronie klienta.

Metoda manageMyConnectedSocket(), która jest specyficzna dla aplikacji, służy do inicjowania wątku przesyłania danych. Zostało to omówione w temacie dotyczącym przesyłania danych przez Bluetooth.

Zwykle należy zamknąć BluetoothServerSocket, gdy tylko zakończysz nasłuchiwanie połączeń przychodzących. W tym przykładzie funkcja close() jest wywoływana, gdy tylko zostanie uzyskany obiekt BluetoothSocket. Możesz też udostępnić w wątku metodę publiczną, która może zamknąć prywatny obiekt BluetoothSocket, jeśli chcesz przestać nasłuchiwać na tym gnieździe serwera.

Łączenie jako klient

Aby zainicjować połączenie z urządzeniem zdalnym, które akceptuje połączenia na otwartym gnieździe serwera, musisz najpierw uzyskać obiekt BluetoothDevice reprezentujący urządzenie zdalne. Aby dowiedzieć się, jak utworzyć BluetoothDevice, przeczytaj artykuł Znajdowanie urządzeń Bluetooth. Następnie musisz użyć BluetoothDevice, aby uzyskać BluetoothSocket i nawiązać połączenie.

Podstawowa procedura wygląda tak:

  1. Korzystając z BluetoothDevice, uzyskaj BluetoothSocket, dzwoniąc pod numer createRfcommSocketToServiceRecord(UUID).

    Ta metoda inicjuje obiekt BluetoothSocket, który umożliwia klientowi połączenie z BluetoothDevice. Przekazany tutaj identyfikator UUID musi być zgodny z identyfikatorem UUID używanym przez urządzenie serwera, gdy wywołuje ono metodę listenUsingRfcommWithServiceRecord(String, UUID), aby otworzyć BluetoothServerSocket. Aby użyć pasującego identyfikatora UUID, zakoduj go na stałe w aplikacji, a następnie odwołuj się do niego zarówno w kodzie serwera, jak i klienta.

  2. Zainicjuj połączenie, dzwoniąc pod numer connect(). Pamiętaj, że ta metoda jest wywołaniem blokującym.

    Gdy klient wywoła tę metodę, system przeprowadzi wyszukiwanie SDP, aby znaleźć urządzenie zdalne z pasującym identyfikatorem UUID. Jeśli wyszukiwanie się powiedzie, a urządzenie zdalne zaakceptuje połączenie, udostępni kanał RFCOMM do użycia podczas połączenia, a metoda connect() zwróci wynik. Jeśli połączenie się nie powiedzie lub upłynie limit czasu metody connect() (po około 12 sekundach), metoda zgłosi błąd IOException.

connect() jest wywołaniem blokującym, dlatego procedurę połączenia należy zawsze wykonywać w wątku oddzielnym od wątku głównego (UI).

Przykład

Poniżej znajdziesz podstawowy przykład wątku klienta, który inicjuje połączenie 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);
       }
   }
}

Zwróć uwagę, że w tym fragmencie kodu metoda cancelDiscovery() jest wywoływana przed próbą połączenia. Zawsze wywołuj cancelDiscovery() przed connect(), zwłaszcza że cancelDiscovery() działa niezależnie od tego, czy wykrywanie urządzeń jest obecnie w toku. Jeśli aplikacja musi określić, czy trwa wykrywanie urządzeń, możesz to sprawdzić za pomocą isDiscovering().

Metoda manageMyConnectedSocket() aplikacji służy do inicjowania wątku przesyłania danych, który został omówiony w sekcji dotyczącej przesyłania danych przez Bluetooth.

Gdy skończysz korzystać z BluetoothSocket, zawsze wywołuj close(). Spowoduje to natychmiastowe zamknięcie połączonego gniazda i zwolnienie wszystkich powiązanych zasobów wewnętrznych.