src/com/android/bluetooth/ObexServerSockets.java - platform/packages/apps/Bluetooth - Git at Google

 /*
 * Copyright (C) 2015 Samsung System LSI
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 package com.android.bluetooth;

 import java.io.IOException;
 import java.util.concurrent.CountDownLatch;

 import javax.obex.ObexSession;
 import javax.obex.ResponseCodes;
 import javax.obex.ServerSession;

 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothServerSocket;
 import android.bluetooth.BluetoothSocket;
 import android.util.Log;

 /**
  * Wraps multiple BluetoothServerSocket objects to make it possible to accept connections on
  * both a RFCOMM and L2CAP channel in parallel.<br>
  * Create an instance using {@link #create()}, which will block until the sockets have been created
  * and channel numbers have been assigned.<br>
  * Use {@link #getRfcommChannel()} and {@link #getL2capPsm()} to get the channel numbers to
  * put into the SDP record.<br>
  * Call {@link #shutdown(boolean)} to terminate the accept threads created by the call to
  * {@link #create(IObexConnectionHandler)}.<br>
  * A reference to an object of this type cannot be reused, and the {@link BluetoothServerSocket}
  * object references passed to this object will be closed by this object, hence cannot be reused
  * either (This is needed, as the only way to interrupt an accept call is to close the socket...)
  * <br>
  * When a connection is accepted,
  * {@link IObexConnectionHandler#onConnect(BluetoothDevice, BluetoothSocket)} will be called.<br>
  * If the an error occur while waiting for an incoming connection
  * {@link IObexConnectionHandler#onConnect(BluetoothDevice, BluetoothSocket)} will be called.<br>
  * In both cases the {@link ObexServerSockets} object have terminated, and a new must be created.
  */
 public class ObexServerSockets {
     private final String TAG;
     private static final String STAG = "ObexServerSockets";
     private static final boolean D = true; // TODO: set to false!
     private static final int NUMBER_OF_SOCKET_TYPES = 2; // increment if LE will be supported

     private final IObexConnectionHandler mConHandler;
     /* The wrapped sockets */
     private final BluetoothServerSocket mRfcommSocket;
     private final BluetoothServerSocket mL2capSocket;
     /* Handles to the accept threads. Needed for shutdown. */
     private SocketAcceptThread mRfcommThread = null;
     private SocketAcceptThread mL2capThread = null;

     private volatile boolean mConAccepted = false;

     private static volatile int sInstanceCounter = 0;

     private ObexServerSockets(IObexConnectionHandler conHandler,
             BluetoothServerSocket rfcommSocket,
             BluetoothServerSocket l2capSocket) {
         mConHandler = conHandler;
         mRfcommSocket = rfcommSocket;
         mL2capSocket = l2capSocket;
         TAG = "ObexServerSockets" + sInstanceCounter++;
     }

     /**
      * Creates an RFCOMM {@link BluetoothServerSocket} and a L2CAP {@link BluetoothServerSocket}
      * @param validator a reference to the {@link IObexConnectionHandler} object to call
      *                  to validate an incoming connection.
      * @return a reference to a {@link ObexServerSockets} object instance.
      * @throws IOException if it occurs while creating the {@link BluetoothServerSocket}s.
      */
     public static ObexServerSockets create(IObexConnectionHandler validator) {
         return create(validator, BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP,
                 BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP);
     }

     /**
      * Creates an RFCOMM {@link BluetoothServerSocket} and a L2CAP {@link BluetoothServerSocket}
      * with specific l2cap and RFCOMM channel numbers. It is the responsibility of the caller to
      * ensure the numbers are free and can be used, e.g. by calling {@link #getL2capPsm()} and
      * {@link #getRfcommChannel()} in {@link ObexServerSockets}.
      * @param validator a reference to the {@link IObexConnectionHandler} object to call
      *                  to validate an incoming connection.
      * @return a reference to a {@link ObexServerSockets} object instance.
      * @throws IOException if it occurs while creating the {@link BluetoothServerSocket}s.
      *
      * TODO: Make public when it becomes possible to determine that the listen-call
      *       failed due to channel-in-use.
      */
     private static ObexServerSockets create(IObexConnectionHandler validator,
             int rfcommChannel, int l2capPsm) {
         if(D) Log.d(STAG,"create(rfcomm = " +rfcommChannel + ", l2capPsm = " + l2capPsm +")");
         BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter();
         if(bt == null) {
             throw new RuntimeException("No bluetooth adapter...");
         }
         BluetoothServerSocket rfcommSocket = null;
         BluetoothServerSocket l2capSocket = null;
         boolean initSocketOK = false;
         final int CREATE_RETRY_TIME = 10;

         // It's possible that create will fail in some cases. retry for 10 times
         for (int i = 0; i < CREATE_RETRY_TIME; i++) {
             initSocketOK = true;
             try {
                 if(rfcommSocket == null) {
                     rfcommSocket = bt.listenUsingRfcommOn(rfcommChannel);
                 }
                 if(l2capSocket == null) {
                     l2capSocket = bt.listenUsingL2capOn(l2capPsm);
                 }
             } catch (IOException e) {
                 Log.e(STAG, "Error create ServerSockets ",e);
                 initSocketOK = false;
             }
             if (!initSocketOK) {
                 // Need to break out of this loop if BT is being turned off.
                 int state = bt.getState();
                 if ((state != BluetoothAdapter.STATE_TURNING_ON) &&
                     (state != BluetoothAdapter.STATE_ON)) {
                     Log.w(STAG, "initServerSockets failed as BT is (being) turned off");
                     break;
                 }
                 try {
                     if (D) Log.v(STAG, "waiting 300 ms...");
                     Thread.sleep(300);
                 } catch (InterruptedException e) {
                     Log.e(STAG, "create() was interrupted");
                 }
             } else {
                 break;
             }
         }

         if (initSocketOK) {
             if (D) Log.d(STAG, "Succeed to create listening sockets ");
             ObexServerSockets sockets = new ObexServerSockets(validator, rfcommSocket, l2capSocket);
             sockets.startAccept();
             return sockets;
         } else {
             Log.e(STAG, "Error to create listening socket after " + CREATE_RETRY_TIME + " try");
             return null;
         }
     }

     /**
      * Returns the channel number assigned to the RFCOMM socket. This will be a static value, that
      * should be reused for multiple connections.
      * @return the RFCOMM channel number
      */
     public int getRfcommChannel() {
         return mRfcommSocket.getChannel();
     }

     /**
      * Returns the channel number assigned to the L2CAP socket. This will be a static value, that
      * should be reused for multiple connections.
      * @return the L2CAP channel number
      */
     public int getL2capPsm() {
         return mL2capSocket.getChannel();
     }

     /**
      * Initiate the accept threads.
      * Will create a thread for each socket type. an incoming connection will be signaled to
      * the {@link IObexConnectionValidator#onConnect()}, at which point both threads will exit.
      */
     private void startAccept() {
         if(D) Log.d(TAG,"startAccept()");
         prepareForNewConnect();

         mRfcommThread = new SocketAcceptThread(mRfcommSocket);
         mRfcommThread.start();

         mL2capThread = new SocketAcceptThread(mL2capSocket);
         mL2capThread.start();
     }

     /**
      * Set state to accept new incoming connection. Will cause the next incoming connection to be
      * Signaled through {@link IObexConnectionValidator#onConnect()};
      */
     public void prepareForNewConnect() {
         if(D) Log.d(TAG, "prepareForNewConnect()");
         mConAccepted = false;
     }

     /**
      * Called from the AcceptThreads to signal an incoming connection.
      * This is the entry point that needs to synchronize between the accept
      * threads, and ensure only a single connection is accepted.
      * {@link mAcceptedSocket} is used a state variable.
      * @param device the connecting device.
      * @param conSocket the socket associated with the connection.
      * @return true if the connection is accepted, false otherwise.
      */
     synchronized private boolean onConnect(BluetoothDevice device, BluetoothSocket conSocket) {
         if(D) Log.d(TAG, "onConnect() socket: " + conSocket + " mConAccepted = " + mConAccepted);
         if(mConAccepted  == false && mConHandler.onConnect(device, conSocket) == true) {
             mConAccepted = true; // TODO: Reset this when ready to accept new connection
             /* Signal the remaining threads to stop.
             shutdown(false); */ // UPDATE: TODO: remove - redesigned to keep running...
             return true;
         }
         return false;
     }

     /**
      * Signal to the {@link IObexConnectionHandler} that an error have occurred.
      */
     synchronized private void onAcceptFailed() {
         Log.w(TAG,"onAcceptFailed() calling shutdown...");
         mConHandler.onAcceptFailed();
         shutdown(false);
     }

     /**
      * Terminate any running accept threads
      * @param block Set true to block the calling thread until the AcceptThreads
      * has ended execution
      */
     synchronized public void shutdown(boolean block) {
         if(D) Log.d(TAG, "shutdown(block = " + block + ")");
         if(mRfcommThread != null) {
             mRfcommThread.shutdown();
         }
         if(mL2capThread != null){
             mL2capThread.shutdown();
         }
         if(block == true) {
             while(mRfcommThread != null || mL2capThread != null) {
                 try {
                     if(mRfcommThread != null) {
                         mRfcommThread.join();
                         mRfcommThread = null;
                     }
                     if(mL2capThread != null) {
                         mL2capThread.join();
                         mL2capThread = null;
                     }
                 } catch (InterruptedException e) {
                     Log.i(TAG, "shutdown() interrupted, continue waiting...", e);
                 }
             }
         } else {
             mRfcommThread = null;
             mL2capThread = null;
         }
     }

     /**
      * A thread that runs in the background waiting for remote an incoming
      * connect. Once a remote socket connects, this thread will be
      * shutdown. When the remote disconnect, this thread shall be restarted to
      * accept a new connection.
      */
     private class SocketAcceptThread extends Thread {

         private boolean mStopped = false;
         private final BluetoothServerSocket mServerSocket;

         /**
          * Create a SocketAcceptThread
          * @param serverSocket shall never be null.
          * @param latch shall never be null.
          * @throws IllegalArgumentException
          */
         public SocketAcceptThread(BluetoothServerSocket serverSocket) {
             if(serverSocket == null) {
                 throw new IllegalArgumentException("serverSocket cannot be null");
             }
             mServerSocket = serverSocket;
         }

         /**
          * Run until shutdown of BT.
          * Accept incoming connections and reject if needed. Keep accepting incoming connections.
          */
         @Override
         public void run() {
             try {
                 while (!mStopped) {
                     BluetoothSocket connSocket;
                     BluetoothDevice device;

                     try {
                         if (D) Log.d(TAG, "Accepting socket connection...");

                         connSocket = mServerSocket.accept();
                         if (D) Log.d(TAG, "Accepted socket connection from: " + mServerSocket);

                        if (connSocket == null) {
                            // TODO: Do we need a max error count, to avoid spinning?
                             Log.w(TAG, "connSocket is null - reattempt accept");
                             continue;
                         }
                         device = connSocket.getRemoteDevice();

                         if (device == null) {
                             Log.i(TAG, "getRemoteDevice() = null - reattempt accept");
                             try{
                                 connSocket.close();
                             } catch (IOException e) {
                                 Log.w(TAG, "Error closing the socket. ignoring...",e );
                             }
                             continue;
                         }

                         /* Signal to the service that we have received an incoming connection.
                          */
                         boolean isValid = ObexServerSockets.this.onConnect(device, connSocket);

                         if(isValid == false) {
                             /* Close connection if we already have a connection with another device
                              * by responding to the OBEX connect request.
                              */
                             Log.i(TAG, "RemoteDevice is invalid - creating ObexRejectServer.");
                             BluetoothObexTransport obexTrans =
                                     new BluetoothObexTransport(connSocket);
                             // Create and detach a selfdestructing ServerSession to respond to any
                             // incoming OBEX signals.
                             new ServerSession(obexTrans,
                                     new ObexRejectServer(
                                             ResponseCodes.OBEX_HTTP_UNAVAILABLE,
                                             connSocket),
                                     null);
                             // now wait for a new connect
                         } else {
                             // now wait for a new connect
                         }
                     } catch (IOException ex) {
                         if(mStopped == true) {
                             // Expected exception because of shutdown.
                         } else {
                             Log.w(TAG, "Accept exception for " +
                                     mServerSocket, ex);
                             ObexServerSockets.this.onAcceptFailed();
                         }
                         mStopped=true;
                     }
                 } // End while()
             } finally {
                 if (D) Log.d(TAG, "AcceptThread ended for: " + mServerSocket);
             }
         }

         /**
          * Shuts down the accept threads, and closes the ServerSockets, causing all related
          * BluetoothSockets to disconnect, hence do not call until all all accepted connections
          * are ready to be disconnected.
          */
         public void shutdown() {
             if(mStopped == false) {
                 mStopped = true;
                 // TODO: According to the documentation, this should not close the accepted
                 //       sockets - and that is true, but it closes the l2cap connections, and
                 //       therefore it implicitly also closes the accepted sockets...
                 try {
                      mServerSocket.close();
                 } catch (IOException e) {
                     if(D) Log.d(TAG, "Exception while thread shutdown:", e);
                 }
             }
             // If called from another thread, interrupt the thread
             if(!Thread.currentThread().equals(this)){
                 // TODO: Will this interrupt the thread if it is blocked in synchronized?
                 // Else: change to use InterruptableLock
                 if(D) Log.d(TAG, "shutdown called from another thread - interrupt().");
                 interrupt();
             }
         }
     }

 }
	/*
	* Copyright (C) 2015 Samsung System LSI
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.android.bluetooth;

	import java.io.IOException;
	import java.util.concurrent.CountDownLatch;

	import javax.obex.ObexSession;
	import javax.obex.ResponseCodes;
	import javax.obex.ServerSession;

	import android.bluetooth.BluetoothAdapter;
	import android.bluetooth.BluetoothDevice;
	import android.bluetooth.BluetoothServerSocket;
	import android.bluetooth.BluetoothSocket;
	import android.util.Log;

	/**
	* Wraps multiple BluetoothServerSocket objects to make it possible to accept connections on
	* both a RFCOMM and L2CAP channel in parallel.<br>
	* Create an instance using {@link #create()}, which will block until the sockets have been created
	* and channel numbers have been assigned.<br>
	* Use {@link #getRfcommChannel()} and {@link #getL2capPsm()} to get the channel numbers to
	* put into the SDP record.<br>
	* Call {@link #shutdown(boolean)} to terminate the accept threads created by the call to
	* {@link #create(IObexConnectionHandler)}.<br>
	* A reference to an object of this type cannot be reused, and the {@link BluetoothServerSocket}
	* object references passed to this object will be closed by this object, hence cannot be reused
	* either (This is needed, as the only way to interrupt an accept call is to close the socket...)
	* <br>
	* When a connection is accepted,
	* {@link IObexConnectionHandler#onConnect(BluetoothDevice, BluetoothSocket)} will be called.<br>
	* If the an error occur while waiting for an incoming connection
	* {@link IObexConnectionHandler#onConnect(BluetoothDevice, BluetoothSocket)} will be called.<br>
	* In both cases the {@link ObexServerSockets} object have terminated, and a new must be created.
	*/
	public class ObexServerSockets {
	private final String TAG;
	private static final String STAG = "ObexServerSockets";
	private static final boolean D = true; // TODO: set to false!
	private static final int NUMBER_OF_SOCKET_TYPES = 2; // increment if LE will be supported

	private final IObexConnectionHandler mConHandler;
	/* The wrapped sockets */
	private final BluetoothServerSocket mRfcommSocket;
	private final BluetoothServerSocket mL2capSocket;
	/* Handles to the accept threads. Needed for shutdown. */
	private SocketAcceptThread mRfcommThread = null;
	private SocketAcceptThread mL2capThread = null;

	private volatile boolean mConAccepted = false;

	private static volatile int sInstanceCounter = 0;

	private ObexServerSockets(IObexConnectionHandler conHandler,
	BluetoothServerSocket rfcommSocket,
	BluetoothServerSocket l2capSocket) {
	mConHandler = conHandler;
	mRfcommSocket = rfcommSocket;
	mL2capSocket = l2capSocket;
	TAG = "ObexServerSockets" + sInstanceCounter++;
	}

	/**
	* Creates an RFCOMM {@link BluetoothServerSocket} and a L2CAP {@link BluetoothServerSocket}
	* @param validator a reference to the {@link IObexConnectionHandler} object to call
	* to validate an incoming connection.
	* @return a reference to a {@link ObexServerSockets} object instance.
	* @throws IOException if it occurs while creating the {@link BluetoothServerSocket}s.
	*/
	public static ObexServerSockets create(IObexConnectionHandler validator) {
	return create(validator, BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP,
	BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP);
	}

	/**
	* Creates an RFCOMM {@link BluetoothServerSocket} and a L2CAP {@link BluetoothServerSocket}
	* with specific l2cap and RFCOMM channel numbers. It is the responsibility of the caller to
	* ensure the numbers are free and can be used, e.g. by calling {@link #getL2capPsm()} and
	* {@link #getRfcommChannel()} in {@link ObexServerSockets}.
	* @param validator a reference to the {@link IObexConnectionHandler} object to call
	* to validate an incoming connection.
	* @return a reference to a {@link ObexServerSockets} object instance.
	* @throws IOException if it occurs while creating the {@link BluetoothServerSocket}s.
	*
	* TODO: Make public when it becomes possible to determine that the listen-call
	* failed due to channel-in-use.
	*/
	private static ObexServerSockets create(IObexConnectionHandler validator,
	int rfcommChannel, int l2capPsm) {
	if(D) Log.d(STAG,"create(rfcomm = " +rfcommChannel + ", l2capPsm = " + l2capPsm +")");
	BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter();
	if(bt == null) {
	throw new RuntimeException("No bluetooth adapter...");
	}
	BluetoothServerSocket rfcommSocket = null;
	BluetoothServerSocket l2capSocket = null;
	boolean initSocketOK = false;
	final int CREATE_RETRY_TIME = 10;

	// It's possible that create will fail in some cases. retry for 10 times
	for (int i = 0; i < CREATE_RETRY_TIME; i++) {
	initSocketOK = true;
	try {
	if(rfcommSocket == null) {
	rfcommSocket = bt.listenUsingRfcommOn(rfcommChannel);
	}
	if(l2capSocket == null) {
	l2capSocket = bt.listenUsingL2capOn(l2capPsm);
	}
	} catch (IOException e) {
	Log.e(STAG, "Error create ServerSockets ",e);
	initSocketOK = false;
	}
	if (!initSocketOK) {
	// Need to break out of this loop if BT is being turned off.
	int state = bt.getState();
	if ((state != BluetoothAdapter.STATE_TURNING_ON) &&
	(state != BluetoothAdapter.STATE_ON)) {
	Log.w(STAG, "initServerSockets failed as BT is (being) turned off");
	break;
	}
	try {
	if (D) Log.v(STAG, "waiting 300 ms...");
	Thread.sleep(300);
	} catch (InterruptedException e) {
	Log.e(STAG, "create() was interrupted");
	}
	} else {
	break;
	}
	}

	if (initSocketOK) {
	if (D) Log.d(STAG, "Succeed to create listening sockets ");
	ObexServerSockets sockets = new ObexServerSockets(validator, rfcommSocket, l2capSocket);
	sockets.startAccept();
	return sockets;
	} else {
	Log.e(STAG, "Error to create listening socket after " + CREATE_RETRY_TIME + " try");
	return null;
	}
	}

	/**
	* Returns the channel number assigned to the RFCOMM socket. This will be a static value, that
	* should be reused for multiple connections.
	* @return the RFCOMM channel number
	*/
	public int getRfcommChannel() {
	return mRfcommSocket.getChannel();
	}

	/**
	* Returns the channel number assigned to the L2CAP socket. This will be a static value, that
	* should be reused for multiple connections.
	* @return the L2CAP channel number
	*/
	public int getL2capPsm() {
	return mL2capSocket.getChannel();
	}

	/**
	* Initiate the accept threads.
	* Will create a thread for each socket type. an incoming connection will be signaled to
	* the {@link IObexConnectionValidator#onConnect()}, at which point both threads will exit.
	*/
	private void startAccept() {
	if(D) Log.d(TAG,"startAccept()");
	prepareForNewConnect();

	mRfcommThread = new SocketAcceptThread(mRfcommSocket);
	mRfcommThread.start();

	mL2capThread = new SocketAcceptThread(mL2capSocket);
	mL2capThread.start();
	}

	/**
	* Set state to accept new incoming connection. Will cause the next incoming connection to be
	* Signaled through {@link IObexConnectionValidator#onConnect()};
	*/
	public void prepareForNewConnect() {
	if(D) Log.d(TAG, "prepareForNewConnect()");
	mConAccepted = false;
	}

	/**
	* Called from the AcceptThreads to signal an incoming connection.
	* This is the entry point that needs to synchronize between the accept
	* threads, and ensure only a single connection is accepted.
	* {@link mAcceptedSocket} is used a state variable.
	* @param device the connecting device.
	* @param conSocket the socket associated with the connection.
	* @return true if the connection is accepted, false otherwise.
	*/
	synchronized private boolean onConnect(BluetoothDevice device, BluetoothSocket conSocket) {
	if(D) Log.d(TAG, "onConnect() socket: " + conSocket + " mConAccepted = " + mConAccepted);
	if(mConAccepted == false && mConHandler.onConnect(device, conSocket) == true) {
	mConAccepted = true; // TODO: Reset this when ready to accept new connection
	/* Signal the remaining threads to stop.
	shutdown(false); */ // UPDATE: TODO: remove - redesigned to keep running...
	return true;
	}
	return false;
	}

	/**
	* Signal to the {@link IObexConnectionHandler} that an error have occurred.
	*/
	synchronized private void onAcceptFailed() {
	Log.w(TAG,"onAcceptFailed() calling shutdown...");
	mConHandler.onAcceptFailed();
	shutdown(false);
	}

	/**
	* Terminate any running accept threads
	* @param block Set true to block the calling thread until the AcceptThreads
	* has ended execution
	*/
	synchronized public void shutdown(boolean block) {
	if(D) Log.d(TAG, "shutdown(block = " + block + ")");
	if(mRfcommThread != null) {
	mRfcommThread.shutdown();
	}
	if(mL2capThread != null){
	mL2capThread.shutdown();
	}
	if(block == true) {
	while(mRfcommThread != null \|\| mL2capThread != null) {
	try {
	if(mRfcommThread != null) {
	mRfcommThread.join();
	mRfcommThread = null;
	}
	if(mL2capThread != null) {
	mL2capThread.join();
	mL2capThread = null;
	}
	} catch (InterruptedException e) {
	Log.i(TAG, "shutdown() interrupted, continue waiting...", e);
	}
	}
	} else {
	mRfcommThread = null;
	mL2capThread = null;
	}
	}

	/**
	* A thread that runs in the background waiting for remote an incoming
	* connect. Once a remote socket connects, this thread will be
	* shutdown. When the remote disconnect, this thread shall be restarted to
	* accept a new connection.
	*/
	private class SocketAcceptThread extends Thread {

	private boolean mStopped = false;
	private final BluetoothServerSocket mServerSocket;

	/**
	* Create a SocketAcceptThread
	* @param serverSocket shall never be null.
	* @param latch shall never be null.
	* @throws IllegalArgumentException
	*/
	public SocketAcceptThread(BluetoothServerSocket serverSocket) {
	if(serverSocket == null) {
	throw new IllegalArgumentException("serverSocket cannot be null");
	}
	mServerSocket = serverSocket;
	}

	/**
	* Run until shutdown of BT.
	* Accept incoming connections and reject if needed. Keep accepting incoming connections.
	*/
	@Override
	public void run() {
	try {
	while (!mStopped) {
	BluetoothSocket connSocket;
	BluetoothDevice device;

	try {
	if (D) Log.d(TAG, "Accepting socket connection...");

	connSocket = mServerSocket.accept();
	if (D) Log.d(TAG, "Accepted socket connection from: " + mServerSocket);

	if (connSocket == null) {
	// TODO: Do we need a max error count, to avoid spinning?
	Log.w(TAG, "connSocket is null - reattempt accept");
	continue;
	}
	device = connSocket.getRemoteDevice();

	if (device == null) {
	Log.i(TAG, "getRemoteDevice() = null - reattempt accept");
	try{
	connSocket.close();
	} catch (IOException e) {
	Log.w(TAG, "Error closing the socket. ignoring...",e );
	}
	continue;
	}

	/* Signal to the service that we have received an incoming connection.
	*/
	boolean isValid = ObexServerSockets.this.onConnect(device, connSocket);

	if(isValid == false) {
	/* Close connection if we already have a connection with another device
	* by responding to the OBEX connect request.
	*/
	Log.i(TAG, "RemoteDevice is invalid - creating ObexRejectServer.");
	BluetoothObexTransport obexTrans =
	new BluetoothObexTransport(connSocket);
	// Create and detach a selfdestructing ServerSession to respond to any
	// incoming OBEX signals.
	new ServerSession(obexTrans,
	new ObexRejectServer(
	ResponseCodes.OBEX_HTTP_UNAVAILABLE,
	connSocket),
	null);
	// now wait for a new connect
	} else {
	// now wait for a new connect
	}
	} catch (IOException ex) {
	if(mStopped == true) {
	// Expected exception because of shutdown.
	} else {
	Log.w(TAG, "Accept exception for " +
	mServerSocket, ex);
	ObexServerSockets.this.onAcceptFailed();
	}
	mStopped=true;
	}
	} // End while()
	} finally {
	if (D) Log.d(TAG, "AcceptThread ended for: " + mServerSocket);
	}
	}

	/**
	* Shuts down the accept threads, and closes the ServerSockets, causing all related
	* BluetoothSockets to disconnect, hence do not call until all all accepted connections
	* are ready to be disconnected.
	*/
	public void shutdown() {
	if(mStopped == false) {
	mStopped = true;
	// TODO: According to the documentation, this should not close the accepted
	// sockets - and that is true, but it closes the l2cap connections, and
	// therefore it implicitly also closes the accepted sockets...
	try {
	mServerSocket.close();
	} catch (IOException e) {
	if(D) Log.d(TAG, "Exception while thread shutdown:", e);
	}
	}
	// If called from another thread, interrupt the thread
	if(!Thread.currentThread().equals(this)){
	// TODO: Will this interrupt the thread if it is blocked in synchronized?
	// Else: change to use InterruptableLock
	if(D) Log.d(TAG, "shutdown called from another thread - interrupt().");
	interrupt();
	}
	}
	}

	}