Application using bluetooth SPP profile not working after update from Android 4.2 to Android 4.3

Question

I wrote a simple application based on bluetoothChat. I communicate between the phone and a bluetooth module using SPP profile. The phone always initiates the communication. The application worked pefectly on Android 4.2, using Nexus 3 and Samsung Galaxy 3. After the update to Android 4.3, the application does not work anymore. I connect all the time, I can send an outpustream and receive the right data, but after the 1st outputstream command, the application always disconnected after around 6s. As shown in the logcat below, it looks there is a timer issue on the inputstream.

08-23 14:10:00.726: D/mems(23193): STEVAL-MKI106V1
08-23 14:10:00.804: D/Main Activity(23193): firmware version*setdb106V1
08-23 14:10:00.812: D/Main Activity(23193): sent message*setdb106V1
08-23 14:10:00.812: D/BluetoothMEMSCommunication(23193): dans write3
08-23 14:10:00.812: D/BluetoothMEMSCommunication(23193): envoi stream
08-23 14:10:05.812: W/bt-btif(20368): dm_pm_timer expires
08-23 14:10:05.812: W/bt-btif(20368): dm_pm_timer expires 0
08-23 14:10:05.812: W/bt-btif(20368): proc dm_pm_timer expires
08-23 14:10:11.656: E/bt-btm(20368): btm_sec_disconnected - Clearing Pending flag
08-23 14:10:11.656: W/bt-btif(20368): invalid rfc slot id: 15
08-23 14:10:11.656: I/connection(23193): connectionlost

What is dm_pm_timer? I tried to connect a different way, with secure and insecure rfcom. I know the bluetooth chat is not optimized to receive the buffer, so I modified it, not no effect. I used the flush command for the outpustream too, but no effect either.

package com.meneujj.memsbtbis;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.widget.Toast;

public class BluetoothMEMSCommunication {

// debugging
private static final String TAG = "BluetoothMEMSCommunication";
private static final boolean D = true;


// eMotion BT h as this standard UUID
private static final UUID STANDARD_UUID = 
        UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");


// Member fields
private final BluetoothAdapter mAdapter;
private final Handler mHandler;
private int mState;
private int handlerCalling;
private ConnectThread mConnectThread;
private ConnectedThread mConnectedThread;

      // Constants they indicate the current connection state
public static final int STATE_NONE = 0;
public static final int STATE_CONNECTED = 3; // now connected to a remote device

// constructor. Prepares a new Bluetooth Connection
// context The UI Activity Context
// handler an Handler to send messages back to the UI Activity

public BluetoothMEMSCommunication(Context context, Handler handler, int i) {
    mAdapter = BluetoothAdapter.getDefaultAdapter();
    mState = STATE_NONE;
    mHandler = handler;
    handlerCalling = i;

}


private synchronized void setState(int state) {
    mState = state;
    Log.d(TAG, Integer.toString(mState));
    mHandler.obtainMessage(MainActivityMemsBT.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
}

public synchronized void connect(BluetoothDevice device) {


    // start the thread to connect with the given device
    if (mConnectThread != null) {
        mConnectedThread.cancel();
        mConnectedThread = null;

    }

    // cancel any thread currently running a connection
    if (mConnectedThread != null) {
        mConnectedThread.cancel();
        mConnectedThread = null; 

    }

    Log.d(TAG,"routine connect lancee");
    mConnectThread = new ConnectThread(device);
    mConnectThread.start();

}


private void ConnectionLost() {
    // Send a failure message back to the activity
    Message msg = mHandler.obtainMessage(MainActivityMemsBT.CONNECTION_LOST_MESSAGE);
    Bundle bundle = new Bundle();
    bundle.putString(MainActivityMemsBT.TOAST_CONNECTION_LOST, "Device connection was lost");
    msg.setData(bundle);
    mHandler.sendMessage(msg);
    Log.i("connection","connectionlost");

    setState(STATE_NONE);
    StopAllThreads();

}



public synchronized void StopAllThreads() {

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

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

    }

setState(STATE_NONE);

}

public synchronized void connected(BluetoothSocket socket, BluetoothDevice device, final String socketType) {

    // cancel the thread they completed the connection
    if (mConnectThread != null) {
        mConnectThread.cancel();
        mConnectThread = null;
    }

    // Cancel any thread currently running a connection
    if (mConnectedThread != null) {
        mConnectedThread.cancel();
        mConnectedThread = null;

    }


    // Start the thread to manage the connection and perform transmission
    mConnectedThread = new ConnectedThread(socket, socketType);
    mConnectedThread.start();

    // Send the name of the connected device back to the UI activity
    Message msg = mHandler.obtainMessage(MainActivityMemsBT.MESSAGE_DEVICE_NAME);
    Bundle bundle = new Bundle();
    bundle.putString(MainActivityMemsBT.DEVICE_NAME, device.getName());
    msg.setData(bundle);
    mHandler.sendMessage(msg);      

    setState(STATE_CONNECTED);

}


