Conecta dispositivos Bluetooth

Para crear una conexión entre dos dispositivos, debes implementar los mecanismos del servidor y del cliente, ya que un dispositivo debe abrir un socket de servidor y el otro debe iniciar la conexión con la dirección MAC del dispositivo del servidor. El dispositivo de servidor y el dispositivo de cliente obtienen el BluetoothSocket requerido de diferentes maneras. El servidor recibe información del socket cuando se acepta una conexión entrante. El cliente proporciona información del socket cuando abre un canal de RFCOMM al servidor.

Se considera que el servidor y el cliente están conectados entre sí cuando cada uno tiene un BluetoothSocket conectado en el mismo canal de RFCOMM. En este punto, cada dispositivo puede obtener flujos de entrada y salida, y puede comenzar la transferencia de datos, que se analiza en la sección sobre transferencia de datos Bluetooth. En esta sección, se describe cómo iniciar la conexión entre dos dispositivos.

Asegúrate de tener los permisos de Bluetooth adecuados y de configurar tu app para Bluetooth antes de intentar encontrar dispositivos Bluetooth.

Técnicas de conexión

Una técnica de implementación consiste en preparar automáticamente cada dispositivo como un servidor, de modo que cada uno tenga un socket de servidor abierto y escuche las conexiones. En este caso, cualquiera de los dispositivos puede iniciar una conexión con el otro y convertirse en el cliente. Como alternativa, un dispositivo puede alojar de forma explícita la conexión y abrir un socket de servidor a pedido, y el otro dispositivo inicia la conexión.

El diálogo de vinculación por Bluetooth que le solicita al usuario que se vincule con un dispositivo.
Figura 1: El diálogo de vinculación por Bluetooth.

Cómo conectarse como servidor

Cuando quieras conectar dos dispositivos, uno debe actuar como servidor con un BluetoothServerSocket abierto. El propósito del socket del servidor es escuchar las solicitudes de conexión entrantes y proporcionar un BluetoothSocket conectado después de que se acepte una solicitud. Cuando se adquiere el BluetoothSocket del BluetoothServerSocket, este BluetoothServerSocket último puede (y debe) descartarse, a menos que quieras que el dispositivo acepte más conexiones.

Para configurar un socket de servidor y aceptar una conexión, completa la siguiente secuencia de pasos:

  1. Llama a listenUsingRfcommWithServiceRecord(String, UUID) para obtener un BluetoothServerSocket.

    La cadena es un nombre identificable de tu servicio, que el sistema escribe automáticamente en una nueva entrada de la base de datos del protocolo de descubrimiento de servicios (SDP) en el dispositivo. El nombre es arbitrario y puede ser simplemente el nombre de tu app. El identificador único universal (UUID) también se incluye en la entrada del SDP y constituye la base del acuerdo de conexión con el dispositivo cliente. Es decir, cuando el cliente intenta conectarse con este dispositivo, lleva un UUID que identifica de forma única el servicio con el que se quiere conectar. Estos UUID deben coincidir para que se acepte la conexión.

    Un UUID es un formato estandarizado de 128 bits para un ID de cadena que se usa para identificar información de forma inequívoca. Se usa un UUID para identificar la información que debe ser única dentro de un sistema o una red, ya que la probabilidad de que se repita un UUID es prácticamente nula. Se genera de forma independiente, sin el uso de una autoridad centralizada. En este caso, se usa para identificar de forma única el servicio de Bluetooth de tu app. Para obtener un UUID que puedas usar con tu app, puedes utilizar uno de los muchos generadores aleatorios de UUID que hay en la Web y, luego, inicializar un UUID con fromString(String).

  2. Para comenzar a escuchar las solicitudes de conexión, llama a accept().

    Esta es una llamada de bloqueo. Se muestra cuando se acepta una conexión o se produce una excepción. Una conexión se acepta solo cuando un dispositivo remoto envía una solicitud de conexión que contiene un UUID que coincide con el registrado en este socket de servidor de escucha. Si se ejecuta de forma correcta, accept() devuelve un BluetoothSocket conectado.

  3. A menos que quieras aceptar conexiones adicionales, llama a close().

    Esta llamada de método libera el socket del servidor y todos sus recursos, pero no cierra el BluetoothSocket conectado que devolvió accept(). A diferencia de TCP/IP, RFCOMM solo permite un cliente conectado por canal a la vez, por lo que, en la mayoría de los casos, tiene sentido llamar a close() en el BluetoothServerSocket inmediatamente después de aceptar un socket conectado.

