@ledgerhq/device-transport-kit-react-native-hid 0.0.0-rnhid-transport-20250411151739 → 0.0.0-test-ble-20251112111541

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
@@ -31,14 +34,17 @@ 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
 
+private val TAG = "TransportHidModule"
+
 class TransportHidModule(
     private val reactContext: ReactApplicationContext,
     private val coroutineScope: CoroutineScope
 ) :
     ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
-    override fun getName(): String = "RCTTransportHIDModule"
+    override fun getName(): String = "LDMKTransportHIDModule"
 
     private var usbPermissionReceiver: UsbPermissionReceiver? = null
     private var usbAttachedReceiverController: UsbAttachedReceiverController? = null
@@ -47,8 +53,8 @@ class TransportHidModule(
     private var eventDispatcherListeningJob: Job
     private val loggerService: LoggerService =
         LoggerService { info ->
-            Timber.tag("RNHIDModule " + info.tag).d(info.message)
-            sendEvent(reactContext, BridgeEvents.TransportLog(info))
+            Timber.tag("LDMKTransportHIDModule " + info.tag).d(info.message)
+            // sendEvent(reactContext, BridgeEvents.TransportLog(info))
         }
 
     private val transport: AndroidUsbTransport? by lazy {
@@ -132,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
         }
@@ -155,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)
+            }
         }
     }
 
@@ -206,17 +236,27 @@ class TransportHidModule(
     }
 
     @ReactMethod
-    fun sendApdu(sessionId: String, apduBase64: String, promise: Promise) {
+    fun sendApdu(
+        sessionId: String,
+        apduBase64: String,
+        triggersDisconnection: Boolean,
+        abortTimeout: Int,
+        promise: Promise
+    ) {
         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 {
                 try {
                     val apdu: ByteArray = Base64.decode(apduBase64, Base64.DEFAULT)
-                    val res = device.sendApduFn(apdu)
+                    val abortTimeoutDuration = if (abortTimeout <= 0) Duration.INFINITE else abortTimeout.milliseconds
+                    val res =
+                        device.sendApduFn(apdu, triggersDisconnection, abortTimeoutDuration)
                     promise.resolve(res.toWritableMap())
                 } catch (e: Exception) {
                     Timber.i("$e, ${e.cause}")
@@ -238,4 +278,4 @@ class TransportHidModule(
     fun removeListeners(count: Int) {
         // Nothing to do in our case, but React Native will issue a warning if this isn't implemented
     }
-}
+}

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

@@ -103,6 +103,8 @@ 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

@@ -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
     }
@@ -97,31 +95,57 @@ 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})"))
-                        deviceConnection.handleDeviceDisconnected()
+                        loggerService.log(
+                            buildSimpleInfoLogInfo(
+                                "AndroidUsbTransport",
+                                "Device disconnected (sessionId=${deviceConnection.sessionId})"
+                            )
+                        )
                         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 {
@@ -138,27 +162,54 @@ 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})"))
-                        deviceConnection.handleDeviceConnected(
-                            AndroidUsbApduSender(
-                                dependencies = AndroidUsbApduSender.Dependencies(
-                                    usbDevice = usbDevice,
-                                    ledgerUsbDevice = state.ledgerUsbDevice,
-                                ),
-                                usbManager = usbManager,
-                                ioDispatcher = Dispatchers.IO,
-                                framerService = FramerService(loggerService),
-                                request = UsbRequest(),
-                                loggerService = loggerService
+                        loggerService.log(
+                            buildSimpleInfoLogInfo(
+                                "AndroidUsbTransport",
+                                "Reconnecting device (sessionId=${deviceConnection.sessionId})"
                             )
                         )
+
+                        val apduSender = AndroidUsbApduSender(
+                            dependencies = AndroidUsbApduSender.Dependencies(
+                                usbDevice = usbDevice,
+                                ledgerUsbDevice = state.ledgerUsbDevice,
+                            ),
+                            usbManager = usbManager,
+                            ioDispatcher = Dispatchers.IO,
+                            framerService = FramerService(loggerService),
+                            request = UsbRequest(),
+                            loggerService = loggerService
+                        )
+                        delay(POST_CONNECTION_DELAY)
+
+                        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
                     }
@@ -195,7 +246,12 @@ 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 ||
@@ -237,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
@@ -255,13 +332,15 @@ internal class DefaultAndroidUsbTransport(
                     request = UsbRequest(),
                     loggerService = loggerService,
                 )
+            delay(POST_CONNECTION_DELAY)
 
             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))