      public void write(byte[] out) {
// create temporary object
ConnectedThread r;

Log.d(TAG,"dans write" + Integer.toString(mState));

// synchronize a copy of the ConnectedThread
synchronized (this) {

    if (handlerCalling == 2) setState(STATE_CONNECTED);

    if (mState != STATE_CONNECTED) {
        Log.d(TAG, "different de STATE_CONNECTED");
        Log.i(TAG, Integer.toString(handlerCalling));
        return;}

    r= mConnectedThread;
}

r.write(out);

   }

Any idea is there is a workaround? Or any obvious mistake in my code

Thanks

// Thread runs while attempting to an an outgoing connection with a device.
// it runs straight through; the connection either succeeds or fails.
private class ConnectThread extends Thread {

    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
    private String mSocketType;

    public ConnectThread(BluetoothDevice device) {
        mmDevice = device;
        BluetoothSocket tmp = null;

        try {
        tmp = device.createRfcommSocketToServiceRecord(STANDARD_UUID);
            //tmp = device.createInsecureRfcommSocketToServiceRecord(STANDARD_UUID);

/*          try {
                Method m = device.getClass().getMethod("createRfcommSocket", new Class[] {int.class});
                try {
                    tmp = (BluetoothSocket) m.invoke(device, 1);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (NoSuchMethodException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } */

        } catch (IOException e) {

        }
        mmSocket = tmp;

    }

    public void run () {

        setName("ConnectThread" + mSocketType);
        mAdapter.cancelDiscovery();

        try {
            mmSocket.connect();
        } catch (IOException e) {

            try {
                mmSocket.close();
            } catch (IOException e2) {
                Log.e(TAG, "unable to close() " + mSocketType + "socket during connection failure", e2);
            }

        return; 
        }

    // reset the CoonectThread because the job is over
    synchronized (BluetoothMEMSCommunication.this) {
        mConnectThread = null;
        }

    connected(mmSocket, mmDevice, mSocketType);

    }

    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) {

        }
    }

      // close connectThread class      
}


     private class ConnectedThread extends Thread {

private final BluetoothSocket mmSocket;
private final InputStream mmInStream;
private final OutputStream mmOutStream;

public ConnectedThread(BluetoothSocket socket, String socketType) {

    mmSocket = socket;
    InputStream tmpIn = null;
    OutputStream tmpOut = null;

    try {
        tmpIn = socket.getInputStream();
        tmpOut = socket.getOutputStream();

    } catch (IOException e) {
        ConnectionLost();

    }

    mmInStream = tmpIn;
    mmOutStream = tmpOut;

}

//  Thread to listen to input sockets

public void run() {

    Log.i(TAG, "Begin mConnectedThread");

    byte[] buffer = new byte[1024];
//  int bytes;
    int bytesRead = -1;
    String message = "";

    // keep listening to the InputStream while connected
    while(true) {


            try {

                // read from the input stream
            //  bytesRead = mmInStream.read(buffer);
        //      message = message+ new String(buffer, 0, bytesRead);

            //  byte[] byteString = message.getBytes();

                Log.i("info","pret a faire read");
                bytesRead = mmInStream.read(buffer, 0, 1024);

                if (bytesRead != -1 && handlerCalling == 1) {
                mHandler.obtainMessage(MainActivityMemsBT.MESSAGE_READ, bytesRead, -1, buffer).sendToTarget(); }

                if (bytesRead !=-1 && handlerCalling == 2) {
                    mHandler.obtainMessage(DemoAccelerometer.MESSAGE_READ, bytesRead, -1, buffer).sendToTarget(); }

                }

             catch (IOException e) {

                 ConnectionLost();
                break;
            }


            }

        }


public void write(byte[] buffer) {

    try{
        mmOutStream.write(buffer);

//      if (handlerCalling == 1) {
//      mHandler.obtainMessage(MainActivityMemsBT.MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
        Log.d(TAG,"envoi stream");

    //  mmOutStream.flush();
//      }

    } catch (IOException e) {

    }

}

public void cancel() {
    try{
        mmSocket.close();
    } catch (IOException e) {

    }
}

   }

    }

