Merge pull request #209 from NordicSemiconductor/improvement/disconnection

Improvement related to disconnection

Author: philips77

client-android/src/main/java/no/nordicsemi/kotlin/ble/client/android/internal/NativeExecutor.kt

@@ -211,6 +211,7 @@ internal class NativeExecutor(
 
     override fun disconnect(): Boolean {
         gatt?.let { gatt ->
+            gattCallback.disconnectRequest = true
             gatt.disconnect()
             return true
         }
@@ -220,6 +221,7 @@ internal class NativeExecutor(
     override fun close() {
         gatt?.let { gatt ->
             this.gatt = null
+            gattCallback.disconnectRequest = false
             try {
                 gatt.disconnect()
             } catch (_: Exception) {

client-android/src/main/java/no/nordicsemi/kotlin/ble/client/android/internal/NativeGattCallback.kt

@@ -60,13 +60,27 @@ internal class NativeGattCallback: BluetoothGattCallback() {
     private val _events: MutableSharedFlow<GattEvent> = MutableSharedFlow(extraBufferCapacity = 64)
     val events: SharedFlow<GattEvent> = _events.asSharedFlow()
 
+    /**
+     * Older Android versions don't return status=8 (GATT_CONN_TIMEOUT) when the connection
+     * drops due to a link loss. By checking whether it was the user who requested disconnection
+     * we can improve the status.
+     */
+    var disconnectRequest = false
+
     // Handling connection state updates
 
     // TODO Remove all debug logs
 
     override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
         logger.debug("onConnectionStateChange: status=$status, newState=$newState")
-        _events.tryEmit(ConnectionStateChanged(newState.toConnectionState(status)))
+        // Pixel 4 with Android 12 does returns status 0 when link is lost to a device.
+        // Newer versions (Pixel 7 with Android 16) report status 8 (timeout) in the same case.
+        val betterStatus = if (
+                newState == BluetoothGatt.STATE_DISCONNECTED &&
+                status == BluetoothGatt.GATT_SUCCESS &&
+                !disconnectRequest
+            ) 0x08 /* GATT_CONN_TIMEOUT */ else status
+        _events.tryEmit(ConnectionStateChanged(newState.toConnectionState(betterStatus)))
     }
 
     override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {

client-core/src/main/java/no/nordicsemi/kotlin/ble/client/Peripheral.kt

@@ -95,6 +95,8 @@ abstract class Peripheral<ID: Any, EX: Peripheral.Executor<ID>>(
      *
      * This is not-null when the device is connected or was connected using auto connect,
      * that is when any GATT event for the device, including connection state change, is expected.
+     *
+     * It's set to `null` when the peripheral is closed.
      */
     private var gattEventCollector: Job? = null
 
@@ -200,7 +202,9 @@ abstract class Peripheral<ID: Any, EX: Peripheral.Executor<ID>>(
      * Returns `true` if the peripheral is disconnected of getting disconnected.
      */
     val isDisconnected: Boolean
-        get() = state.value is ConnectionState.Disconnected || state.value is ConnectionState.Disconnecting
+        get() = state.value is ConnectionState.Disconnected ||
+                state.value is ConnectionState.Disconnecting ||
+                state.value is ConnectionState.Closed
 
     /**
      * Waits until the given condition is met.
@@ -266,6 +270,7 @@ abstract class Peripheral<ID: Any, EX: Peripheral.Executor<ID>>(
             impl.close()
             _state.update { ConnectionState.Closed }
         }
+        gattEventCollector = null
     }
 
     /**
@@ -476,36 +481,47 @@ abstract class Peripheral<ID: Any, EX: Peripheral.Executor<ID>>(
      * @throws SecurityException If BLUETOOTH_CONNECT permission is denied.
      */
     suspend fun disconnect() {
-        // Check if the peripheral isn't already disconnected or has a pending disconnection.
-        state.value.let { currentState ->
-            if (currentState is ConnectionState.Disconnected) {
-                // Make sure the AutoConnect also gets cancelled if the peripheral is currently disconnected.
-                close()
+        // Depending on the state...
+        when (state.value) {
+            is ConnectionState.Closed -> {
+                // Do nothing when already closed.
                 return
             }
-            if (currentState is ConnectionState.Disconnecting) {
-                waitUntil { it is ConnectionState.Disconnected }
+            is ConnectionState.Disconnected -> {
+                // Make sure auto-connection is closed.
+                close()
                 return
             }
+            is ConnectionState.Disconnecting -> {
+                // Skip..
+            }
+            is ConnectionState.Connecting -> {
+                // Cancel the connection attempt.
+                logger.trace("Cancelling connection to {}", this)
+                _state.update { ConnectionState.Disconnecting }
+                impl.disconnect()
+            }
+            is ConnectionState.Connected -> {
+                // Disconnect from the peripheral.
+                logger.trace("Disconnecting from {}", this)
+                _state.update { ConnectionState.Disconnecting }
+                impl.disconnect()
+            }
         }
 
-        // Disconnect from the peripheral.
-        logger.trace("Disconnecting from {}", this)
-        _state.update { ConnectionState.Disconnecting }
-        if (impl.disconnect()) {
-            try {
-                waitUntil(500.milliseconds) { it is ConnectionState.Disconnected }
-            } catch (e: TimeoutCancellationException) {
-                logger.warn("Disconnection takes longer than expected, closing")
+        // If the peripheral is disconnecting, wait until it is disconnected and close.
+        try {
+            if (!impl.isClosed) {
+                waitUntil(500.milliseconds) { it.isDisconnected }
             }
-        } else {
-            // Update the state if disconnect() returned false.
-            _state.update {
-                ConnectionState.Disconnected(ConnectionState.Disconnected.Reason.Success)
+        } catch (e: TimeoutCancellationException) {
+            if (!isDisconnected) {
+                logger.warn("Disconnection takes longer than expected, closing")
             }
+        } finally {
+            close()
+            logger.info("Disconnected from {}", this)
         }
-        close()
-        logger.info("Disconnected from {}", this)
     }
 
     // Other