@ledgerhq/device-transport-kit-react-native-hid 0.0.0-hid-candidate-4-20250528125313 → 0.0.0-intent-queue-2-20251112131539

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

@@ -17,11 +17,14 @@ import com.ledger.devicesdk.shared.androidMain.transport.usb.controller.ACTION_U
 import com.ledger.devicesdk.shared.androidMain.transport.usb.controller.UsbAttachedReceiverController
 import com.ledger.devicesdk.shared.androidMain.transport.usb.controller.UsbDetachedReceiverController
 import com.ledger.devicesdk.shared.androidMain.transport.usb.controller.UsbPermissionReceiver
+import com.ledger.devicesdk.shared.api.apdu.SendApduFailureReason
+import com.ledger.devicesdk.shared.api.apdu.SendApduResult
 import com.ledger.devicesdk.shared.api.discovery.DiscoveryDevice
 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 +37,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
@@ -133,12 +138,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 +167,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)
+            }
         }
     }
 
@@ -217,7 +246,9 @@ class TransportHidModule(
         try {
             val device = connectedDevices.firstOrNull() { it.id == sessionId }
             if (device == null) {
-                promise.reject(Exception("[TransportHidModule][sendApdu] Device not found"))
+                promise.resolve(
+                    SendApduResult.Failure(SendApduFailureReason.DeviceNotFound).toWritableMap()
+                )
                 return
             }
             coroutineScope.launch {

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

@@ -43,8 +43,11 @@ import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
 
+private val TAG = "DefaultAndroidUsbTransport"
+
 internal class DefaultAndroidUsbTransport(
     private val application: Application,
     private val usbManager: UsbManager,
@@ -67,22 +70,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 +87,7 @@ internal class DefaultAndroidUsbTransport(
     }
 
     override fun stopScan() {
+        loggerService.log(buildSimpleDebugLogInfo(TAG, "[stopScan] called"))
         discoveryJob?.cancel()
         discoveryJob = null
     }
@@ -199,6 +197,7 @@ internal class DefaultAndroidUsbTransport(
                             request = UsbRequest(),
                             loggerService = loggerService
                         )
+                        delay(POST_CONNECTION_DELAY)
 
                         if (!usbConnectionsPendingReconnection.contains(deviceConnection)) {
                             /**
@@ -294,6 +293,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
@@ -312,6 +332,7 @@ internal class DefaultAndroidUsbTransport(
                     request = UsbRequest(),
                     loggerService = loggerService,
                 )
+            delay(POST_CONNECTION_DELAY)
 
             val deviceConnection = DeviceConnection(
                 sessionId = sessionId,
@@ -354,6 +375,8 @@ internal class DefaultAndroidUsbTransport(
     private fun generateSessionId(usbDevice: UsbDevice): String = "usb_${usbDevice.deviceId}"
 }
 
+private val POST_CONNECTION_DELAY = 200.milliseconds
+
 private fun List<LedgerUsbDevice>.toScannedDevices(): List<DiscoveryDevice> =
     this.map {
         it.toScannedDevice()

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

@@ -25,6 +25,9 @@ internal fun ProductId.toLedgerDevice(): LedgerDevice? =
             this.id.isLedgerDeviceProductId(LedgerDevice.Flex) -> {
                 LedgerDevice.Flex
             }
+            this.id.isLedgerDeviceProductId(LedgerDevice.Apex) -> {
+                LedgerDevice.Apex
+            }
             else -> {
                 null
             }

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

@@ -2,6 +2,7 @@ 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 kotlinx.coroutines.CoroutineDispatcher
@@ -25,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()
             }
@@ -75,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 -> {
@@ -134,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 -> {
@@ -240,6 +292,24 @@ internal class DeviceConnectionStateMachine(
         }
     }
 
+    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
     private fun startReconnectionTimeout() {
         // start a timeout and at the end, emit a WaitingForReconnectionTimedOut event
@@ -254,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)
     }
 
@@ -304,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()
 

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/device/LedgerDevice.kt

@@ -5,6 +5,21 @@ public sealed class LedgerDevice(
         public val usbInfo: UsbInfo,
         public val bleInformation: BleInformation? = null,
 ) {
+    public data object Apex :
+            LedgerDevice(
+                name = "Ledger Apex",
+                usbInfo = UsbInfo(LEDGER_USB_VENDOR_ID, "0x80", "0x0008"),
+                bleInformation =
+                    BleInformation(
+                        serviceUuid = "13d63400-2c97-6004-0000-4c6564676572",
+                        notifyCharacteristicUuid =
+                            "13d63400-2c97-6004-0001-4c6564676572",
+                        writeWithResponseCharacteristicUuid =
+                            "13d63400-2c97-6004-0002-4c6564676572",
+                        writeWithoutResponseCharacteristicUuid =
+                            "13d63400-2c97-6004-0003-4c6564676572",
+                    ),
+            )
     public data object Flex :
             LedgerDevice(
                     name = "Ledger Flex",
@@ -77,6 +92,7 @@ public sealed class LedgerDevice(
             add(NanoX)
             add(NanoSPlus)
             add(NanoS)
+            add(Apex)
         }
 
         public fun getAllDevices(): List<LedgerDevice> {

package/android/src/test/kotlin/com/ledger/devicesdk/shared/androidMainInternal/transport/deviceconnection/DeviceConnectionStateMachineTest.kt

@@ -2,6 +2,7 @@ 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.LogInfo
 import com.ledger.devicesdk.shared.internal.service.logger.LoggerService
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -12,6 +13,7 @@ import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 import kotlin.test.Test
 import org.junit.Assert.*
+import kotlin.test.assertIs
 import kotlin.time.Duration.Companion.milliseconds
 
 @OptIn(ExperimentalCoroutinesApi::class)
@@ -88,7 +90,7 @@ class DeviceConnectionStateMachineTest {
             stateMachine.handleApduResult(mockedFailureResult)
 
             // Then
-            assertEquals(sendApduResult, mockedFailureResult)
+            assertEquals(mockedFailureResult, sendApduResult)
             assertTrue(terminated)
             assertNull(error)
         }
@@ -134,14 +136,13 @@ class DeviceConnectionStateMachineTest {
         }
 
     @Test
-    fun `GIVEN the device connection state machine WHEN an APDU with triggersDisconnection is sent THEN the machine moves to WaitingForReconnection and recovers when device reconnects`() =
+    fun `GIVEN the device connection state machine WHEN an APDU with triggersDisconnection is sent and triggers a disconnection THEN the machine moves to WaitingForReconnection and recovers when device reconnects`() =
         runTest {
             var sendApduCalled: ByteArray? = null
             var sendApduResult: SendApduResult? = null
             var terminated = false
             var error: Throwable? = null
 
-            val dispatcher = StandardTestDispatcher(testScheduler)
             val stateMachine = DeviceConnectionStateMachine(
                 sendApduFn = { apdu, _ -> sendApduCalled = apdu },
                 onTerminated = { terminated = true },
@@ -167,6 +168,10 @@ class DeviceConnectionStateMachineTest {
             val mockedSuccessApduResult = SendApduResult.Success(mockedResultApduSuccessA)
             stateMachine.handleApduResult(mockedSuccessApduResult)
 
+            assertNull(sendApduResult)
+            // Simulate a disconnection
+            stateMachine.handleDeviceDisconnected()
+
             // Result should have been returned
             assertEquals(mockedSuccessApduResult, sendApduResult)
 
@@ -203,7 +208,118 @@ class DeviceConnectionStateMachineTest {
         }
 
     @Test
-    fun `GIVEN the device connection state machine WHEN an APDU with triggersDisconnection is sent THEN the machine moves to WaitingForReconnection and the next APDU is queued until reconnection`() =
+    fun `GIVEN the device connection state machine WHEN an APDU with triggersDisconnection is sent and device does not disconnect THEN the machine moves to Connected`() =
+        runTest {
+            var sendApduCalled: ByteArray? = null
+            var sendApduResult: SendApduResult? = null
+            var terminated = false
+            var error: Throwable? = null
+
+            val stateMachine = DeviceConnectionStateMachine(
+                sendApduFn = { apdu, _ -> sendApduCalled = apdu },
+                onTerminated = { terminated = true },
+                isFatalSendApduFailure = { false },
+                reconnectionTimeoutDuration = reconnectionTimeout,
+                onError = { error = it },
+                loggerService = FakeLoggerService(),
+                coroutineDispatcher = StandardTestDispatcher(testScheduler)
+            )
+
+            // Request sending an APDU (with triggersDisconnection = true)
+            stateMachine.requestSendApdu(DeviceConnectionStateMachine.SendApduRequestContent(
+                apdu = mockedRequestApduA,
+                triggersDisconnection = true,
+                resultCallback = { result -> sendApduResult = result },
+                abortTimeoutDuration = Duration.INFINITE
+            ))
+
+            // Send APDU should have been called
+            assertArrayEquals(mockedRequestApduA, sendApduCalled)
+
+            // Simulate a successful response
+            val mockedSuccessApduResult = SendApduResult.Success(mockedResultApduSuccessA)
+            stateMachine.handleApduResult(mockedSuccessApduResult)
+
+            assertNull(sendApduResult)
+
+            // Simulate Response from GetAppAndVersion
+            val mockedSuccessApduResultGetAppAndVersion = SendApduResult.Success(mockedGetAppAndVersionSuccessfulResponse)
+            stateMachine.handleApduResult(mockedSuccessApduResultGetAppAndVersion)
+
+            // Should be in Connected state
+            assertEquals(
+                DeviceConnectionStateMachine.State.Connected,
+                stateMachine.getState()
+            )
+
+            // Response should have been returned
+            assertEquals(mockedSuccessApduResult, sendApduResult)
+        }
+
+    @Test
+    fun `GIVEN the device connection state machine WHEN an APDU with triggersDisconnection is sent and device does not disconnect but is first busy THEN the machine retries and moves to Connected`() =
+        runTest {
+            var sendApduCalled: ByteArray? = null
+            var sendApduResult: SendApduResult? = null
+            var terminated = false
+            var error: Throwable? = null
+
+            val stateMachine = DeviceConnectionStateMachine(
+                sendApduFn = { apdu, _ -> sendApduCalled = apdu },
+                onTerminated = { terminated = true },
+                isFatalSendApduFailure = { false },
+                reconnectionTimeoutDuration = reconnectionTimeout,
+                onError = { error = it },
+                loggerService = FakeLoggerService(),
+                coroutineDispatcher = StandardTestDispatcher(testScheduler)
+            )
+
+            // Request sending an APDU (with triggersDisconnection = true)
+            stateMachine.requestSendApdu(DeviceConnectionStateMachine.SendApduRequestContent(
+                apdu = mockedRequestApduA,
+                triggersDisconnection = true,
+                resultCallback = { result -> sendApduResult = result },
+                abortTimeoutDuration = Duration.INFINITE
+            ))
+
+            // Send APDU should have been called
+            assertArrayEquals(mockedRequestApduA, sendApduCalled)
+
+            // Simulate a successful response
+            val mockedSuccessApduResult = SendApduResult.Success(mockedResultApduSuccessA)
+            stateMachine.handleApduResult(mockedSuccessApduResult)
+
+            assertNull(sendApduResult)
+
+            assertIs<DeviceConnectionStateMachine.State.WaitingForDisconnection>(
+                stateMachine.getState()
+            )
+
+            // Simulate Busy Response from GetAppAndVersion
+            val mockedBusyApduResultGetAppAndVersion = SendApduResult.Success(mockedGetAppAndVersionBusyResponse)
+            stateMachine.handleApduResult(mockedBusyApduResultGetAppAndVersion)
+
+            assertIs<DeviceConnectionStateMachine.State.WaitingForDisconnection>(
+                stateMachine.getState()
+            )
+
+            // Simulate Successful Response from GetAppAndVersion
+            val mockedSuccessApduResultGetAppAndVersion = SendApduResult.Success(mockedGetAppAndVersionSuccessfulResponse)
+            stateMachine.handleApduResult(mockedSuccessApduResultGetAppAndVersion)
+
+            // Should be in Connected state
+            assertEquals(
+                DeviceConnectionStateMachine.State.Connected,
+                stateMachine.getState()
+            )
+
+            // Response should have been returned
+            assertEquals(mockedSuccessApduResult, sendApduResult)
+        }
+
+
+    @Test
+    fun `GIVEN the device connection state machine WHEN an APDU with triggersDisconnection is sent and triggers a disconnection THEN the machine moves to WaitingForReconnection and the next APDU is queued until reconnection`() =
         runTest {
             val sendApduCalled: MutableList<ByteArray> = mutableListOf()
             var terminated = false
@@ -231,10 +347,19 @@ class DeviceConnectionStateMachineTest {
             val mockedSuccessApduResult = SendApduResult.Success(mockedResultApduSuccessA)
             stateMachine.handleApduResult(mockedSuccessApduResult)
 
-            // sendApduFn should have been called once
-            assertEquals(1, sendApduCalled.size)
+            // sendApduFn should have been called twice (for the mockedRequestApduA and an extra call for the getAppAndVersion APDU)
+            assertEquals(2, sendApduCalled.size)
+
+            // Should be in WaitingForDisconnection state
+            assertIs<DeviceConnectionStateMachine.State.WaitingForDisconnection>(
+                stateMachine.getState()
+            )
+
+            // Simulate disconnection
+            stateMachine.handleDeviceDisconnected()
+
+            // Should be in WaitingForReconnection state
 
-            // Should be in waiting state
             assertEquals(
                 DeviceConnectionStateMachine.State.WaitingForReconnection,
                 stateMachine.getState()
@@ -256,7 +381,7 @@ class DeviceConnectionStateMachineTest {
             )
 
             // sendApduFn should not have been called one more time
-            assertEquals(1, sendApduCalled.size)
+            assertEquals(2, sendApduCalled.size)
 
             // Simulate reconnection
             stateMachine.handleDeviceConnected()
@@ -267,9 +392,9 @@ class DeviceConnectionStateMachineTest {
                 stateMachine.getState()::class
             )
 
-            // Send APDU should have been called a second time, and the result should have been returned
-            assertEquals(2, sendApduCalled.size)
-            assertArrayEquals(mockedRequestApduB, sendApduCalled[1])
+            // Send APDU should have been called a 3rd time, and the result should have been returned
+            assertEquals(3, sendApduCalled.size)
+            assertArrayEquals(mockedRequestApduB, sendApduCalled[2])
 
             // Simulate a successful response
             val mockedSuccessApduResultB = SendApduResult.Success(mockedResultApduSuccessB)
@@ -721,9 +846,11 @@ class DeviceConnectionStateMachineTest {
         }
 
         val reconnectionTimeout: Duration = 5.seconds
-        val mockedRequestApduA: ByteArray = byteArrayOf(0x01, 0x02)
-        val mockedRequestApduB: ByteArray = byteArrayOf(0x03, 0x04)
-        val mockedResultApduSuccessA: ByteArray = byteArrayOf(0x05, 0x06, 0x90.toByte(), 0x00)
-        val mockedResultApduSuccessB: ByteArray = byteArrayOf(0x07, 0x08, 0x90.toByte(), 0x00)
+        val mockedRequestApduA: ByteArray = "1234".fromHexStringToBytesOrThrow()
+        val mockedRequestApduB: ByteArray = "5678".fromHexStringToBytesOrThrow()
+        val mockedGetAppAndVersionSuccessfulResponse: ByteArray = "12349000".fromHexStringToBytesOrThrow()
+        val mockedGetAppAndVersionBusyResponse: ByteArray = "12346601".fromHexStringToBytesOrThrow()
+        val mockedResultApduSuccessA: ByteArray = "56789000".fromHexStringToBytesOrThrow()
+        val mockedResultApduSuccessB: ByteArray = "abcd9000".fromHexStringToBytesOrThrow()
     }
 }