@@ -276,7 +355,9 @@ internal class DefaultAndroidUsbTransport(
                     discoveryDevice.name,
                     discoveryDevice.ledgerDevice,
                     discoveryDevice.connectivityType,
-                    sendApduFn = { apdu -> deviceConnection.requestSendApdu(apdu) },
+                    sendApduFn = { apdu: ByteArray, triggersDisconnection: Boolean, abortTimeoutDuration: Duration ->
+                        deviceConnection.requestSendApdu(apdu, triggersDisconnection, abortTimeoutDuration)
+                    }
                 )
 
             usbConnections[sessionId] = deviceConnection
@@ -286,12 +367,16 @@ 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}"
 }
 
+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/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 java.nio.ByteBuffer
-import kotlin.random.Random
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import timber.log.Timber
+import java.nio.ByteBuffer
+import kotlin.random.Random
+import kotlin.time.Duration
 
 private const val USB_TIMEOUT = 500
 
@@ -35,44 +35,75 @@ 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,
     private val loggerService: LoggerService,
 ) : DeviceApduSender<AndroidUsbApduSender.Dependencies> {
-
     data class Dependencies(
         val usbDevice: UsbDevice,
         val ledgerUsbDevice: LedgerUsbDevice,
     )
 
-    override suspend fun send(apdu: ByteArray): SendApduResult =
+    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)
+                    throw SendApduTimeoutException
+                }
 
                 transmitApdu(
                     usbConnection = usbConnection,
                     androidToUsbEndpoint = androidToUsbEndpoint,
                     rawApdu = apdu,
                 )
+
                 val apduResponse =
                     receiveApdu(
                         usbConnection = usbConnection,
                         usbToAndroidEndpoint = usbToAndroidEndpoint,
                     )
+                timeoutJob.cancel()
 
-                usbConnection.releaseInterface(usbInterface)
-                usbConnection.close()
+                if (apduResponse.isEmpty()) {
+                    return@withContext SendApduResult.Failure(reason = SendApduFailureReason.EmptyResponse)
+                }
 
-                SendApduResult.Success(apdu = apduResponse)
+                return@withContext 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"))
@@ -84,22 +115,27 @@ internal class AndroidUsbApduSender(
         androidToUsbEndpoint: UsbEndpoint,
         rawApdu: ByteArray,
     ) {
-        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)
-        }
+        framerService.serialize(mtu = USB_MTU, channelId = generateChannelId(), rawApdu = rawApdu)
+            .forEach { apduFrame ->
+                val buffer = apduFrame.toByteArray()
+                usbConnection.bulkTransfer(
+                    androidToUsbEndpoint,
+                    buffer,
+                    apduFrame.size(),
+                    USB_TIMEOUT
+                )
+            }
     }
 
     private fun receiveApdu(
         usbConnection: UsbDeviceConnection,
         usbToAndroidEndpoint: UsbEndpoint,
-    ): ByteArray =
-        if (!request.initialize(usbConnection, usbToAndroidEndpoint)) {
+    ): ByteArray {
+        return 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)
 
@@ -107,8 +143,7 @@ internal class AndroidUsbApduSender(
                 if (!queuingResult) {
                     request.close()
                     byteArrayOf()
-                }
-                else{
+                } else {
                     usbConnection.requestWait()
                     responseBuffer.rewind()
                     responseBuffer.get(buffer, 0, responseBuffer.remaining())
@@ -117,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) {
@@ -129,5 +165,10 @@ internal class AndroidUsbApduSender(
         throw NoSuchElementException("No endpoint matching the predicate")
     }
 
-    private fun generateChannelId(): ByteArray = Random.nextInt(0, until = Int.MAX_VALUE).to2BytesArray()
+    private fun generateChannelId(): ByteArray =
+        Random.nextInt(0, until = Int.MAX_VALUE).to2BytesArray()
+
+    private data object SendApduTimeoutException : Exception() {
+        private fun readResolve(): Any = SendApduTimeoutException
+    }
 }

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/DeviceApduSender.kt

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