Android bluetooth: Paired devices list

Question

I have a bluetooth device with SPP profile and bluetooth version 2.1.
I have an app which connects to that device and communicates with it. The device uses "Just Works" pairing technique.

I am facing a problem on certain phones like Samsung Galaxy tablet, Galaxy S.

The problem is after the user exits from the app, I am closing the sockets and disconnecting from the device. After successful disconnection, it is observed that the device's entry is removed from the paired devices list.

Answer 1

I haven't worked with tablets, but I did write an app that used SPP for Android phones. What I found was that in order to get Bluetooth to be stable, I have to manually bond with the device I want to communicate with. We used the code below to initiated bonding from within the app, and it should preserve the bonding just as if you manually paired through the settings menu.

Here is the general flow: 1) Register a BroadcastReceiver to listen for BluetoothDevice.ACTION_BOND_STATE_CHANGED
2) After device discovery you should have a BluetoothDevice object.
3) Use reflection to call 'createBond' method on a BluetoothDeviceObject
3a) Wait for bond state change events before opening sockets

BluetoothDevice device = {obtained from device discovery};
Method m = device.getClass().getMethod("createBond", (Class[])null);
m.invoke(device, (Object[])null);

int bondState = device.getBondState();
if (bondState == BluetoothDevice.BOND_NONE || bondState == BluetoothDevice.BOND_BONDING)
{
    waitingForBonding = true; // Class variable used later in the broadcast receiver

    // Also...I have the whole bluetooth session running on a thread.  This was a key point for me.  If the bond state is not BOND_BONDED, I wait here.  Then see the snippets below
    synchronized(this)
    {
        wait();
    }
}

4) Wait for the bond state to change from BOND_BONDING to BOND_BONDED

Inside a BroadcastReciever:

public void onReceive(Context context, Intent intent)
{
    if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(intent.getAction()))
    {
        int prevBondState = intent.getIntExtra(BluetoothDevice.EXTRA_PREVIOUS_BOND_STATE, -1);
        int bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, -1);

        if (waitingForBonding)
        {
            if (prevBondState == BluetoothDevice.BOND_BONDING)
            {
                // check for both BONDED and NONE here because in some error cases the bonding fails and we need to fail gracefully.
                if (bondState == BluetoothDevice.BOND_BONDED || bondState == BluetoothDevice.BOND_NONE)
                {
                    // safely notify your thread to continue
                }
            }
        }
    }
}

5) Open sockets and communicate

You can also you the 'removeBond' method via reflection to remove your device from the pairing list.

Hope this helps!

Answer 2

If the pairing is happening as a consequence of your app connecting, I am guessing that some devices will consider it as a temporary pairing and will not keep the device in the paired list after the connection is disconnected. To retain the device in paired list you should manually pair through the Bluetooth settings menu. Once paired your program can connect / disconnect and the device will retain itself in the paired list.

Answer 3

I also experienced the same problem with a Sony Xperia X10. I managed to make it "remember" the pairing by changing the security level settings on the bluetooth device side (as I am developing the device also).

I am not sure about the "temporary pairing" explanation, that would be manufacturer dependent, it doesn't make much sense that different phones would react differently to a connection with the same device.

However it is the unbounding part that is a problem for me. Typically the Bluetooth stack seems to crash when the user is unpairing a device while the application is connected in the background. I still haven't figure out how to manage the ACTION_BOND_STATE_CHANGED event properly.