Debido a que la llamada accept() es una llamada de bloqueo, no la ejecutes en el subproceso de IU de la actividad principal. Ejecutarlo en otro subproceso garantiza que tu app pueda seguir respondiendo a otras interacciones del usuario. Por lo general, tiene sentido realizar todo el trabajo que involucre un BluetoothServerSocket o BluetoothSocket en un subproceso nuevo administrado por tu app. Para anular una llamada bloqueada, como accept(), llama a close() en el BluetoothServerSocket o BluetoothSocket desde otro subproceso. Ten en cuenta que todos los métodos de un BluetoothServerSocket o BluetoothSocket tienen protección de subprocesos.

Ejemplo

A continuación, se muestra un subproceso simplificado para el componente del servidor que acepta conexiones 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);
       }
   }
}

En este ejemplo, solo se desea una conexión entrante, por lo que, en cuanto se acepta una conexión y se adquiere el BluetoothSocket, la app pasa el BluetoothSocket adquirido a un subproceso separado, cierra el BluetoothServerSocket y sale del bucle.

Ten en cuenta que, cuando accept() devuelve BluetoothSocket, el socket ya está conectado. Por lo tanto, no debes llamar a connect(), como lo haces desde el cliente.

El método manageMyConnectedSocket() específico de la app está diseñado para iniciar el subproceso de transferencia de datos, que se analiza en el tema sobre la transferencia de datos de Bluetooth.

Por lo general, debes cerrar tu BluetoothServerSocket en cuanto termines de escuchar las conexiones entrantes. En este ejemplo, se llama a close() en cuanto se adquiere BluetoothSocket. También puedes proporcionar un método público en tu subproceso que pueda cerrar el BluetoothSocket privado en caso de que necesites dejar de escuchar en ese socket de servidor.

Conéctate como cliente

Para iniciar una conexión con un dispositivo remoto que acepta conexiones en un socket de servidor abierto, primero debes obtener un objeto BluetoothDevice que represente el dispositivo remoto. Para obtener información sobre cómo crear un BluetoothDevice, consulta Cómo buscar dispositivos Bluetooth. Luego, debes usar BluetoothDevice para adquirir un BluetoothSocket y, así, iniciar la conexión.

El procedimiento básico es el siguiente:

  1. Con BluetoothDevice, llama a createRfcommSocketToServiceRecord(UUID) para obtener un BluetoothSocket.

    Este método inicializa un objeto BluetoothSocket que permite que el cliente se conecte a un BluetoothDevice. El UUID que se pasa aquí debe coincidir con el que usó el dispositivo del servidor cuando llamó a listenUsingRfcommWithServiceRecord(String, UUID) para abrir su BluetoothServerSocket. Para usar un UUID coincidente, codifica la cadena de UUID en tu app y, luego, haz referencia a ella desde el código del servidor y del cliente.

  2. Inicia la conexión llamando a connect(). Ten en cuenta que este método es una llamada de bloqueo.

    Después de que un cliente llama a este método, el sistema realiza una búsqueda de SDP para encontrar el dispositivo remoto con el UUID coincidente. Si la búsqueda se realiza correctamente y el dispositivo remoto acepta la conexión, comparte el canal de RFCOMM que se usará durante la conexión, y se muestra el método connect(). Si la conexión falla o si se agota el tiempo de espera del método connect() (después de unos 12 segundos), el método arroja una IOException.

Debido a que connect() es una llamada de bloqueo, siempre debes realizar este procedimiento de conexión en un subproceso independiente del subproceso de la actividad principal (IU).

Ejemplo

A continuación, se muestra un ejemplo básico de un subproceso de cliente que inicia una conexión 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);
       }
   }
}

Observa que, en este fragmento, se llama a cancelDiscovery() antes de que se produzca el intento de conexión. Siempre debes llamar a cancelDiscovery() antes de connect(), sobre todo porque cancelDiscovery() se ejecuta correctamente, sin importar si el descubrimiento de dispositivos está en curso. Si tu app necesita determinar si el descubrimiento de dispositivos está en curso, puedes verificarlo con isDiscovering().

El método manageMyConnectedSocket() específico de la app está diseñado para iniciar el subproceso de transferencia de datos, que se analiza en la sección sobre transferencia de datos de Bluetooth.

Cuando termines con tu BluetoothSocket, siempre llama a close(). Si lo haces, se cerrará de inmediato el socket conectado y se liberarán todos los recursos internos relacionados.