@ledgerhq/device-transport-kit-react-native-hid 0.0.0-rn-ble-pairing-removed-while-reconnecting-20250807094338 → 0.0.0-rn-hid-issues-20251022142715

package/android/src/main/kotlin/com/ledger/androidtransporthid/TransportHidModule.kt

@@ -22,6 +22,7 @@ import com.ledger.devicesdk.shared.internal.connection.InternalConnectedDevice
 import com.ledger.devicesdk.shared.internal.connection.InternalConnectionResult
 import com.ledger.devicesdk.shared.internal.event.SdkEventDispatcher
 import com.ledger.devicesdk.shared.internal.service.logger.LoggerService
+import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleDebugLogInfo
 import com.ledger.devicesdk.shared.internal.transport.TransportEvent
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -34,6 +35,8 @@ import kotlin.random.Random
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
 
+private val TAG = "TransportHidModule"
+
 class TransportHidModule(
     private val reactContext: ReactApplicationContext,
     private val coroutineScope: CoroutineScope
@@ -49,7 +52,7 @@ class TransportHidModule(
     private val loggerService: LoggerService =
         LoggerService { info ->
             Timber.tag("LDMKTransportHIDModule " + info.tag).d(info.message)
-            sendEvent(reactContext, BridgeEvents.TransportLog(info))
+            // sendEvent(reactContext, BridgeEvents.TransportLog(info))
         }
 
     private val transport: AndroidUsbTransport? by lazy {
@@ -133,12 +136,18 @@ class TransportHidModule(
         transport?.stopScan()
     }
 
-    private var discoveryCount = 0
+    private var activeScanCount = 0
 
     @ReactMethod
     fun startScan(promise: Promise) {
-        discoveryCount += 1
-        if (discoveryCount > 1) {
+        loggerService.log(
+            buildSimpleDebugLogInfo(TAG, "[startScan] called")
+        )
+        activeScanCount += 1
+        if (activeScanCount > 1) {
+            loggerService.log(
+                buildSimpleDebugLogInfo(TAG, "[startScan] already scanning")
+            )
             promise.resolve(null)
             return
         }
@@ -156,16 +165,34 @@ class TransportHidModule(
 
     @ReactMethod
     fun stopScan(promise: Promise) {
-        discoveryCount -= 1
-        if (discoveryCount > 0) {
-            promise.resolve(null)
-            return
-        }
-        try {
-            transport!!.stopScan()
-            promise.resolve(null)
-        } catch (e: Exception) {
-            promise.reject(e);
+        loggerService.log(
+            buildSimpleDebugLogInfo(TAG, "[stopScan] called, activeScanCount=$activeScanCount")
+        )
+
+        when(activeScanCount) {
+            0 -> {
+                loggerService.log(buildSimpleDebugLogInfo(TAG, "[stopScan] no active scan"))
+                promise.resolve(null)
+            }
+            1 -> {
+                try {
+                    transport!!.stopScan()
+                    promise.resolve(null)
+                } catch (e: Exception) {
+                    promise.reject(e);
+                }
+                activeScanCount = 0
+            }
+            else -> {
+                loggerService.log(
+                    buildSimpleDebugLogInfo(
+                        TAG,
+                        "[stopScan] still scanning because there are active listeners"
+                    )
+                )
+                activeScanCount -= 1
+                promise.resolve(null)
+            }
         }
     }
 

package/android/src/main/kotlin/com/ledger/devicesdk/shared/androidMain/transport/usb/DefaultAndroidUsbTransport.kt

@@ -45,6 +45,8 @@ import kotlinx.coroutines.launch
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
+private val TAG = "DefaultAndroidUsbTransport"
+
 internal class DefaultAndroidUsbTransport(
     private val application: Application,
     private val usbManager: UsbManager,
@@ -67,22 +69,16 @@ internal class DefaultAndroidUsbTransport(
     private var discoveryJob: Job? = null
 
     override fun startScan(): Flow<List<DiscoveryDevice>> {
+        loggerService.log(buildSimpleDebugLogInfo(TAG, "[startScan] called"))
         val scanStateFlow = MutableStateFlow<List<DiscoveryDevice>>(emptyList())
         discoveryJob?.cancel()
         discoveryJob =
             scope.launch {
                 while (isActive) {
-                    val usbDevices = usbManager.deviceList.values.toList()
-                    val devices =
-                        usbDevices
-                            .filter { device ->
-                                usbConnections.filter {
-                                    device == it.value.getApduSender().dependencies.usbDevice
-                                }.isEmpty()
-                            }.toUsbDevices()
-
-                    scanStateFlow.value = devices.toScannedDevices()
-
+                    loggerService.log(buildSimpleDebugLogInfo(TAG, "[startScan] isActive loop"))
+                    val usbDevices = usbManager.deviceList.values.toList().toUsbDevices()
+                    scanStateFlow.value = usbDevices.toScannedDevices()
+                    loggerService.log(buildSimpleDebugLogInfo(TAG, "[startScan] scannedDevices=${scanStateFlow.value}"))
                     delay(scanDelay)
                 }
             }
@@ -90,6 +86,7 @@ internal class DefaultAndroidUsbTransport(
     }
 
     override fun stopScan() {
+        loggerService.log(buildSimpleDebugLogInfo(TAG, "[stopScan] called"))
         discoveryJob?.cancel()
         discoveryJob = null
     }
@@ -123,9 +120,10 @@ internal class DefaultAndroidUsbTransport(
                                 "Device disconnected (sessionId=${deviceConnection.sessionId})"
                             )
                         )
-                        deviceConnection.handleDeviceDisconnected()
                         usbConnections.remove(key)
                         usbConnectionsPendingReconnection.add(deviceConnection)
+                        deviceConnection.handleDeviceDisconnected()
+                        (deviceConnection.getApduSender() as AndroidUsbApduSender).release()
                     }
                 }
             }
@@ -186,19 +184,30 @@ internal class DefaultAndroidUsbTransport(
                                 "Reconnecting device (sessionId=${deviceConnection.sessionId})"
                             )
                         )
-                        deviceConnection.handleDeviceConnected(
-                            AndroidUsbApduSender(
-                                dependencies = AndroidUsbApduSender.Dependencies(
-                                    usbDevice = usbDevice,
-                                    ledgerUsbDevice = state.ledgerUsbDevice,
-                                ),
-                                usbManager = usbManager,
-                                ioDispatcher = Dispatchers.IO,
-                                framerService = FramerService(loggerService),
-                                request = UsbRequest(),
-                                loggerService = loggerService
-                            )
+
+                        val apduSender = AndroidUsbApduSender(
+                            dependencies = AndroidUsbApduSender.Dependencies(
+                                usbDevice = usbDevice,
+                                ledgerUsbDevice = state.ledgerUsbDevice,
+                            ),
+                            usbManager = usbManager,
+                            ioDispatcher = Dispatchers.IO,
+                            framerService = FramerService(loggerService),
+                            request = UsbRequest(),
+                            loggerService = loggerService
                         )
+
+                        if (!usbConnectionsPendingReconnection.contains(deviceConnection)) {
+                            /**
+                             * We check this because maybe by the time we get here,
+                             * the reconnection has timed out and the session has been terminated.
+                             * Easy to reproduce for instance if the permission request requires
+                             * a user interaction.
+                             */
+                            apduSender.release()
+                            return@launch
+                        }
+                        deviceConnection.handleDeviceConnected(apduSender)
                         usbConnectionsPendingReconnection.remove(deviceConnection)
                         usbConnections[deviceConnection.sessionId] = deviceConnection
                     }
@@ -282,6 +291,27 @@ internal class DefaultAndroidUsbTransport(
         return if (usbDevice == null || ledgerUsbDevice == null) {
             InternalConnectionResult.ConnectionError(error = InternalConnectionResult.Failure.DeviceNotFound)
         } else {
+
+            val existingConnection = usbConnections.firstNotNullOfOrNull {
+                if (it.value.getApduSender().dependencies.usbDevice == usbDevice) it.value
+                else if (it.key == generateSessionId(usbDevice)) it.value
+                else null
+            }
+
+            if (existingConnection != null) {
+                val connectedDevice =
+                    InternalConnectedDevice(
+                        existingConnection.sessionId,
+                        discoveryDevice.name,
+                        discoveryDevice.ledgerDevice,
+                        discoveryDevice.connectivityType,
+                        sendApduFn = { apdu: ByteArray, triggersDisconnection: Boolean, abortTimeoutDuration: Duration ->
+                            existingConnection.requestSendApdu(apdu, triggersDisconnection, abortTimeoutDuration)
+                        }
+                    )
+                return InternalConnectionResult.Connected(device = connectedDevice, sessionId = existingConnection.sessionId)
+            }
+
             val permissionResult = checkOrRequestPermission(usbDevice)
             if (permissionResult is PermissionResult.Denied) {
                 return permissionResult.connectionError
@@ -304,9 +334,10 @@ internal class DefaultAndroidUsbTransport(
             val deviceConnection = DeviceConnection(
                 sessionId = sessionId,
                 deviceApduSender = apduSender,
-                isFatalSendApduFailure = { false }, // TODO: refine this
+                isFatalSendApduFailure = { false },
                 reconnectionTimeoutDuration = 5.seconds,
                 onTerminated = {
+                    (it.getApduSender() as AndroidUsbApduSender).release()
                     usbConnections.remove(sessionId)
                     usbConnectionsPendingReconnection.remove(it)
                     eventDispatcher.dispatch(TransportEvent.DeviceConnectionLost(sessionId))
@@ -333,7 +364,9 @@ internal class DefaultAndroidUsbTransport(
     }
 
     override suspend fun disconnect(deviceId: String) {
+        // The DeviceConnection is either in usbConnections or usbConnectionsPendingReconnection
         usbConnections[deviceId]?.requestCloseConnection()
+        usbConnectionsPendingReconnection.find { it.sessionId == deviceId }?.requestCloseConnection()
     }
 
     private fun generateSessionId(usbDevice: UsbDevice): String = "usb_${usbDevice.deviceId}"

package/android/src/main/kotlin/com/ledger/devicesdk/shared/androidMain/transport/usb/connection/AndroidUsbApduSender.kt

@@ -22,7 +22,6 @@ import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleErrorLogIn
 import com.ledger.devicesdk.shared.internal.transport.framer.FramerService
 import com.ledger.devicesdk.shared.internal.transport.framer.to2BytesArray
 import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -36,7 +35,7 @@ private const val DEFAULT_USB_INTERFACE = 0
 
 internal class AndroidUsbApduSender(
     override val dependencies: Dependencies,
-    private val usbManager: UsbManager,
+    usbManager: UsbManager,
     private val framerService: FramerService,
     private val request: UsbRequest,
     private val ioDispatcher: CoroutineDispatcher,
@@ -47,49 +46,48 @@ internal class AndroidUsbApduSender(
         val ledgerUsbDevice: LedgerUsbDevice,
     )
 
+    private val usbDevice = dependencies.usbDevice
+    private val usbInterface = usbDevice.getInterface(DEFAULT_USB_INTERFACE)
+    private val androidToUsbEndpoint =
+        usbInterface.firstEndpointOrThrow { it == UsbConstants.USB_DIR_OUT }
+    private val usbToAndroidEndpoint =
+        usbInterface.firstEndpointOrThrow { it == UsbConstants.USB_DIR_IN }
+    private val usbConnection = usbManager.openDevice(usbDevice)
+        .apply { claimInterface(usbInterface, true) }
+
+
+    fun release() {
+        usbConnection.releaseInterface(usbInterface)
+        usbConnection.close()
+    }
+
     override suspend fun send(apdu: ByteArray, abortTimeoutDuration: Duration): SendApduResult =
         try {
-            val usbDevice = dependencies.usbDevice
             withContext(context = ioDispatcher) {
-                val usbInterface = usbDevice.getInterface(DEFAULT_USB_INTERFACE)
-                val androidToUsbEndpoint =
-                    usbInterface.firstEndpointOrThrow { it == UsbConstants.USB_DIR_OUT }
-                val usbToAndroidEndpoint =
-                    usbInterface.firstEndpointOrThrow { it == UsbConstants.USB_DIR_IN }
-                val usbConnection = usbManager.openDevice(usbDevice)
-                    .apply { claimInterface(usbInterface, true) }
 
                 val timeoutJob = launch {
                     delay(abortTimeoutDuration)
-                    usbConnection.releaseInterface(usbInterface)
-                    usbConnection.close()
                     throw SendApduTimeoutException
                 }
 
-                try {
+                transmitApdu(
+                    usbConnection = usbConnection,
+                    androidToUsbEndpoint = androidToUsbEndpoint,
+                    rawApdu = apdu,
+                )
 
-                    transmitApdu(
+                val apduResponse =
+                    receiveApdu(
                         usbConnection = usbConnection,
-                        androidToUsbEndpoint = androidToUsbEndpoint,
-                        rawApdu = apdu,
+                        usbToAndroidEndpoint = usbToAndroidEndpoint,
                     )
+                timeoutJob.cancel()
 
-                    val apduResponse =
-                        receiveApdu(
-                            usbConnection = usbConnection,
-                            usbToAndroidEndpoint = usbToAndroidEndpoint,
-                        )
-                    timeoutJob.cancel()
-
-                    if (apduResponse.isEmpty()) {
-                        return@withContext SendApduResult.Failure(reason = SendApduFailureReason.EmptyResponse)
-                    }
-
-                    return@withContext SendApduResult.Success(apdu = apduResponse)
-                } finally {
-                    usbConnection.releaseInterface(usbInterface)
-                    usbConnection.close()
+                if (apduResponse.isEmpty()) {
+                    return@withContext SendApduResult.Failure(reason = SendApduFailureReason.EmptyResponse)
                 }
+
+                return@withContext SendApduResult.Success(apdu = apduResponse)
             }
         } catch (e: SendApduTimeoutException) {
             loggerService.log(
@@ -132,8 +130,8 @@ internal class AndroidUsbApduSender(
     private fun receiveApdu(
         usbConnection: UsbDeviceConnection,
         usbToAndroidEndpoint: UsbEndpoint,
-    ): ByteArray =
-        if (!request.initialize(usbConnection, usbToAndroidEndpoint)) {
+    ): ByteArray {
+        return if (!request.initialize(usbConnection, usbToAndroidEndpoint)) {
             request.close()
             byteArrayOf()
         } else {
@@ -154,6 +152,7 @@ internal class AndroidUsbApduSender(
             }
             framerService.deserialize(mtu = USB_MTU, frames)
         }
+    }
 
     private fun UsbInterface.firstEndpointOrThrow(predicate: (Int) -> Boolean): UsbEndpoint {
         for (endp in 0..this.endpointCount) {
@@ -169,7 +168,7 @@ internal class AndroidUsbApduSender(
     private fun generateChannelId(): ByteArray =
         Random.nextInt(0, until = Int.MAX_VALUE).to2BytesArray()
 
-    private data object SendApduTimeoutException: Exception() {
+    private data object SendApduTimeoutException : Exception() {
         private fun readResolve(): Any = SendApduTimeoutException
     }
 }

package/android/src/main/kotlin/com/ledger/devicesdk/shared/androidMainInternal/transport/deviceconnection/DeviceConnectionStateMachine.kt

@@ -2,9 +2,9 @@ package com.ledger.devicesdk.shared.androidMainInternal.transport.deviceconnecti
 
 import com.ledger.devicesdk.shared.api.apdu.SendApduFailureReason
 import com.ledger.devicesdk.shared.api.apdu.SendApduResult
+import com.ledger.devicesdk.shared.api.utils.fromHexStringToBytesOrThrow
 import com.ledger.devicesdk.shared.internal.service.logger.LoggerService
 import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleDebugLogInfo
-import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleInfoLogInfo
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
@@ -26,12 +26,31 @@ internal class DeviceConnectionStateMachine(
     fun getState() = state
 
     private fun pushState(newState: State) {
+
+        val currentState = state
+
+        /* STATE EXIT EFFECTS */
+        if (newState != currentState) {
+            when (currentState) {
+                is State.WaitingForDisconnection -> {
+                    currentState.requestContent.resultCallback(currentState.result)
+                }
+                else -> {}
+            }
+        }
+
+        /* STATE ENTRY EFFECTS */
         when (newState) {
             is State.Connected -> {}
             is State.SendingApdu -> {
                 sendApduFn(newState.requestContent.apdu, newState.requestContent.abortTimeoutDuration)
             }
 
+            is State.WaitingForDisconnection -> {
+                // TODO: send getAppAndVersion
+                sendApduFn ("b0010000".fromHexStringToBytesOrThrow(), Duration.INFINITE)
+            }
+
             is State.WaitingForReconnection -> {
                 startReconnectionTimeout()
             }
@@ -42,11 +61,16 @@ internal class DeviceConnectionStateMachine(
             }
         }
         this.state = newState
+        loggerService.log(buildSimpleDebugLogInfo("DeviceConnectionStateMachine", "-> New state: $newState"))
     }
 
     private fun handleEvent(event: Event) {
-        val currentState = state
-        when (currentState) {
+        val logMessage = """
+            -> Event received: $event
+               In state: $state
+        """.trimIndent()
+        loggerService.log(buildSimpleDebugLogInfo("DeviceConnectionStateMachine", logMessage))
+        when (val currentState = state) {
             is State.Connected -> {
                 when (event) {
                     is Event.SendApduRequested -> {
@@ -71,31 +95,27 @@ internal class DeviceConnectionStateMachine(
                 when (event) {
                     is Event.ApduResultReceived -> {
                         when (event.result) {
-                            is SendApduResult.Failure -> {
-                                if (isFatalSendApduFailure(event.result)) {
-                                    pushState(State.Terminated)
+                            is SendApduResult.Success -> {
+                                // check if last 2 bytes of APDU are [0x90,OxO0]
+                                val apdu = event.result.apdu
+
+
+                                if (isSuccessApdu(apdu) && currentState.requestContent.triggersDisconnection) {
+                                    pushState(State.WaitingForDisconnection(requestContent = currentState.requestContent, result = event.result))
                                 } else {
                                     pushState(State.Connected)
+                                    currentState.requestContent.resultCallback(event.result)
                                 }
                             }
-
-                            is SendApduResult.Success -> {
-                                // check if last 2 bytes of APDU are [0x90,OxO0]
-                                val apdu = event.result.apdu
-                                val apduSize = apdu.size
-                                val isSuccessApdu =
-                                    apdu.size >= 2 &&
-                                            apdu[apduSize - 2] == 0x90.toByte() &&
-                                            apdu[apduSize - 1] == 0x00.toByte()
-
-                                if (isSuccessApdu && currentState.requestContent.triggersDisconnection) {
-                                    pushState(State.WaitingForReconnection)
+                            is SendApduResult.Failure -> {
+                                if (isFatalSendApduFailure(event.result)) {
+                                    pushState(State.Terminated)
                                 } else {
                                     pushState(State.Connected)
                                 }
+                                currentState.requestContent.resultCallback(event.result)
                             }
                         }
-                        currentState.requestContent.resultCallback(event.result)
                     }
 
                     is Event.CloseConnectionRequested -> {
@@ -130,6 +150,42 @@ internal class DeviceConnectionStateMachine(
                 }
             }
 
+            is State.WaitingForDisconnection -> {
+                when (event) {
+                    is Event.ApduResultReceived -> {
+                        when (event.result) {
+                            is SendApduResult.Success -> {
+                                val apdu = event.result.apdu
+                                if (isSendApduBusyError(apdu)) {
+                                    pushState(state) // Loop on same state, will trigger a new send of GetAppAndVersion (entry effect)
+                                } else {
+                                    pushState(State.Connected)
+                                }
+                            }
+                            is SendApduResult.Failure -> {
+                                pushState(State.WaitingForReconnection)
+                            }
+                        }
+                    }
+                    is Event.SendApduRequested -> {
+                        event.requestContent.resultCallback(
+                            SendApduResult.Failure(
+                                SendApduFailureReason.DeviceBusy
+                            )
+                        )
+                    }
+                    is Event.DeviceDisconnected -> {
+                        pushState(State.WaitingForReconnection)
+                    }
+                    is Event.CloseConnectionRequested -> {
+                        pushState(State.Terminated)
+                    }
+                    else -> {
+                        onError(Exception("Unhandled event: $event in state: $currentState"))
+                    }
+                }
+            }
+
             is State.WaitingForReconnection -> {
                 when (event) {
                     is Event.DeviceConnected -> {
@@ -234,13 +290,24 @@ internal class DeviceConnectionStateMachine(
                 onError(Exception("Unhandled event: $event in state: $currentState"))
             }
         }
-        val logMessage = """
-            Received event:
-            In state:       $currentState
-            -> Event:       $event
-            -> New state:   $state
-        """.trimIndent()
-        loggerService.log(buildSimpleDebugLogInfo("DeviceConnectionStateMachine", logMessage))
+    }
+
+    private fun  isSuccessApdu(apdu: ByteArray): Boolean {
+        val apduSize = apdu.size
+        return apduSize >= 2 &&
+                apdu[apduSize - 2] == 0x90.toByte() &&
+                apdu[apduSize - 1] == 0x00.toByte()
+    }
+
+    private fun isSendApduBusyError(apdu: ByteArray): Boolean {
+        val apduSize = apdu.size
+        return apduSize >= 2 &&
+                apdu[apduSize - 2] == 0x66.toByte() &&
+                apdu[apduSize - 1] == 0x01.toByte()
+    }
+
+    private fun sendGetAppAndVersionApdu() {
+        sendApduFn("b0010000".fromHexStringToBytesOrThrow(), Duration.INFINITE)
     }
 
     private var timeoutJob: Job? = null
@@ -257,23 +324,23 @@ internal class DeviceConnectionStateMachine(
         timeoutJob = null
     }
 
-    public fun requestSendApdu(requestContent: SendApduRequestContent) {
+    fun requestSendApdu(requestContent: SendApduRequestContent) {
         handleEvent(Event.SendApduRequested(requestContent))
     }
 
-    public fun requestCloseConnection() {
+    fun requestCloseConnection() {
         handleEvent(Event.CloseConnectionRequested)
     }
 
-    public fun handleApduResult(result: SendApduResult) {
+    fun handleApduResult(result: SendApduResult) {
         handleEvent(Event.ApduResultReceived(result))
     }
 
-    public fun handleDeviceConnected() {
+    fun handleDeviceConnected() {
         handleEvent(Event.DeviceConnected)
     }
 
-    public fun handleDeviceDisconnected() {
+    fun handleDeviceDisconnected() {
         handleEvent(Event.DeviceDisconnected)
     }
 
@@ -307,6 +374,8 @@ internal class DeviceConnectionStateMachine(
 
         data object WaitingForReconnection : State()
 
+        data class WaitingForDisconnection(val requestContent: SendApduRequestContent, val result: SendApduResult): State()
+
         data class WaitingForReconnectionWithQueuedApdu(val requestContent: SendApduRequestContent) :
             State()