When cancelling the bluetooth server socket before accepting, the whole process dies. Why?

I am compiling for SDK 10 (2.3.3):

android:minSdkVersion="10"
android:targetSdkVersion="16"

I am testing on two Sony Ericsson smartphones. One has Android 2.3.7 on it and the other 4.0.1.

  • Hide RecyclerView scrollbar
  • Android: Set color of CheckBox
  • Dialog on Android KitKat seems to be cut
  • How do I convert pt to sp?
  • How to use the ORMLite query builder to get the total records in a table
  • How to achieve this folding effect in android?
  • I am using listenUsingInsecureRfcommWithServiceRecord to open a new server socket on bluetooth and listen to connections.

    If the connection is accepted successfully then everything works fine. I can even try to cancel the server socket but that does not seem to bother the connection socket just created.

    BUT when I want to cancel the server socket before having accepted any connections as soon as the line bluetoothServerSocket.close(); gets executed the entire activity closes and the process dies. And furthermore this is not a regular exception which I could handle.

    Actually even logcat itself quits!! and I have to quickly execute it again in order to grab the errors you can see below:

    Zygote  D  Process 25471 terminated by signal (11)
      295         InputDispatcher  W  channel '2c2e20a8 com.pligor.test/activities.MainActivity (server)' ~ Consumer closed input channel or an error occurred.  events=0x8
      295         InputDispatcher  E  channel '2c2e20a8 com.pligor.test/activities.MainActivity (server)' ~ Channel is unrecoverably broken and will be disposed!
      295                dalvikvm  D  GC_FOR_ALLOC freed 1299K, 21% free 13252K/16583K, paused 93ms
      295         InputDispatcher  W  Attempted to unregister already unregistered input channel '2c2e20a8 com.pligor.test/activities.MainActivity (server)'
      295        BluetoothService  D  Tracked app 25471 diedType:10
      295        BluetoothService  D  Removing service record 10009 for pid 25471
      132          SurfaceFlinger  D  Release buffer at 0x61c08
      295           WindowManager  I  WINDOW DIED Window{2c2e20a8 com.pligor.test/activities.MainActivity paused=false}
      295         ActivityManager  I  Process com.pligor.test (pid 25471) has died.
      295         ActivityManager  W  Force removing ActivityRecord{2c021800 com.pligor.test/activities.MainActivity}: app died, no saved state
      295           WindowManager  W  Failed looking up window
      295           WindowManager  W  java.lang.IllegalArgumentException: Requested window android.os.BinderProxy@2bf3e798 does not exist
      295           WindowManager  W    at com.android.server.wm.WindowManagerService.windowForClientLocked(WindowManagerService.java:7165)
      295           WindowManager  W    at com.android.server.wm.WindowManagerService.windowForClientLocked(WindowManagerService.java:7156)
      295           WindowManager  W    at com.android.server.wm.WindowState$DeathRecipient.binderDied(WindowState.java:1545)
      295           WindowManager  W    at android.os.BinderProxy.sendDeathNotice(Binder.java:417)
      295           WindowManager  W    at dalvik.system.NativeStart.run(Native Method)
      295           WindowManager  I  WIN DEATH: null
      295      BluetoothEventLoop  D  Property Changed: UUIDs : 11
      295    hAdapterStateMachine  D  BluetoothOn process message: 51
      295     InputManagerService  W  Got RemoteException sending setActive(false) notification to pid 25471 uid 10040
    

    Note: Process terminated by signal (11) means Segmentation fault (http://en.wikipedia.org/wiki/SIGSEGV).

    EDIT

    I create the Bluetooth server socket using the following code (Scala):

    private val bluetoothServerSocket: BluetoothServerSocket = try {
        bluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord(MY_SERVICE_NAME_INSE‌​CURE, MY_UUID_INSECURE); 
    } 
    catch { 
        case e: IOException => throw new ServerSocketException; 
    } 
    

    I use this code to close the Bluetooth socket:

    try { 
        isCancelled = true; 
        bluetoothServerSocket.close(); 
    } catch { 
        case e: IOException => throw new NotClosedException; 
    }
    

  • Why BroadcastReceiver works even when app is in background ?
  • Android M weird shared preferences issue
  • Is there a way prevent AlertDialog from closing with invalid inputs?
  • notification icon gets cropped
  • Set Background Color of Navigation Drawer
  • Which Eclipse version should I use for an Android app?
  • 3 Solutions collect form web for “When cancelling the bluetooth server socket before accepting, the whole process dies. Why?”

    I have experienced a similar issue and the root cause of the problem was calling close on a socket more than once. To correct this problem, I wrapped my bluetooth sockets in a special class to prevent the close method from being called more than once.

    Be aware that closing the streams created by a bluetooth socket are capable of calling close on the socket. The following solves the problem.

    public class CloseOnceBluetoothSocket 
    {
    private final BluetoothSocket mSocket;
    private boolean mIsClosed;
    
    public CloseOnceBluetoothSocket(BluetoothSocket socket)
    {
        this.mSocket = socket;
    }
    
    public void connect() throws IOException
    {
        mSocket.connect();
    }
    
    public InputStream getInputStream() throws IOException
    {
        return new FilterInputStream(mSocket.getInputStream()) {
            @Override
            public void close() throws IOException
            {
                CloseOnceBluetoothSocket.this.close();
            }
        };
    }
    
    public OutputStream getOutputStream() throws IOException
    {
        return new FilterOutputStream(mSocket.getOutputStream()) {
            @Override
            public void close() throws IOException
            {
                CloseOnceBluetoothSocket.this.close();
            }
        };
    }
    
    public void close() throws IOException
    {
        synchronized (mSocket) {
            if (!mIsClosed) {
                mSocket.close();
                mIsClosed = true;
            }
        }
    }
    }
    

    If closing the socket causes that much damage then why not just create a boolean flag that is set to true when the user is connected and set to false when the user disconnects; then only call close when the user was previously connected.

    I think I have found a workaround for this issue. The “I think” is because this has not been tested on many devices yet.

    code below is Scala

    For the workaround I take advantage of the overloaded method accept(int) which has a timeout

    So we have a variable for the state of the infinite loop you are seeing below

    private var toContinue = true;
    

    We just repeat accepting in a while loop

    while (toContinue) {
      try {
        //this is a blocking call and will only return on a successful connection or an exception, or on timeout
        val socket = bluetoothServerSocket.accept(10000); //msec
    
        connectionAccepted(socket);
      } catch {
        case e: IOException => {
          Logger("accepting timed out");
        }
      }
    }
    

    So now instead of calling the bluetoothServerSocket.close() we are just setting variable to false

    def cancel() {
        toContinue = false;
    }
    

    Actual code is a little bit more complex since you need a callback function to do something upon the exit of the while loop but the main issue is resolved as shown above

    Android Babe is a Google Android Fan, All about Android Phones, Android Wear, Android Dev and Android Games Apps and so on.