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.
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:
Llama a
listenUsingRfcommWithServiceRecord(String, UUID)para obtener unBluetoothServerSocket.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
UUIDque hay en la Web y, luego, inicializar un UUID confromString(String).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 unBluetoothSocketconectado.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
BluetoothSocketconectado 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 aclose()en elBluetoothServerSocketinmediatamente 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:
Con
BluetoothDevice, llama acreateRfcommSocketToServiceRecord(UUID)para obtener unBluetoothSocket.Este método inicializa un objeto
BluetoothSocketque permite que el cliente se conecte a unBluetoothDevice. El UUID que se pasa aquí debe coincidir con el que usó el dispositivo del servidor cuando llamó alistenUsingRfcommWithServiceRecord(String, UUID)para abrir suBluetoothServerSocket. 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.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étodoconnect()(después de unos 12 segundos), el método arroja unaIOException.
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.