The interface for Bluetooth Sockets is similar to that of TCP sockets: * {@link java.net.Socket} and {@link java.net.ServerSocket}. On the server * side, use a {@link BluetoothServerSocket} to create a listening server * socket. When a connection is accepted by the {@link BluetoothServerSocket}, * it will return a new {@link BluetoothSocket} to manage the connection. * On the client side, use a single {@link BluetoothSocket} to both initiate * an outgoing connection and to manage the connection. * *
For Bluetooth BR/EDR, the most common type of socket is RFCOMM, which is the type supported by * the Android APIs. RFCOMM is a connection-oriented, streaming transport over Bluetooth BR/EDR. It * is also known as the Serial Port Profile (SPP). To create a listening * {@link BluetoothServerSocket} that's ready for incoming Bluetooth BR/EDR connections, use {@link * BluetoothAdapter#listenUsingRfcommWithServiceRecord * BluetoothAdapter.listenUsingRfcommWithServiceRecord()}. * *
For Bluetooth LE, the socket uses LE Connection-oriented Channel (CoC). LE CoC is a * connection-oriented, streaming transport over Bluetooth LE and has a credit-based flow control. * Correspondingly, use {@link BluetoothAdapter#listenUsingL2capChannel * BluetoothAdapter.listenUsingL2capChannel()} to create a listening {@link BluetoothServerSocket} * that's ready for incoming Bluetooth LE CoC connections. For LE CoC, you can use {@link #getPsm()} * to get the protocol/service multiplexer (PSM) value that the peer needs to use to connect to your * socket. * *
After the listening {@link BluetoothServerSocket} is created, call {@link #accept()} to * listen for incoming connection requests. This call will block until a connection is established, * at which point, it will return a {@link BluetoothSocket} to manage the connection. Once the * {@link BluetoothSocket} is acquired, it's a good idea to call {@link #close()} on the {@link * BluetoothServerSocket} when it's no longer needed for accepting * connections. Closing the {@link BluetoothServerSocket} will not close the returned * {@link BluetoothSocket}. * *
{@link BluetoothServerSocket} is thread * safe. In particular, {@link #close} will always immediately abort ongoing * operations and close the server socket. * *
For more information about using Bluetooth, read the * Bluetooth developer guide.
*Returns a connected {@link BluetoothSocket} on successful connection. *
Once this call returns, it can be called again to accept subsequent * incoming connections. *
{@link #close} can be used to abort this call from another thread. * * @return a connected {@link BluetoothSocket} * @throws IOException on error, for example this call was aborted, or timeout */ public BluetoothSocket accept() throws IOException { return accept(-1); } /** * Block until a connection is established, with timeout. *
Returns a connected {@link BluetoothSocket} on successful connection. *
Once this call returns, it can be called again to accept subsequent * incoming connections. *
{@link #close} can be used to abort this call from another thread. * * @return a connected {@link BluetoothSocket} * @throws IOException on error, for example this call was aborted, or timeout */ public BluetoothSocket accept(int timeout) throws IOException { long socketConnectionTime = System.currentTimeMillis(); BluetoothSocket acceptedSocket = null; try { acceptedSocket = mSocket.accept(timeout); logL2capcocServerConnection( acceptedSocket, timeout, BluetoothSocket.RESULT_L2CAP_CONN_SUCCESS, socketConnectionTime); return acceptedSocket; } catch (IOException e) { logL2capcocServerConnection( acceptedSocket, timeout, BluetoothSocket.RESULT_L2CAP_CONN_SERVER_FAILURE, socketConnectionTime); throw e; } } private void logL2capcocServerConnection( BluetoothSocket acceptedSocket, int timeout, int result, long socketConnectionTimeMillis) { if (mType != BluetoothSocket.TYPE_L2CAP_LE) { return; } IBluetooth bluetoothProxy = BluetoothAdapter.getDefaultAdapter().getBluetoothService(); if (bluetoothProxy == null) { Log.w(TAG, "bluetoothProxy is null while trying to log l2cap soc server connection"); return; } try { final SynchronousResultReceiver recv = SynchronousResultReceiver.get(); bluetoothProxy.logL2capcocServerConnection( acceptedSocket == null ? null : acceptedSocket.getRemoteDevice(), getPsm(), mSocket.isAuth(), result, mSocketCreationTimeMillis, // pass creation time to calculate end to end latency mSocketCreationLatencyMillis, // socket creation latency socketConnectionTimeMillis, // send connection start time for connection latency timeout, recv); recv.awaitResultNoInterrupt(getSyncTimeout()).getValue(null); } catch (RemoteException | TimeoutException e) { Log.w(TAG, "logL2capcocServerConnection failed due to remote exception"); } } /** * Immediately close this socket, and release all associated resources. *
Causes blocked calls on this socket in other threads to immediately * throw an IOException. *
Closing the {@link BluetoothServerSocket} will not * close any {@link BluetoothSocket} received from {@link #accept()}. */ public void close() throws IOException { if (DBG) Log.d(TAG, "BluetoothServerSocket:close() called. mChannel=" + mChannel); synchronized (this) { if (mHandler != null) { mHandler.obtainMessage(mMessage).sendToTarget(); } } mSocket.close(); } /*package*/ synchronized void setCloseHandler(Handler handler, int message) { mHandler = handler; mMessage = message; } /*package*/ void setServiceName(String serviceName) { mSocket.setServiceName(serviceName); } /** * Returns the channel on which this socket is bound. * * @hide */ public int getChannel() { return mChannel; } /** * Returns the assigned dynamic protocol/service multiplexer (PSM) value for the listening L2CAP * Connection-oriented Channel (CoC) server socket. This server socket must be returned by the * {@link BluetoothAdapter#listenUsingL2capChannel()} or {@link * BluetoothAdapter#listenUsingInsecureL2capChannel()}. The returned value is undefined if this * method is called on non-L2CAP server sockets. * * @return the assigned PSM or LE_PSM value depending on transport */ public int getPsm() { return mChannel; } /** * Sets the channel on which future sockets are bound. * Currently used only when a channel is auto generated. */ /*package*/ void setChannel(int newChannel) { /* TODO: From a design/architecture perspective this is wrong. * The bind operation should be conducted through this class * and the resulting port should be kept in mChannel, and * not set from BluetoothAdapter. */ if (mSocket != null) { if (mSocket.getPort() != newChannel) { Log.w(TAG, "The port set is different that the underlying port. mSocket.getPort(): " + mSocket.getPort() + " requested newChannel: " + newChannel); } } mChannel = newChannel; } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("ServerSocket: Type: "); switch (mSocket.getConnectionType()) { case BluetoothSocket.TYPE_RFCOMM: { sb.append("TYPE_RFCOMM"); break; } case BluetoothSocket.TYPE_L2CAP: { sb.append("TYPE_L2CAP"); break; } case BluetoothSocket.TYPE_L2CAP_LE: { sb.append("TYPE_L2CAP_LE"); break; } case BluetoothSocket.TYPE_SCO: { sb.append("TYPE_SCO"); break; } } sb.append(" Channel: ").append(mChannel); return sb.toString(); } }