@ledgerhq/device-transport-kit-react-native-hid 0.0.0-try-to-fix-20250429171448 → 0.0.0-v0-transaction-unfunded-20250918091119

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
@@ -12,7 +12,7 @@ import kotlinx.coroutines.launch
 import kotlin.time.Duration
 
 internal class DeviceConnectionStateMachine(
-    private val sendApduFn: (apdu: ByteArray) -> Unit,
+    private val sendApduFn: (apdu: ByteArray, abortTimeoutDuration: Duration) -> Unit,
     private val onTerminated: () -> Unit,
     private val isFatalSendApduFailure: (SendApduResult.Failure) -> Boolean,
     private val reconnectionTimeoutDuration: Duration,
@@ -26,10 +26,29 @@ 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)
+                sendApduFn(newState.requestContent.apdu, newState.requestContent.abortTimeoutDuration)
+            }
+
+            is State.WaitingForDisconnection -> {
+                // TODO: send getAppAndVersion
+                sendApduFn ("b0010000".fromHexStringToBytesOrThrow(), Duration.INFINITE)
             }
 
             is State.WaitingForReconnection -> {
@@ -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,29 +324,30 @@ 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)
     }
 
     data class SendApduRequestContent(
         val apdu: ByteArray,
         val triggersDisconnection: Boolean,
+        val abortTimeoutDuration: Duration,
         val resultCallback: (SendApduResult) -> Unit
     )
 
@@ -306,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/apdu/SendApduResult.kt

@@ -44,4 +44,8 @@ public sealed class SendApduFailureReason {
     public data object DeviceDisconnected : SendApduFailureReason()
 
     public data object Unknown : SendApduFailureReason()
+
+    public data object AbortTimeout : SendApduFailureReason()
+
+    public data object EmptyResponse : SendApduFailureReason()
 }

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/main/kotlin/com/ledger/devicesdk/shared/internal/connection/InternalConnectedDevice.kt

@@ -9,5 +9,5 @@ internal data class InternalConnectedDevice(
     val name: String,
     val ledgerDevice: LedgerDevice,
     val connectivity: ConnectivityType,
-    val sendApduFn: suspend (ByteArray) -> SendApduResult,
+    val sendApduFn: suspend (apdu: ByteArray, triggersDisconnection: Boolean, abortTimeoutDuration: kotlin.time.Duration) -> SendApduResult,
 )