@ledgerhq/device-transport-kit-react-native-hid 0.0.0-hid-candidate-3-20250528083456 → 0.0.0-io-revamp-20250618083854

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

@@ -31,7 +31,6 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import kotlin.random.Random
-import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
 
 class TransportHidModule(
@@ -49,7 +48,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 {
@@ -207,13 +206,7 @@ class TransportHidModule(
     }
 
     @ReactMethod
-    fun sendApdu(
-        sessionId: String,
-        apduBase64: String,
-        triggersDisconnection: Boolean,
-        abortTimeout: Int,
-        promise: Promise
-    ) {
+    fun sendApdu(sessionId: String, apduBase64: String, promise: Promise) {
         try {
             val device = connectedDevices.firstOrNull() { it.id == sessionId }
             if (device == null) {
@@ -223,9 +216,7 @@ class TransportHidModule(
             coroutineScope.launch {
                 try {
                     val apdu: ByteArray = Base64.decode(apduBase64, Base64.DEFAULT)
-                    val abortTimeoutDuration = if (abortTimeout <= 0) Duration.INFINITE else abortTimeout.milliseconds
-                    val res =
-                        device.sendApduFn(apdu, triggersDisconnection, abortTimeoutDuration)
+                    val res = device.sendApduFn(apdu)
                     promise.resolve(res.toWritableMap())
                 } catch (e: Exception) {
                     Timber.i("$e, ${e.cause}")

package/android/src/main/kotlin/com/ledger/androidtransporthid/bridge/serialization.kt

@@ -103,8 +103,6 @@ internal fun SendApduResult.toWritableMap(): WritableMap {
                     SendApduFailureReason.NoUsbEndpointFound -> "NoUsbEndpointFound"
                     SendApduFailureReason.DeviceDisconnected -> "DeviceDisconnected"
                     SendApduFailureReason.Unknown -> "Unknown"
-                    SendApduFailureReason.AbortTimeout -> "SendApduTimeout"
-                    SendApduFailureReason.EmptyResponse -> "EmptyResponse"
                 })
             }
         }

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

@@ -97,57 +97,31 @@ internal class DefaultAndroidUsbTransport(
     override fun updateUsbState(state: UsbState) {
         when (state) {
             is UsbState.Detached -> {
-                loggerService.log(
-                    buildSimpleDebugLogInfo(
-                        "AndroidUsbTransport",
-                        "Detached deviceId=${state.ledgerUsbDevice.uid}"
-                    )
-                )
+                loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Detached deviceId=${state.ledgerUsbDevice.uid}"))
                 usbConnections.entries.find {
                     it.value.getApduSender().dependencies.ledgerUsbDevice.uid == state.ledgerUsbDevice.uid
                 }.let { item ->
                     scope.launch {
                         if (item == null) {
-                            loggerService.log(
-                                buildSimpleWarningLogInfo(
-                                    "AndroidUsbTransport",
-                                    "No connection found"
-                                )
-                            )
+                            loggerService.log(buildSimpleWarningLogInfo("AndroidUsbTransport", "No connection found"))
                             return@launch
                         }
                         val (key, deviceConnection) = item
-                        loggerService.log(
-                            buildSimpleInfoLogInfo(
-                                "AndroidUsbTransport",
-                                "Device disconnected (sessionId=${deviceConnection.sessionId})"
-                            )
-                        )
+                        loggerService.log(buildSimpleInfoLogInfo("AndroidUsbTransport", "Device disconnected (sessionId=${deviceConnection.sessionId})"))
+                        deviceConnection.handleDeviceDisconnected()
                         usbConnections.remove(key)
                         usbConnectionsPendingReconnection.add(deviceConnection)
-                        deviceConnection.handleDeviceDisconnected()
-                        (deviceConnection.getApduSender() as AndroidUsbApduSender).release()
                     }
                 }
             }
 
             is UsbState.Attached -> {
-                loggerService.log(
-                    buildSimpleDebugLogInfo(
-                        "AndroidUsbTransport",
-                        "Attached deviceId=${state.ledgerUsbDevice.uid}, pendingReconnections=${usbConnectionsPendingReconnection}"
-                    )
-                )
+                loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Attached deviceId=${state.ledgerUsbDevice.uid}, pendingReconnections=${usbConnectionsPendingReconnection}"))
                 val usbDevice = usbManager.deviceList.values.firstOrNull {
                     it.toLedgerUsbDevice()?.uid == state.ledgerUsbDevice.uid
                 }
                 if (usbDevice == null) {
-                    loggerService.log(
-                        buildSimpleWarningLogInfo(
-                            "AndroidUsbTransport",
-                            "No UsbDevice found"
-                        )
-                    )
+                    loggerService.log(buildSimpleWarningLogInfo("AndroidUsbTransport", "No UsbDevice found"))
                     return
                 }
                 usbConnectionsPendingReconnection.firstOrNull {
@@ -164,29 +138,14 @@ internal class DefaultAndroidUsbTransport(
                             )
                             return@launch
                         }
-                        loggerService.log(
-                            buildSimpleDebugLogInfo(
-                                "AndroidUsbTransport",
-                                "Found matching device connection $deviceConnection"
-                            )
-                        )
+                        loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Found matching device connection $deviceConnection"))
 
                         val permissionResult = checkOrRequestPermission(usbDevice)
                         if (permissionResult is PermissionResult.Denied) {
-                            loggerService.log(
-                                buildSimpleDebugLogInfo(
-                                    "AndroidUsbTransport",
-                                    "Permission denied"
-                                )
-                            )
+                            loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Permission denied"))
                             return@launch
                         }
-                        loggerService.log(
-                            buildSimpleInfoLogInfo(
-                                "AndroidUsbTransport",
-                                "Reconnecting device (sessionId=${deviceConnection.sessionId})"
-                            )
-                        )
+                        loggerService.log(buildSimpleInfoLogInfo("AndroidUsbTransport", "Reconnecting device (sessionId=${deviceConnection.sessionId})"))
                         deviceConnection.handleDeviceConnected(
                             AndroidUsbApduSender(
                                 dependencies = AndroidUsbApduSender.Dependencies(
@@ -236,12 +195,7 @@ internal class DefaultAndroidUsbTransport(
             device = usbDevice,
         )
 
-        loggerService.log(
-            buildSimpleDebugLogInfo(
-                "AndroidUsbTransport",
-                "Waiting for permission result"
-            )
-        )
+        loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Waiting for permission result"))
 
         val result = eventsFlow.first {
             it is UsbPermissionEvent.PermissionGranted ||
@@ -305,10 +259,9 @@ internal class DefaultAndroidUsbTransport(
             val deviceConnection = DeviceConnection(
                 sessionId = sessionId,
                 deviceApduSender = apduSender,
-                isFatalSendApduFailure = { false },
+                isFatalSendApduFailure = { false }, // TODO: refine this
                 reconnectionTimeoutDuration = 5.seconds,
                 onTerminated = {
-                    (it.getApduSender() as AndroidUsbApduSender).release()
                     usbConnections.remove(sessionId)
                     usbConnectionsPendingReconnection.remove(it)
                     eventDispatcher.dispatch(TransportEvent.DeviceConnectionLost(sessionId))
@@ -323,9 +276,7 @@ internal class DefaultAndroidUsbTransport(
                     discoveryDevice.name,
                     discoveryDevice.ledgerDevice,
                     discoveryDevice.connectivityType,
-                    sendApduFn = { apdu: ByteArray, triggersDisconnection: Boolean, abortTimeoutDuration: Duration ->
-                        deviceConnection.requestSendApdu(apdu, triggersDisconnection, abortTimeoutDuration)
-                    }
+                    sendApduFn = { apdu -> deviceConnection.requestSendApdu(apdu) },
                 )
 
             usbConnections[sessionId] = deviceConnection

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

@@ -13,21 +13,21 @@ import android.hardware.usb.UsbInterface
 import android.hardware.usb.UsbManager
 import android.hardware.usb.UsbRequest
 import com.ledger.devicesdk.shared.androidMain.transport.usb.model.LedgerUsbDevice
-import com.ledger.devicesdk.shared.androidMainInternal.transport.USB_MTU
-import com.ledger.devicesdk.shared.androidMainInternal.transport.deviceconnection.DeviceApduSender
 import com.ledger.devicesdk.shared.api.apdu.SendApduFailureReason
 import com.ledger.devicesdk.shared.api.apdu.SendApduResult
+import com.ledger.devicesdk.shared.androidMainInternal.transport.deviceconnection.DeviceApduSender
+import com.ledger.devicesdk.shared.api.utils.toHexadecimalString
+import com.ledger.devicesdk.shared.androidMainInternal.transport.USB_MTU
 import com.ledger.devicesdk.shared.internal.service.logger.LoggerService
 import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleErrorLogInfo
+import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleInfoLogInfo
 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.delay
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import java.nio.ByteBuffer
 import kotlin.random.Random
-import kotlin.time.Duration
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import timber.log.Timber
 
 private const val USB_TIMEOUT = 500
 
@@ -35,75 +35,44 @@ private const val DEFAULT_USB_INTERFACE = 0
 
 internal class AndroidUsbApduSender(
     override val dependencies: Dependencies,
-    usbManager: UsbManager,
+    private val usbManager: UsbManager,
     private val framerService: FramerService,
     private val request: UsbRequest,
     private val ioDispatcher: CoroutineDispatcher,
     private val loggerService: LoggerService,
 ) : DeviceApduSender<AndroidUsbApduSender.Dependencies> {
+
     data class Dependencies(
         val usbDevice: UsbDevice,
         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 =
+    override suspend fun send(apdu: ByteArray): SendApduResult =
         try {
+            val usbDevice = dependencies.usbDevice
             withContext(context = ioDispatcher) {
-
-                val timeoutJob = launch {
-                    delay(abortTimeoutDuration)
-                    throw SendApduTimeoutException
-                }
+                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) }
 
                 transmitApdu(
                     usbConnection = usbConnection,
                     androidToUsbEndpoint = androidToUsbEndpoint,
                     rawApdu = apdu,
                 )
-
                 val apduResponse =
                     receiveApdu(
                         usbConnection = usbConnection,
                         usbToAndroidEndpoint = usbToAndroidEndpoint,
                     )
-                timeoutJob.cancel()
 
-                if (apduResponse.isEmpty()) {
-                    return@withContext SendApduResult.Failure(reason = SendApduFailureReason.EmptyResponse)
-                }
+                usbConnection.releaseInterface(usbInterface)
+                usbConnection.close()
 
-                return@withContext SendApduResult.Success(apdu = apduResponse)
+                SendApduResult.Success(apdu = apduResponse)
             }
-        } catch (e: SendApduTimeoutException) {
-            loggerService.log(
-                buildSimpleErrorLogInfo(
-                    "AndroidUsbApduSender",
-                    "timeout in send: $e"
-                )
-            )
-            SendApduResult.Failure(reason = SendApduFailureReason.AbortTimeout)
         } catch (e: NoSuchElementException) {
-            loggerService.log(
-                buildSimpleErrorLogInfo(
-                    "AndroidUsbApduSender",
-                    "no endpoint found: $e"
-                )
-            )
             SendApduResult.Failure(reason = SendApduFailureReason.NoUsbEndpointFound)
         } catch (e: Exception) {
             loggerService.log(buildSimpleErrorLogInfo("AndroidUsbApduSender", "error in send: $e"))
@@ -115,27 +84,22 @@ internal class AndroidUsbApduSender(
         androidToUsbEndpoint: UsbEndpoint,
         rawApdu: ByteArray,
     ) {
-        framerService.serialize(mtu = USB_MTU, channelId = generateChannelId(), rawApdu = rawApdu)
-            .forEach { apduFrame ->
-                val buffer = apduFrame.toByteArray()
-                usbConnection.bulkTransfer(
-                    androidToUsbEndpoint,
-                    buffer,
-                    apduFrame.size(),
-                    USB_TIMEOUT
-                )
-            }
+        framerService.serialize(mtu = USB_MTU, channelId = generateChannelId(), rawApdu = rawApdu).forEach { apduFrame ->
+            val buffer = apduFrame.toByteArray()
+            Timber.i("APDU sent = ${buffer.toHexadecimalString()}")
+            usbConnection.bulkTransfer(androidToUsbEndpoint, buffer, apduFrame.size(), USB_TIMEOUT)
+        }
     }
 
     private fun receiveApdu(
         usbConnection: UsbDeviceConnection,
         usbToAndroidEndpoint: UsbEndpoint,
-    ): ByteArray {
-        return if (!request.initialize(usbConnection, usbToAndroidEndpoint)) {
+    ): ByteArray =
+        if (!request.initialize(usbConnection, usbToAndroidEndpoint)) {
             request.close()
             byteArrayOf()
         } else {
-            val frames = framerService.createApduFrames(mtu = USB_MTU, isUsbTransport = true) {
+            val frames = framerService.createApduFrames(mtu = USB_MTU, isUsbTransport = true){
                 val buffer = ByteArray(USB_MTU)
                 val responseBuffer = ByteBuffer.allocate(USB_MTU)
 
@@ -143,7 +107,8 @@ internal class AndroidUsbApduSender(
                 if (!queuingResult) {
                     request.close()
                     byteArrayOf()
-                } else {
+                }
+                else{
                     usbConnection.requestWait()
                     responseBuffer.rewind()
                     responseBuffer.get(buffer, 0, responseBuffer.remaining())
@@ -152,7 +117,6 @@ internal class AndroidUsbApduSender(
             }
             framerService.deserialize(mtu = USB_MTU, frames)
         }
-    }
 
     private fun UsbInterface.firstEndpointOrThrow(predicate: (Int) -> Boolean): UsbEndpoint {
         for (endp in 0..this.endpointCount) {
@@ -165,10 +129,5 @@ internal class AndroidUsbApduSender(
         throw NoSuchElementException("No endpoint matching the predicate")
     }
 
-    private fun generateChannelId(): ByteArray =
-        Random.nextInt(0, until = Int.MAX_VALUE).to2BytesArray()
-
-    private data object SendApduTimeoutException : Exception() {
-        private fun readResolve(): Any = SendApduTimeoutException
-    }
+    private fun generateChannelId(): ByteArray = Random.nextInt(0, until = Int.MAX_VALUE).to2BytesArray()
 }

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

@@ -6,9 +6,8 @@
 package com.ledger.devicesdk.shared.androidMainInternal.transport.deviceconnection
 
 import com.ledger.devicesdk.shared.api.apdu.SendApduResult
-import kotlin.time.Duration
 
 internal interface DeviceApduSender<Dependencies> {
-    suspend fun send(apdu: ByteArray, abortTimeoutDuration: Duration): SendApduResult
+    suspend fun send(apdu: ByteArray): SendApduResult
     val dependencies: Dependencies
 }

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

@@ -24,9 +24,9 @@ internal class DeviceConnection<Dependencies>(
 
     init {
         stateMachine = DeviceConnectionStateMachine(
-            sendApduFn = { apdu, abortTimeoutDuration ->
+            sendApduFn = {
                 coroutineScope.launch {
-                    val res = deviceApduSender.send(apdu, abortTimeoutDuration)
+                    val res = deviceApduSender.send(it)
                     handleApduResult(res)
                 }
             },
@@ -66,13 +66,12 @@ internal class DeviceConnection<Dependencies>(
         stateMachine.handleDeviceDisconnected()
     }
 
-    public suspend fun requestSendApdu(apdu: ByteArray, triggersDisconnection: Boolean, abortTimeoutDuration: Duration): SendApduResult =
+    public suspend fun requestSendApdu(apdu: ByteArray): SendApduResult =
         suspendCoroutine { cont ->
             stateMachine.requestSendApdu(
                 DeviceConnectionStateMachine.SendApduRequestContent(
                     apdu = apdu,
-                    triggersDisconnection = apduTriggersDisconnection(apdu) || triggersDisconnection,
-                    abortTimeoutDuration = abortTimeoutDuration,
+                    triggersDisconnection = apduTriggersDisconnection(apdu),
                     resultCallback = cont::resume
                 )
             )

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

@@ -4,6 +4,7 @@ import com.ledger.devicesdk.shared.api.apdu.SendApduFailureReason
 import com.ledger.devicesdk.shared.api.apdu.SendApduResult
 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
@@ -11,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,
@@ -28,7 +29,7 @@ internal class DeviceConnectionStateMachine(
         when (newState) {
             is State.Connected -> {}
             is State.SendingApdu -> {
-                sendApduFn(newState.requestContent.apdu, newState.requestContent.abortTimeoutDuration)
+                sendApduFn(newState.requestContent.apdu)
             }
 
             is State.WaitingForReconnection -> {
@@ -41,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 -> {
@@ -238,6 +234,13 @@ 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 var timeoutJob: Job? = null
@@ -277,7 +280,6 @@ internal class DeviceConnectionStateMachine(
     data class SendApduRequestContent(
         val apdu: ByteArray,
         val triggersDisconnection: Boolean,
-        val abortTimeoutDuration: Duration,
         val resultCallback: (SendApduResult) -> Unit
     )
 

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,
 )