@ledgerhq/device-transport-kit-react-native-hid 0.0.0-rn-hid-20250221115747 → 0.0.0-rn-hid-sync-onboarding-behavior-20250516092329

package/README.md

@@ -35,7 +35,7 @@ The transport itself is only compatible with Android devices but there is no add
 
 ### Pre-requisites
 
-To use this transport, ensure you have the Device Magement Kit installed in your project.
+To use this transport, ensure you have the Device Management Kit installed in your project.
 
 #### AndroidManifest.xml
 

package/android/build.gradle

@@ -93,7 +93,9 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_stdlib_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
     implementation "org.jetbrains.kotlinx:kotlinx-datetime:$kotlinx_datetime_version"
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlin_coroutines_test_version"
     implementation "com.jakewharton.timber:timber:$timber_version"
     implementation "com.ditchoom:buffer:$buffer_version"
+    testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin_version"
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlin_coroutines_test_version"
+    testImplementation "junit:junit:4.13.2"
 }

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

@@ -31,6 +31,7 @@ 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(
@@ -38,7 +39,7 @@ class TransportHidModule(
     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,7 +48,7 @@ class TransportHidModule(
     private var eventDispatcherListeningJob: Job
     private val loggerService: LoggerService =
         LoggerService { info ->
-            Timber.tag("RNHIDModule " + info.tag).d(info.message)
+            Timber.tag("LDMKTransportHIDModule " + info.tag).d(info.message)
             sendEvent(reactContext, BridgeEvents.TransportLog(info))
         }
 
@@ -206,7 +207,13 @@ 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) {
@@ -216,7 +223,9 @@ class TransportHidModule(
             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 +247,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

@@ -9,13 +9,6 @@ import android.app.Application
 import android.hardware.usb.UsbDevice
 import android.hardware.usb.UsbManager
 import android.hardware.usb.UsbRequest
-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.transport.TransportEvent
-import com.ledger.devicesdk.shared.internal.transport.framer.FramerService
 import com.ledger.devicesdk.shared.androidMain.transport.usb.connection.AndroidUsbApduSender
 import com.ledger.devicesdk.shared.androidMain.transport.usb.model.LedgerUsbDevice
 import com.ledger.devicesdk.shared.androidMain.transport.usb.model.UsbPermissionEvent
@@ -24,11 +17,16 @@ import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.toLedgerUsbDe
 import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.toScannedDevice
 import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.toUsbDevices
 import com.ledger.devicesdk.shared.androidMainInternal.transport.deviceconnection.DeviceConnection
+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.service.logger.buildSimpleErrorLogInfo
 import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleInfoLogInfo
 import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleWarningLogInfo
-import kotlin.time.Duration
+import com.ledger.devicesdk.shared.internal.transport.TransportEvent
+import com.ledger.devicesdk.shared.internal.transport.framer.FramerService
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -41,11 +39,10 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.merge
-import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
-import kotlin.math.log
+import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
 internal class DefaultAndroidUsbTransport(
@@ -55,25 +52,23 @@ internal class DefaultAndroidUsbTransport(
     private val eventDispatcher: SdkEventDispatcher,
     private val loggerService: LoggerService,
     private val scanDelay: Duration,
-    coroutineDispatcher: CoroutineDispatcher,
+    private val coroutineDispatcher: CoroutineDispatcher,
 ) : AndroidUsbTransport {
     private val scope = CoroutineScope(coroutineDispatcher + SupervisorJob())
     private val internalUsbEventFlow: MutableSharedFlow<UsbState> = MutableSharedFlow()
     private val internalUsbPermissionEventFlow: MutableSharedFlow<UsbPermissionEvent> =
         MutableSharedFlow()
 
-    @Suppress("BackingPropertyName")
-    private var _scanStateFlow: MutableStateFlow<List<DiscoveryDevice>> =
-        MutableStateFlow(emptyList())
-    private var discoveryJob: Job? = null
     private val usbConnections: MutableMap<String, DeviceConnection<AndroidUsbApduSender.Dependencies>> =
         mutableMapOf()
     private val usbConnectionsPendingReconnection: MutableSet<DeviceConnection<AndroidUsbApduSender.Dependencies>> =
         mutableSetOf()
 
+    private var discoveryJob: Job? = null
+
     override fun startScan(): Flow<List<DiscoveryDevice>> {
+        val scanStateFlow = MutableStateFlow<List<DiscoveryDevice>>(emptyList())
         discoveryJob?.cancel()
-        _scanStateFlow.value = emptyList()
         discoveryJob =
             scope.launch {
                 while (isActive) {
@@ -86,12 +81,12 @@ internal class DefaultAndroidUsbTransport(
                                 }.isEmpty()
                             }.toUsbDevices()
 
-                    _scanStateFlow.value = devices.toScannedDevices()
+                    scanStateFlow.value = devices.toScannedDevices()
 
                     delay(scanDelay)
                 }
             }
-        return _scanStateFlow
+        return scanStateFlow
     }
 
     override fun stopScan() {
@@ -102,17 +97,33 @@ 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.getApduSender() as AndroidUsbApduSender).clear()
+                        loggerService.log(
+                            buildSimpleInfoLogInfo(
+                                "AndroidUsbTransport",
+                                "Device disconnected (sessionId=${deviceConnection.sessionId})"
+                            )
+                        )
                         deviceConnection.handleDeviceDisconnected()
                         usbConnections.remove(key)
                         usbConnectionsPendingReconnection.add(deviceConnection)
@@ -121,12 +132,22 @@ internal class DefaultAndroidUsbTransport(
             }
 
             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 {
@@ -143,15 +164,30 @@ 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.setApduSender(
+                        loggerService.log(
+                            buildSimpleInfoLogInfo(
+                                "AndroidUsbTransport",
+                                "Reconnecting device (sessionId=${deviceConnection.sessionId})"
+                            )
+                        )
+                        deviceConnection.handleDeviceConnected(
                             AndroidUsbApduSender(
                                 dependencies = AndroidUsbApduSender.Dependencies(
                                     usbDevice = usbDevice,
@@ -164,7 +200,6 @@ internal class DefaultAndroidUsbTransport(
                                 loggerService = loggerService
                             )
                         )
-                        deviceConnection.handleDeviceConnected()
                         usbConnectionsPendingReconnection.remove(deviceConnection)
                         usbConnections[deviceConnection.sessionId] = deviceConnection
                     }
@@ -201,7 +236,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 ||
@@ -268,11 +308,12 @@ internal class DefaultAndroidUsbTransport(
                 isFatalSendApduFailure = { false }, // TODO: refine this
                 reconnectionTimeoutDuration = 5.seconds,
                 onTerminated = {
+//                    (it.getApduSender() as AndroidUsbApduSender).clear()
                     usbConnections.remove(sessionId)
                     usbConnectionsPendingReconnection.remove(it)
                     eventDispatcher.dispatch(TransportEvent.DeviceConnectionLost(sessionId))
                 },
-                coroutineScope = scope,
+                coroutineDispatcher = coroutineDispatcher,
                 loggerService = loggerService,
             )
 
@@ -282,7 +323,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

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

@@ -13,21 +13,24 @@ 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.buildSimpleDebugLogInfo
 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.TimeoutCancellationException
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
 import timber.log.Timber
+import java.nio.ByteBuffer
+import kotlin.random.Random
+import kotlin.time.Duration
 
 private const val USB_TIMEOUT = 500
 
@@ -41,38 +44,60 @@ internal class AndroidUsbApduSender(
     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 =
+    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) }
+                withTimeout(abortTimeoutDuration) {
+                    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(
+                    transmitApdu(
                         usbConnection = usbConnection,
-                        usbToAndroidEndpoint = usbToAndroidEndpoint,
+                        androidToUsbEndpoint = androidToUsbEndpoint,
+                        rawApdu = apdu,
                     )
+                    val apduResponse =
+                        receiveApdu(
+                            usbConnection = usbConnection,
+                            usbToAndroidEndpoint = usbToAndroidEndpoint,
+                        )
 
-                usbConnection.releaseInterface(usbInterface)
-                usbConnection.close()
+                    if (apduResponse.isEmpty()) {
+                        return@withTimeout SendApduResult.Failure(reason = SendApduFailureReason.EmptyResponse)
+                    }
 
-                SendApduResult.Success(apdu = apduResponse)
+                    usbConnection.releaseInterface(usbInterface)
+                    usbConnection.close()
+
+                    return@withTimeout SendApduResult.Success(apdu = apduResponse)
+                }
             }
+        } catch (e: TimeoutCancellationException) {
+            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,11 +109,17 @@ 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()
+                Timber.i("APDU sent = ${buffer.toHexadecimalString()}")
+                usbConnection.bulkTransfer(
+                    androidToUsbEndpoint,
+                    buffer,
+                    apduFrame.size(),
+                    USB_TIMEOUT
+                )
+            }
     }
 
     private fun receiveApdu(
@@ -99,7 +130,7 @@ internal class AndroidUsbApduSender(
             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,11 +138,19 @@ internal class AndroidUsbApduSender(
                 if (!queuingResult) {
                     request.close()
                     byteArrayOf()
-                }
-                else{
+                } else {
                     usbConnection.requestWait()
                     responseBuffer.rewind()
-                    responseBuffer.get(buffer, 0, responseBuffer.remaining())
+                    val remaining = responseBuffer.remaining()
+                    responseBuffer.get(buffer, 0, remaining)
+                    loggerService.log(
+                        buildSimpleDebugLogInfo(
+                            "AndroidUsbApduSender",
+                            "APDU frame received = ${
+                                buffer.copyOfRange(0, remaining).toHexadecimalString()
+                            }"
+                        )
+                    )
                     buffer
                 }
             }
@@ -129,5 +168,6 @@ 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()
 }

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

@@ -42,7 +42,7 @@ internal class UsbPermissionReceiver(
                 context,
                 this,
                 IntentFilter(ACTION_USB_PERMISSION),
-                ACTION_USB_PERMISSION,
+                null,
                 null,
                 ContextCompat.RECEIVER_NOT_EXPORTED,
             )

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

@@ -5,51 +5,42 @@
 
 package com.ledger.devicesdk.shared.androidMain.transport.usb.utils
 
-import com.ledger.devicesdk.shared.api.device.LedgerDevice
 import com.ledger.devicesdk.shared.androidMain.transport.usb.model.ProductId
+import com.ledger.devicesdk.shared.api.device.LedgerDevice
 
 internal fun ProductId.toLedgerDevice(): LedgerDevice? =
-    when {
-        this.id.isLedgerDeviceProductId(LedgerDevice.NanoS)
-        -> {
-            LedgerDevice.NanoS
-        }
-
-        this.id.isLedgerDeviceProductId(LedgerDevice.NanoSPlus)
-        -> {
-            LedgerDevice.NanoSPlus
+        when {
+            this.id.isLedgerDeviceProductId(LedgerDevice.NanoS) -> {
+                LedgerDevice.NanoS
+            }
+            this.id.isLedgerDeviceProductId(LedgerDevice.NanoSPlus) -> {
+                LedgerDevice.NanoSPlus
+            }
+            this.id.isLedgerDeviceProductId(LedgerDevice.NanoX) -> {
+                LedgerDevice.NanoX
+            }
+            this.id.isLedgerDeviceProductId(LedgerDevice.Stax) -> {
+                LedgerDevice.Stax
+            }
+            this.id.isLedgerDeviceProductId(LedgerDevice.Flex) -> {
+                LedgerDevice.Flex
+            }
+            else -> {
+                null
+            }
         }
 
-        this.id.isLedgerDeviceProductId(LedgerDevice.NanoX)
-        -> {
-            LedgerDevice.NanoX
-        }
-
-        this.id.isLedgerDeviceProductId(LedgerDevice.Stax)
-        -> {
-            LedgerDevice.Stax
-        }
-
-        this.id.isLedgerDeviceProductId(LedgerDevice.Flex)
-        -> {
-            LedgerDevice.Flex
-        }
-
-        else -> {
-            null
-        }
-    }
-
 private fun Int.isLedgerDeviceProductId(device: LedgerDevice): Boolean {
     val productId = device.usbInfo.productIdMask.sdkHexToInt()
+    val bootloaderProductId = device.usbInfo.bootloaderProductId.sdkHexToInt()
     val shiftedId = this shr 8
-    return shiftedId == productId
+    return shiftedId == productId || this == bootloaderProductId
 }
 
 @OptIn(ExperimentalStdlibApi::class)
 public fun String.sdkHexToInt(withPrefix: Boolean = true): Int =
-    if (withPrefix) {
-        this.substring(2).hexToInt()
-    } else {
-        this.hexToInt()
-    }
+        if (withPrefix) {
+            this.substring(2).hexToInt()
+        } else {
+            this.hexToInt()
+        }

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

@@ -5,4 +5,4 @@
 
 package com.ledger.devicesdk.shared.androidMainInternal.transport
 
-internal val USB_MTU: Int = 64
+internal const val USB_MTU: Int = 64

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
 }