Android: bluetooth socket failure for proper connection

Question

I have a bluetooth transmitter trying to connect to a service that I wrote based on BluetoothChat (Android API).

as soon as I run the command mAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME, MY_UUID), bluetooth automatically connects (before the command accept();, thereby making accept block the stream). any ideas?

I assume that in the previous run there is a socket that did not close properly - while debugging in this direction did not reveal anything interesting.

The code:

public class BluetoothService extends Service {


    // Unique UUID for this application
    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");



    @Override
    public void onCreate() {
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        if (mAdapter == null) {
            Log.e(TAG, "Bluetooth is not available");
            stopSelf();
            return;
        }

        mState = STATE_NONE;
    }
    @Override
    public int onStartCommand(Intent BluetoothService, int flags, int startId ) {
        /**
        * Start the chat service. Specifically start AcceptThread to begin a
        * session in listening (server) mode. Called by the Activity onResume() */


        if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}

        // Start the thread to listen on a BluetoothServerSocket
        if (mAcceptThread == null) {
            mAcceptThread = new AcceptThread();
            mAcceptThread.start();
            }
        setState(STATE_LISTEN);
        return START_NOT_STICKY;
    }

    /**
     * This thread runs while listening for incoming connections. It behaves
     * like a server-side client. It runs until a connection is accepted
     * (or until cancelled).
     */
     private class AcceptThread extends Thread 
     {
         // The local server socket
         private BluetoothServerSocket mmServerSocket = null;

         public AcceptThread() 
         {
             BluetoothServerSocket tmp = null;

             // Create a new listening server socket
             try 
             {
                 //mmServerSocket = mAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME, MY_UUID);
                 tmp= mAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME, MY_UUID);
             } 
             catch (IOException e) 
             {
                 e.printStackTrace();
                 stopSelf();
             }              
             mmServerSocket = tmp;
         }

         public void run() {
              setName("AcceptThread");
              socket = null;
             // Listen to the server socket if we're not connected
             while (mState != STATE_CONNECTED) {
                 try {
                     // This is a blocking call and will only return on a
                     // successful connection or an exception
                     if (socket==null)
                         socket = mmServerSocket.accept();
                     } catch (IOException e) {
                         break;
                         }
                 // If a connection was accepted
                 if (socket != null) {
                     synchronized (BluetoothService.this) {
                         switch (mState) {
                             case STATE_LISTEN:
                             // Situation normal. Start the connected thread.
                             connected(socket, socket.getRemoteDevice());
                             break;
                             case STATE_NONE:
                             case STATE_CONNECTED:
                                 // Either not ready or already connected. Terminate new socket.
                                 try {
                                     socket.close();
                                     } catch (IOException e) {
                                     }
                                    break;
                                }
                            }
                        }
                  }
                  }

           public void cancel() 
           {
               try {
                   if(mmServerSocket!=null) mmServerSocket.close();
                   } catch (IOException e) {
                       Log.e(TAG, "close() of server failed", e);
                   }
           }
     }

        /**
        * Indicate that the connection was lost and notify the UI Activity.
        */
     private void connectionLost() {
         setState(STATE_LISTEN);
        // Start the service over to restart listening mode
            // Start the thread to listen on a BluetoothServerSocket
            if (mAcceptThread == null) {
                mAcceptThread = new AcceptThread();
                mAcceptThread.start();
                }
     }

     /**
      * This thread runs during a connection with a remote device.
      * It handles all incoming and outgoing transmissions.
      */
     private class ConnectedThread extends Thread {          
         public ConnectedThread(BluetoothSocket socket) {
             Log.d(TAG, "create ConnectedThread");
             InputStream tmpIn = null;
             OutputStream tmpOut = null;
             tabulkaBluetooth=socket.getRemoteDevice();
             tabulkaMac=tabulkaBluetooth.getAddress(); //MAC address of the tabulka to be used as ID at the server

             // We need an Editor object to make preference changes.
              // All objects are from android.context.Context

             // editor.commit();
             // Get the BluetoothSocket input and output streams
             try {
                 tmpIn = socket.getInputStream();
                 tmpOut = socket.getOutputStream();
                 } catch (IOException e) {
                     Log.e(TAG, "temp sockets not created", e);
                 }
                 mmInStream = tmpIn;
                 mmOutStream = tmpOut;
         }

         public void run() {
             Log.i(TAG, "BEGIN mConnectedThread");

                 int bytes;
             String coordinates = ""; //new coordinates from the tabulka
             String newCoordinates=null;
             byte[] buffer = new byte[1024];
             // Keep listening to the InputStream while connected
             int inputStreamAviableBool=0; //0- not aviable 1-aviable
             //---------diagnostic msg
             byte[] sendBuffer = new byte[3];
             sendBuffer[0] = 0x0a;
             sendBuffer[1] = 1;
             sendBuffer[2] = 'A';
             try {
                mmOutStream.write(sendBuffer);
            } catch (IOException e2) {
                // TODO Auto-generated catch block
                e2.printStackTrace();
            }
            //---------end of diagnostic msg 
             SystemClock.sleep(1000) ;
             int numOfInputReads=1;
             while(numOfInputReads<3)
             {
                 try {
                     inputStreamAviableBool=mmInStream.available();
                } catch (IOException e1) {
                     Log.e(TAG, "checking availability of inputStream IOException:", e1);
                }

                  while(inputStreamAviableBool!=0 ){
                        try{
                            bytes = mmInStream.read(buffer);
                            if(bytes == -1)
                                 Log.e(TAG, "input stream is over");
                        } catch (IOException e) {
                             Log.e(TAG, "reading from inputStream IOException:", e);
                        }
                        newCoordinates = new String(buffer);
                        coordinates=coordinates+newCoordinates;
                        try {
                            numOfInputReads++;
                            SystemClock.sleep(2000) ;
                            mmOutStream.write(sendBuffer);
                        } catch (IOException e2) {
                            // TODO Auto-generated catch block
                            e2.printStackTrace();
                        }
                        try {
                             inputStreamAviableBool=mmInStream.available();
                        } catch (IOException e1) {
                             Log.e(TAG, "checking availability of inputStream IOException:", e1);
                        }
                        if(inputStreamAviableBool>=3) inputStreamAviableBool=0;
                    }
                  numOfInputReads++;
                  SystemClock.sleep(2000) ;
             }

         disconnect();
         connectionLost();
         stopSelf();
         //-------end--------debuging 
         }  

         public void cancel() {
         try {
        //  if(mmSocket!=null) mmSocket.close();
             if(socket!=null) socket.close();
             } catch (IOException e) {
                     Log.e(TAG, "close() of connect socket failed", e);
                 }
         }

         private void disconnect() {
            Log.d(TAG, "closing");

            if (mmInStream != null) {
                try {
                    mmInStream.close();

                } catch (IOException e) {
                    Log.e(TAG, "isBt IOE", e);              
                }
                mmInStream = null;


            }

            if (mmOutStream != null) {
                try {
                    mmOutStream.close();

                } catch (IOException e) {
                    Log.e(TAG, "isBt IOE", e);              
                }
               mmOutStream = null;

            }

           if (socket != null) {
                try{
                   socket.close();
                    }
                   catch (IOException e) {
                        Log.e(TAG, "socket haven't been close", e);              
                    }
               socket = null;

            }
            Log.d(TAG, "closed");       
        }

     }

     /**
      * Start the ConnectedThread to begin managing a Bluetooth connection
      * @param socket  The BluetoothSocket on which the connection was made
      * @param device  The BluetoothDevice that has been connected
      */
     public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
         if (D) Log.d(TAG, "connected");
         // Cancel any thread currently running a connection
         if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}
         // Cancel the accept thread because we only want to connect to one device
         if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}
         // Start the thread to manage the connection and perform transmissions
         mConnectedThread = new ConnectedThread(socket);
         mConnectedThread.start();


         setState(STATE_CONNECTED);
     }


}