@ledgerhq/device-transport-kit-react-native-hid 0.0.0-develop-20250904001204 → 0.0.0-e2e-speculos-20250904125723

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, abortTimeoutDuration: Duration) -> Unit,
+    private val sendApduFn: (apdu: ByteArray) -> Unit,
     private val onTerminated: () -> Unit,
     private val isFatalSendApduFailure: (SendApduResult.Failure) -> Boolean,
     private val reconnectionTimeoutDuration: Duration,
@@ -26,29 +26,10 @@ 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)
+                sendApduFn(newState.requestContent.apdu)
             }
 
             is State.WaitingForReconnection -> {
@@ -61,16 +42,11 @@ internal class DeviceConnectionStateMachine(
             }
         }
         this.state = newState
-        loggerService.log(buildSimpleDebugLogInfo("DeviceConnectionStateMachine", "-> New state: $newState"))
     }
 
     private fun handleEvent(event: Event) {
-        val logMessage = """
-            -> Event received: $event
-               In state: $state
-        """.trimIndent()
-        loggerService.log(buildSimpleDebugLogInfo("DeviceConnectionStateMachine", logMessage))
-        when (val currentState = state) {
+        val currentState = state
+        when (currentState) {
             is State.Connected -> {
                 when (event) {
                     is Event.SendApduRequested -> {
@@ -95,27 +71,31 @@ internal class DeviceConnectionStateMachine(
                 when (event) {
                     is Event.ApduResultReceived -> {
                         when (event.result) {
-                            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))
+                            is SendApduResult.Failure -> {
+                                if (isFatalSendApduFailure(event.result)) {
+                                    pushState(State.Terminated)
                                 } else {
                                     pushState(State.Connected)
-                                    currentState.requestContent.resultCallback(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
+                                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)
                                 } else {
                                     pushState(State.Connected)
                                 }
-                                currentState.requestContent.resultCallback(event.result)
                             }
                         }
+                        currentState.requestContent.resultCallback(event.result)
                     }
 
                     is Event.CloseConnectionRequested -> {
@@ -150,42 +130,6 @@ 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 -> {
@@ -290,24 +234,13 @@ internal class DeviceConnectionStateMachine(
                 onError(Exception("Unhandled event: $event in state: $currentState"))
             }
         }
-    }
-
-    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)
+        val logMessage = """
+            Received event:
+            In state:       $currentState
+            -> Event:       $event
+            -> New state:   $state
+        """.trimIndent()
+        loggerService.log(buildSimpleDebugLogInfo("DeviceConnectionStateMachine", logMessage))
     }
 
     private var timeoutJob: Job? = null
@@ -324,30 +257,29 @@ internal class DeviceConnectionStateMachine(
         timeoutJob = null
     }
 
-    fun requestSendApdu(requestContent: SendApduRequestContent) {
+    public fun requestSendApdu(requestContent: SendApduRequestContent) {
         handleEvent(Event.SendApduRequested(requestContent))
     }
 
-    fun requestCloseConnection() {
+    public fun requestCloseConnection() {
         handleEvent(Event.CloseConnectionRequested)
     }
 
-    fun handleApduResult(result: SendApduResult) {
+    public fun handleApduResult(result: SendApduResult) {
         handleEvent(Event.ApduResultReceived(result))
     }
 
-    fun handleDeviceConnected() {
+    public fun handleDeviceConnected() {
         handleEvent(Event.DeviceConnected)
     }
 
-    fun handleDeviceDisconnected() {
+    public fun handleDeviceDisconnected() {
         handleEvent(Event.DeviceDisconnected)
     }
 
     data class SendApduRequestContent(
         val apdu: ByteArray,
         val triggersDisconnection: Boolean,
-        val abortTimeoutDuration: Duration,
         val resultCallback: (SendApduResult) -> Unit
     )
 
@@ -374,8 +306,6 @@ 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,8 +44,4 @@ 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/internal/connection/InternalConnectedDevice.kt

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