1 /*
2  * Copyright (C) 2009 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.bluetooth;
18 
19 import android.os.Handler;
20 import android.os.ParcelUuid;
21 import android.util.Log;
22 
23 import java.io.Closeable;
24 import java.io.IOException;
25 
26 /**
27  * A listening Bluetooth socket.
28  *
29  * <p>The interface for Bluetooth Sockets is similar to that of TCP sockets:
30  * {@link java.net.Socket} and {@link java.net.ServerSocket}. On the server
31  * side, use a {@link BluetoothServerSocket} to create a listening server
32  * socket. When a connection is accepted by the {@link BluetoothServerSocket},
33  * it will return a new {@link BluetoothSocket} to manage the connection.
34  * On the client side, use a single {@link BluetoothSocket} to both initiate
35  * an outgoing connection and to manage the connection.
36  *
37  * <p>The most common type of Bluetooth socket is RFCOMM, which is the type
38  * supported by the Android APIs. RFCOMM is a connection-oriented, streaming
39  * transport over Bluetooth. It is also known as the Serial Port Profile (SPP).
40  *
41  * <p>To create a listening {@link BluetoothServerSocket} that's ready for
42  * incoming connections, use
43  * {@link BluetoothAdapter#listenUsingRfcommWithServiceRecord
44  * BluetoothAdapter.listenUsingRfcommWithServiceRecord()}. Then call
45  * {@link #accept()} to listen for incoming connection requests. This call
46  * will block until a connection is established, at which point, it will return
47  * a {@link BluetoothSocket} to manage the connection. Once the {@link
48  * BluetoothSocket} is acquired, it's a good idea to call {@link #close()} on
49  * the {@link BluetoothServerSocket} when it's no longer needed for accepting
50  * connections. Closing the {@link BluetoothServerSocket} will <em>not</em>
51  * close the returned {@link BluetoothSocket}.
52  *
53  * <p>{@link BluetoothServerSocket} is thread
54  * safe. In particular, {@link #close} will always immediately abort ongoing
55  * operations and close the server socket.
56  *
57  * <p class="note"><strong>Note:</strong>
58  * Requires the {@link android.Manifest.permission#BLUETOOTH} permission.
59  *
60  * <div class="special reference">
61  * <h3>Developer Guides</h3>
62  * <p>For more information about using Bluetooth, read the
63  * <a href="{@docRoot}guide/topics/connectivity/bluetooth.html">Bluetooth</a> developer guide.</p>
64  * </div>
65  *
66  * {@see BluetoothSocket}
67  */
68 public final class BluetoothServerSocket implements Closeable {
69 
70     private static final String TAG = "BluetoothServerSocket";
71     private static final boolean DBG = false;
72     /*package*/ final BluetoothSocket mSocket;
73     private Handler mHandler;
74     private int mMessage;
75     private int mChannel;
76 
77     /**
78      * Construct a socket for incoming connections.
79      *
80      * @param type type of socket
81      * @param auth require the remote device to be authenticated
82      * @param encrypt require the connection to be encrypted
83      * @param port remote port
84      * @throws IOException On error, for example Bluetooth not available, or insufficient
85      * privileges
86      */
BluetoothServerSocket(int type, boolean auth, boolean encrypt, int port)87     /*package*/ BluetoothServerSocket(int type, boolean auth, boolean encrypt, int port)
88             throws IOException {
89         mChannel = port;
90         mSocket = new BluetoothSocket(type, -1, auth, encrypt, null, port, null);
91         if (port == BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP) {
92             mSocket.setExcludeSdp(true);
93         }
94     }
95 
96     /**
97      * Construct a socket for incoming connections.
98      *
99      * @param type type of socket
100      * @param auth require the remote device to be authenticated
101      * @param encrypt require the connection to be encrypted
102      * @param port remote port
103      * @param mitm enforce man-in-the-middle protection for authentication.
104      * @param min16DigitPin enforce a minimum length of 16 digits for a sec mode 2 connection
105      * @throws IOException On error, for example Bluetooth not available, or insufficient
106      * privileges
107      */
BluetoothServerSocket(int type, boolean auth, boolean encrypt, int port, boolean mitm, boolean min16DigitPin)108     /*package*/ BluetoothServerSocket(int type, boolean auth, boolean encrypt, int port,
109             boolean mitm, boolean min16DigitPin)
110             throws IOException {
111         mChannel = port;
112         mSocket = new BluetoothSocket(type, -1, auth, encrypt, null, port, null, mitm,
113                 min16DigitPin);
114         if (port == BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP) {
115             mSocket.setExcludeSdp(true);
116         }
117     }
118 
119     /**
120      * Construct a socket for incoming connections.
121      *
122      * @param type type of socket
123      * @param auth require the remote device to be authenticated
124      * @param encrypt require the connection to be encrypted
125      * @param uuid uuid
126      * @throws IOException On error, for example Bluetooth not available, or insufficient
127      * privileges
128      */
BluetoothServerSocket(int type, boolean auth, boolean encrypt, ParcelUuid uuid)129     /*package*/ BluetoothServerSocket(int type, boolean auth, boolean encrypt, ParcelUuid uuid)
130             throws IOException {
131         mSocket = new BluetoothSocket(type, -1, auth, encrypt, null, -1, uuid);
132         // TODO: This is the same as mChannel = -1 - is this intentional?
133         mChannel = mSocket.getPort();
134     }
135 
136 
137     /**
138      * Block until a connection is established.
139      * <p>Returns a connected {@link BluetoothSocket} on successful connection.
140      * <p>Once this call returns, it can be called again to accept subsequent
141      * incoming connections.
142      * <p>{@link #close} can be used to abort this call from another thread.
143      *
144      * @return a connected {@link BluetoothSocket}
145      * @throws IOException on error, for example this call was aborted, or timeout
146      */
accept()147     public BluetoothSocket accept() throws IOException {
148         return accept(-1);
149     }
150 
151     /**
152      * Block until a connection is established, with timeout.
153      * <p>Returns a connected {@link BluetoothSocket} on successful connection.
154      * <p>Once this call returns, it can be called again to accept subsequent
155      * incoming connections.
156      * <p>{@link #close} can be used to abort this call from another thread.
157      *
158      * @return a connected {@link BluetoothSocket}
159      * @throws IOException on error, for example this call was aborted, or timeout
160      */
accept(int timeout)161     public BluetoothSocket accept(int timeout) throws IOException {
162         return mSocket.accept(timeout);
163     }
164 
165     /**
166      * Immediately close this socket, and release all associated resources.
167      * <p>Causes blocked calls on this socket in other threads to immediately
168      * throw an IOException.
169      * <p>Closing the {@link BluetoothServerSocket} will <em>not</em>
170      * close any {@link BluetoothSocket} received from {@link #accept()}.
171      */
close()172     public void close() throws IOException {
173         if (DBG) Log.d(TAG, "BluetoothServerSocket:close() called. mChannel=" + mChannel);
174         synchronized (this) {
175             if (mHandler != null) {
176                 mHandler.obtainMessage(mMessage).sendToTarget();
177             }
178         }
179         mSocket.close();
180     }
181 
182     /*package*/
setCloseHandler(Handler handler, int message)183     synchronized void setCloseHandler(Handler handler, int message) {
184         mHandler = handler;
185         mMessage = message;
186     }
187 
setServiceName(String serviceName)188     /*package*/ void setServiceName(String serviceName) {
189         mSocket.setServiceName(serviceName);
190     }
191 
192     /**
193      * Returns the channel on which this socket is bound.
194      *
195      * @hide
196      */
getChannel()197     public int getChannel() {
198         return mChannel;
199     }
200 
201     /**
202      * Returns the assigned dynamic protocol/service multiplexer (PSM) value for the listening L2CAP
203      * Connection-oriented Channel (CoC) server socket. This server socket must be returned by the
204      * {#link BluetoothAdapter.listenUsingL2capCoc(int)} or {#link
205      * BluetoothAdapter.listenUsingInsecureL2capCoc(int)}. The returned value is undefined if this
206      * method is called on non-L2CAP server sockets.
207      *
208      * @return the assigned PSM or LE_PSM value depending on transport
209      * @hide
210      */
getPsm()211     public int getPsm() {
212         return mChannel;
213     }
214 
215     /**
216      * Sets the channel on which future sockets are bound.
217      * Currently used only when a channel is auto generated.
218      */
setChannel(int newChannel)219     /*package*/ void setChannel(int newChannel) {
220         /* TODO: From a design/architecture perspective this is wrong.
221          *       The bind operation should be conducted through this class
222          *       and the resulting port should be kept in mChannel, and
223          *       not set from BluetoothAdapter. */
224         if (mSocket != null) {
225             if (mSocket.getPort() != newChannel) {
226                 Log.w(TAG, "The port set is different that the underlying port. mSocket.getPort(): "
227                         + mSocket.getPort() + " requested newChannel: " + newChannel);
228             }
229         }
230         mChannel = newChannel;
231     }
232 
233     @Override
toString()234     public String toString() {
235         StringBuilder sb = new StringBuilder();
236         sb.append("ServerSocket: Type: ");
237         switch (mSocket.getConnectionType()) {
238             case BluetoothSocket.TYPE_RFCOMM: {
239                 sb.append("TYPE_RFCOMM");
240                 break;
241             }
242             case BluetoothSocket.TYPE_L2CAP: {
243                 sb.append("TYPE_L2CAP");
244                 break;
245             }
246             case BluetoothSocket.TYPE_L2CAP_LE: {
247                 sb.append("TYPE_L2CAP_LE");
248                 break;
249             }
250             case BluetoothSocket.TYPE_SCO: {
251                 sb.append("TYPE_SCO");
252                 break;
253             }
254         }
255         sb.append(" Channel: ").append(mChannel);
256         return sb.toString();
257     }
258 }
259