Having Android reconnect to a bonded peripheral without user interaction

RE: Having Android reconnect to a bonded peripheral without user interaction

Zami — Sat, 24 Sep 2022 15:45:34 GMT

I know this is an old post but since no one really answered it I'll show what I did. This is written in Kotlin btw.

I don't know if this is the best solution but it works for my case. I wanted the app to auto connect to a peripheral device that's previously bonded and advertising.

I created a fragment that runs the code below. The fragment is part of a fragment container and is part of the the MainActivity layout.

It basically registers a bluetooth broadcast receiver to watch the state. When bluetooth is turned on, it reads through the bonded devices list and if one of the devices has the name of your device then it will call Nordic's autoconnect function for the device.

class DeviceMonitorFragment : Fragment() {
    private var _fragmentDeviceMonitorBinding: FragmentDeviceMonitorBinding? = null
    private val fragmentDeviceMonitorBinding get() = _fragmentDeviceMonitorBinding!!

    /**
     * Checks the bluetooth state and try to auto connect the
     * ble device when bluetooth is turned on and active.
     * The device should connect if it is on and bonded.
     * Otherwise the user will have to manually connect it from
     * the scanner fragment or through the Android Bluetooth settings.
     */
    private val mReceiver: BroadcastReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            val action = intent.action
            if (BluetoothAdapter.ACTION_STATE_CHANGED == action) {
                when (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1)) {
                    BluetoothAdapter.STATE_TURNING_OFF,
                    BluetoothAdapter.STATE_OFF,
                    BluetoothAdapter.STATE_TURNING_ON,
                    -> {
                    }
                    BluetoothAdapter.STATE_ON -> {
                        // Attempt to connect device
                        autoConnectDeviceIfMatch(requireContext())
                    }
                }
            }
        }
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?,
    ): View {
        _fragmentDeviceMonitorBinding = FragmentDeviceMonitorBinding.inflate(inflater, container, false)
        return fragmentDeviceMonitorBinding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        /** Register broadcast receiver to watch bluetooth state */
        requireContext().registerReceiver(mReceiver, IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED))

        /** Attempt to connect device if bluetooth is enabled and device is advertising */
        autoConnectDeviceIfMatch(requireContext())
    }

    /**
     * Connects to the ble device if it is bonded and the
     * name matches our device name
     *
     * @param context
     */
    @SuppressLint("MissingPermission")
    fun autoConnectDeviceIfMatch(context: Context){
        val manager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
        if(manager.adapter.isEnabled){
            val devices = manager.adapter.bondedDevices
            devices.forEach { device ->
                if (device.bondState == BluetoothDevice.BOND_BONDED && device.name == context.getString(R.string.app_name)) {
                    DataShared.device.connect(context, device)
                    return@forEach // exit on match
                }
            }
        }
    }

    override fun onDestroy() {
        requireContext().unregisterReceiver(mReceiver)
        _fragmentDeviceMonitorBinding = null
        super.onDestroy()
    }
}

The code below would be located in a device manager of sorts. Similar to the Blinky example for Android.

    /**
     * Connect to the given peripheral
     * (Primarily for use by the auto-bonding)
     *
     * @param target the target device
     */
    @SuppressLint("MissingPermission")
    fun connect(context: Context, target: BluetoothDevice) {
        if (_bleDevice == null) {
            _bleDevice = target
            val logSession = Logger
                .newSession(context, null, target.address, target.name)
            _bleDeviceManager.setLogger(logSession)
        }
        
        autoConnect()
    }

    /**
     * Reconnects to previously connected device
     * If this device was not supported, its services were cleared on disconnection, so
     * reconnection may help
     */
    private fun autoConnect() {
        if (_bleDevice != null) {
            _bleDeviceManager.connect(_bleDevice!!)
                .retry(3, 100)
                .useAutoConnect(true)
                .enqueue()
        }
    }

RE: Having Android reconnect to a bonded peripheral without user interaction

wen — Wed, 19 Nov 2014 07:49:17 GMT

Excuse me , did you solve the problem ? I have the same question about auto reconnect when BLE device disconnect and come back in range and starts advertising.

RE: Having Android reconnect to a bonded peripheral without user interaction

Eliot Stock — Mon, 07 Jul 2014 20:56:54 GMT

Here's some interesting Javadoc from BluetoothGatt.connect() method (not the public one) in the AOSP source, which rather implies that subsequent connections are to be made programmatically:

The autoConnect paramter determines whether to actively connect to the remote device, or rather passively scan and finalize the connection when the remote device is in range/available. Generally, the first ever connection to a device should be direct (autoConnect set to false) and subsequent connections to known devices should be invoked with the autoConnect parameter set to true.

RE: Having Android reconnect to a bonded peripheral without user interaction

Eliot Stock — Fri, 04 Jul 2014 14:21:51 GMT

Thanks. Was aware of that autoConnect param but in my experience passing true there does NOT mean that a peripheral that's been disconnected for days then reappears will be reconnected.

RE: Having Android reconnect to a bonded peripheral without user interaction

leo — Fri, 04 Jul 2014 12:35:38 GMT

As far as i know it scans with a callback if you start startLEScan, but there is the possibility to set a flag for an auto-connect if the device is available:

mBluetoothGatt = device.connectGatt(this, false, mGattCallback);

The second parameter is the autoConnect parameter [1] (boolean indicating whether to automatically connect to the BLE device as soon as it becomes available). So, i guess it scans in the background without starting it (otherwise, it wouldn't be possible to auto reconnect)

Was this your question? cheers

[1] developer.android.com/.../bluetooth-le.html

RE: Having Android reconnect to a bonded peripheral without user interaction

gootoomoon — Fri, 04 Jul 2014 12:19:55 GMT

the same question like you