Answer 1

We can confirm the Bluetooth disconnect after 6 seconds when communicating from our Nexus 4 app to an external Bluetooth ECG (medical device) after upgrading from Android 4.2 to 4.3. This happens specifically during an ECG measurement with lots of inbound data (from ECG to the Android app) but no outbound data. "Normal" Bluetooth communication with some inbound and outbound data from time to time does not seem to be affected.

After 6 seconds we see the same adb log messages reported by JJM

dm_pm_timer expires
dm_pm_timer expires 0
proc dm_pm_timer expires
btm_sec_disconnected - Clearing Pending flag

This timer expiry on the Android side triggers something (closing output stream because no outbound data?) on the external Bluetooth ECG which in turn sends an ECG specific command we receive on the input stream that we never receive on the Nexus 4 with Android 4.2.

Changing the Android app implementation to occasionally send an arbitrary "keep alive" command to the ECG solves the problem. The timer expiry does not appear in the adb logs anymore and the ECG measurement now behaves the same as with Android 4.2.

Thanks to JJM for the hints.

Answer 2

I found a work around. It is disconnected if there is no streaming activity for a few seconds. I managed to have some output or input streaming several times per second, and it never disconnects now.

Answer 3

I found on StackOverflow an answer that helped me to fix the problem. I guess it has something to do with the inputStream and outputStream not being closed properly and nulled, as well as the bluetooth socket. After using this function:

 * Reset input and output streams and make sure socket is closed. 
     * This method will be used during shutdown() to ensure that the connection is properly closed during a shutdown.  
     * @return
     */
    private void resetConnection() {
        setState(STATE_NONE);
        Log.d(TAG, "reset connection");
        if (mmInStream != null) {
            try {
                mmInStream.close();
            } catch (Exception e) {
                Log.d(TAG,"exception in closing inputstream - " + e.getMessage());
            }
            mmInStream = null;
        }
        if (mmOutStream != null) {
            try {
                mmOutStream.close();
            } catch (Exception e) {
                Log.d(TAG,"exception in closing outputstream - " + e.getMessage());
            }
            mmOutStream = null;
        }
        if (mmSocket != null) {
            try {
                mmSocket.close();
            } catch (Exception e) {
                Log.d(TAG,"exception in closing socket - " + e.getMessage());
            }
            mmSocket = null;
        }
    }

in ConnectedThread and call it when necessary, i removed that problem. It could be also a problem with reading from the inputStream, maybe because there was nothing in there when attempting to read.

I suggest that you do a boolean function readWrite() that whenever you write to outputStream you also read the inputStream and send the readBuffer to UI with mHandler. If both read and write are ok, than return true, if one of them went wrong than return false and use resetConection before closing your ConnectedThread.

It worked very nice for me.

UPDATE: (30-SEPT-2013) I am running my app and I still get the hci_status = 36 after few minutes. I have an app, that connects to an external bluetooth device. I am sending data and receive data approx. 3 times / sec. I am using a Thread.sleep(300) between writes. In my tests I got this error after few minutes up to almost 30 minutes when running the app.

Any feedback is appreciated!