@ledgerhq/device-transport-kit-react-native-hid 0.0.0-rn-hid-20250221112139 → 0.0.0-rnhid-transport-20250411151739

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

@@ -0,0 +1,298 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb
+
+import android.app.Application
+import android.hardware.usb.UsbDevice
+import android.hardware.usb.UsbManager
+import android.hardware.usb.UsbRequest
+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
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.UsbState
+import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.toLedgerUsbDevice
+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.buildSimpleInfoLogInfo
+import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleWarningLogInfo
+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
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.shareIn
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
+internal class DefaultAndroidUsbTransport(
+    private val application: Application,
+    private val usbManager: UsbManager,
+    private val permissionRequester: UsbPermissionRequester,
+    private val eventDispatcher: SdkEventDispatcher,
+    private val loggerService: LoggerService,
+    private val scanDelay: Duration,
+    private val coroutineDispatcher: CoroutineDispatcher,
+) : AndroidUsbTransport {
+    private val scope = CoroutineScope(coroutineDispatcher + SupervisorJob())
+    private val internalUsbEventFlow: MutableSharedFlow<UsbState> = MutableSharedFlow()
+    private val internalUsbPermissionEventFlow: MutableSharedFlow<UsbPermissionEvent> =
+        MutableSharedFlow()
+
+    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()
+        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()
+
+                    delay(scanDelay)
+                }
+            }
+        return scanStateFlow
+    }
+
+    override fun stopScan() {
+        discoveryJob?.cancel()
+        discoveryJob = null
+    }
+
+    override fun updateUsbState(state: UsbState) {
+        when (state) {
+            is UsbState.Detached -> {
+                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"))
+                            return@launch
+                        }
+                        val (key, deviceConnection) = item
+                        loggerService.log(buildSimpleInfoLogInfo("AndroidUsbTransport", "Device disconnected (sessionId=${deviceConnection.sessionId})"))
+                        deviceConnection.handleDeviceDisconnected()
+                        usbConnections.remove(key)
+                        usbConnectionsPendingReconnection.add(deviceConnection)
+                    }
+                }
+            }
+
+            is UsbState.Attached -> {
+                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"))
+                    return
+                }
+                usbConnectionsPendingReconnection.firstOrNull {
+                    it.getApduSender()
+                        .dependencies.ledgerUsbDevice.ledgerDevice == state.ledgerUsbDevice.ledgerDevice // we just find a similar device model since there is no way to uniquely identify a device between 2 connections
+                }.let { deviceConnection ->
+                    scope.launch {
+                        if (deviceConnection == null) {
+                            loggerService.log(
+                                buildSimpleWarningLogInfo(
+                                    "AndroidUsbTransport",
+                                    "No pending connection found"
+                                )
+                            )
+                            return@launch
+                        }
+                        loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Found matching device connection $deviceConnection"))
+
+                        val permissionResult = checkOrRequestPermission(usbDevice)
+                        if (permissionResult is PermissionResult.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
+                            )
+                        )
+                        usbConnectionsPendingReconnection.remove(deviceConnection)
+                        usbConnections[deviceConnection.sessionId] = deviceConnection
+                    }
+                }
+            }
+        }
+    }
+
+    override fun updateUsbEvent(event: UsbPermissionEvent) {
+        scope.launch {
+            internalUsbPermissionEventFlow.emit(event)
+        }
+    }
+
+    sealed class PermissionResult {
+        data object Granted : PermissionResult()
+        data class Denied(val connectionError: InternalConnectionResult.ConnectionError) :
+            PermissionResult()
+    }
+
+    private suspend fun checkOrRequestPermission(usbDevice: UsbDevice): PermissionResult {
+        if (usbManager.hasPermission(usbDevice)) {
+            return PermissionResult.Granted
+        }
+
+        val eventsFlow = merge(
+            internalUsbPermissionEventFlow,
+            internalUsbEventFlow,
+        ).shareIn(scope = scope, started = SharingStarted.Eagerly)
+
+        permissionRequester.requestPermission(
+            context = application,
+            manager = usbManager,
+            device = usbDevice,
+        )
+
+        loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Waiting for permission result"))
+
+        val result = eventsFlow.first {
+            it is UsbPermissionEvent.PermissionGranted ||
+                    it is UsbPermissionEvent.PermissionDenied ||
+                    it is UsbState.Detached
+        }
+
+        loggerService.log(buildSimpleDebugLogInfo("AndroidUsbTransport", "Got permission result"))
+
+        return when (result) {
+            is UsbPermissionEvent -> {
+                return when (result) {
+                    is UsbPermissionEvent.PermissionDenied -> {
+                        PermissionResult.Denied(
+                            InternalConnectionResult.ConnectionError(
+                                error = InternalConnectionResult.Failure.PermissionNotGranted,
+                            )
+                        )
+                    }
+
+                    is UsbPermissionEvent.PermissionGranted -> {
+                        PermissionResult.Granted
+                    }
+                }
+            }
+
+            else -> {
+                PermissionResult.Denied(InternalConnectionResult.ConnectionError(error = InternalConnectionResult.Failure.DeviceNotFound))
+            }
+        }
+    }
+
+    override suspend fun connect(discoveryDevice: DiscoveryDevice): InternalConnectionResult {
+        val usbDevice: UsbDevice? =
+            usbManager.deviceList.values.firstOrNull { it.deviceId == discoveryDevice.uid.toInt() }
+
+        val ledgerUsbDevice = usbDevice?.toLedgerUsbDevice()
+
+        return if (usbDevice == null || ledgerUsbDevice == null) {
+            InternalConnectionResult.ConnectionError(error = InternalConnectionResult.Failure.DeviceNotFound)
+        } else {
+            val permissionResult = checkOrRequestPermission(usbDevice)
+            if (permissionResult is PermissionResult.Denied) {
+                return permissionResult.connectionError
+            }
+
+            val sessionId = generateSessionId(usbDevice)
+            val apduSender =
+                AndroidUsbApduSender(
+                    dependencies = AndroidUsbApduSender.Dependencies(
+                        usbDevice = usbDevice,
+                        ledgerUsbDevice = ledgerUsbDevice,
+                    ),
+                    usbManager = usbManager,
+                    ioDispatcher = Dispatchers.IO,
+                    framerService = FramerService(loggerService),
+                    request = UsbRequest(),
+                    loggerService = loggerService,
+                )
+
+            val deviceConnection = DeviceConnection(
+                sessionId = sessionId,
+                deviceApduSender = apduSender,
+                isFatalSendApduFailure = { false }, // TODO: refine this
+                reconnectionTimeoutDuration = 5.seconds,
+                onTerminated = {
+                    usbConnections.remove(sessionId)
+                    usbConnectionsPendingReconnection.remove(it)
+                    eventDispatcher.dispatch(TransportEvent.DeviceConnectionLost(sessionId))
+                },
+                coroutineDispatcher = coroutineDispatcher,
+                loggerService = loggerService,
+            )
+
+            val connectedDevice =
+                InternalConnectedDevice(
+                    sessionId,
+                    discoveryDevice.name,
+                    discoveryDevice.ledgerDevice,
+                    discoveryDevice.connectivityType,
+                    sendApduFn = { apdu -> deviceConnection.requestSendApdu(apdu) },
+                )
+
+            usbConnections[sessionId] = deviceConnection
+
+            InternalConnectionResult.Connected(device = connectedDevice, sessionId = sessionId)
+        }
+    }
+
+    override suspend fun disconnect(deviceId: String) {
+        usbConnections[deviceId]?.requestCloseConnection()
+    }
+
+    private fun generateSessionId(usbDevice: UsbDevice): String = "usb_${usbDevice.deviceId}"
+}
+
+private fun List<LedgerUsbDevice>.toScannedDevices(): List<DiscoveryDevice> =
+    this.map {
+        it.toScannedDevice()
+    }

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

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb
+
+import android.content.Context
+import android.hardware.usb.UsbManager
+import android.hardware.usb.UsbDevice as AndroidUsbDevice
+
+internal fun interface UsbPermissionRequester {
+    fun requestPermission(
+        context: Context,
+        manager: UsbManager,
+        device: AndroidUsbDevice,
+    )
+}

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

@@ -0,0 +1,133 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb.connection
+
+import android.hardware.usb.UsbConstants
+import android.hardware.usb.UsbDevice
+import android.hardware.usb.UsbDeviceConnection
+import android.hardware.usb.UsbEndpoint
+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.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.withContext
+import timber.log.Timber
+
+private const val USB_TIMEOUT = 500
+
+private const val DEFAULT_USB_INTERFACE = 0
+
+internal class AndroidUsbApduSender(
+    override val dependencies: Dependencies,
+    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,
+    )
+
+    override suspend fun send(apdu: ByteArray): 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) }
+
+                transmitApdu(
+                    usbConnection = usbConnection,
+                    androidToUsbEndpoint = androidToUsbEndpoint,
+                    rawApdu = apdu,
+                )
+                val apduResponse =
+                    receiveApdu(
+                        usbConnection = usbConnection,
+                        usbToAndroidEndpoint = usbToAndroidEndpoint,
+                    )
+
+                usbConnection.releaseInterface(usbInterface)
+                usbConnection.close()
+
+                SendApduResult.Success(apdu = apduResponse)
+            }
+        } catch (e: NoSuchElementException) {
+            SendApduResult.Failure(reason = SendApduFailureReason.NoUsbEndpointFound)
+        } catch (e: Exception) {
+            loggerService.log(buildSimpleErrorLogInfo("AndroidUsbApduSender", "error in send: $e"))
+            SendApduResult.Failure(reason = SendApduFailureReason.Unknown)
+        }
+
+    private fun transmitApdu(
+        usbConnection: UsbDeviceConnection,
+        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)
+        }
+    }
+
+    private fun receiveApdu(
+        usbConnection: UsbDeviceConnection,
+        usbToAndroidEndpoint: UsbEndpoint,
+    ): ByteArray =
+        if (!request.initialize(usbConnection, usbToAndroidEndpoint)) {
+            request.close()
+            byteArrayOf()
+        } else {
+            val frames = framerService.createApduFrames(mtu = USB_MTU, isUsbTransport = true){
+                val buffer = ByteArray(USB_MTU)
+                val responseBuffer = ByteBuffer.allocate(USB_MTU)
+
+                val queuingResult = request.queue(responseBuffer)
+                if (!queuingResult) {
+                    request.close()
+                    byteArrayOf()
+                }
+                else{
+                    usbConnection.requestWait()
+                    responseBuffer.rewind()
+                    responseBuffer.get(buffer, 0, responseBuffer.remaining())
+                    buffer
+                }
+            }
+            framerService.deserialize(mtu = USB_MTU, frames)
+        }
+
+    private fun UsbInterface.firstEndpointOrThrow(predicate: (Int) -> Boolean): UsbEndpoint {
+        for (endp in 0..this.endpointCount) {
+            val endpoint = this.getEndpoint(endp)
+            val endpointDirection = endpoint.direction
+            if (predicate(endpointDirection)) {
+                return endpoint
+            }
+        }
+        throw NoSuchElementException("No endpoint matching the predicate")
+    }
+
+    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/UsbAttachedReceiverController.kt

@@ -0,0 +1,59 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb.controller
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.hardware.usb.UsbDevice
+import android.hardware.usb.UsbManager
+import androidx.core.content.ContextCompat
+import com.ledger.devicesdk.shared.internal.utils.Controller
+import com.ledger.devicesdk.shared.androidMain.transport.usb.AndroidUsbTransport
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.LedgerUsbDevice
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.UsbState
+import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.getAndroidUsbDevice
+import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.toLedgerUsbDevice
+import timber.log.Timber
+
+internal class UsbAttachedReceiverController(
+    private val context: Context,
+    private val androidUsbTransport: AndroidUsbTransport,
+) : BroadcastReceiver(),
+    Controller {
+    override fun start() {
+        Timber.i("start UsbAttachedReceiverController")
+        ContextCompat.registerReceiver(
+            context,
+            this,
+            IntentFilter(UsbManager.ACTION_USB_DEVICE_ATTACHED),
+            ContextCompat.RECEIVER_NOT_EXPORTED,
+        )
+    }
+
+    override fun stop() {
+        Timber.i("stop UsbAttachedReceiverController")
+        context.unregisterReceiver(this)
+    }
+
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
+        Timber.i("UsbAttachedReceiverController:onReceive")
+        val androidUsbDevice: UsbDevice = intent.getAndroidUsbDevice()
+        val ledgerUsbDevice: LedgerUsbDevice? = androidUsbDevice.toLedgerUsbDevice()
+        if (ledgerUsbDevice != null) {
+            androidUsbTransport.updateUsbState(
+                state = UsbState.Attached(
+                    ledgerUsbDevice = ledgerUsbDevice,
+                )
+            )
+        }
+
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb.controller
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.hardware.usb.UsbDevice
+import android.hardware.usb.UsbManager
+import androidx.core.content.ContextCompat
+import com.ledger.devicesdk.shared.androidMain.transport.usb.AndroidUsbTransport
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.LedgerUsbDevice
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.UsbState
+import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.getAndroidUsbDevice
+import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.toLedgerUsbDevice
+import com.ledger.devicesdk.shared.internal.utils.Controller
+import timber.log.Timber
+
+internal class UsbDetachedReceiverController(
+    private val context: Context,
+    private val androidUsbTransport: AndroidUsbTransport,
+) : BroadcastReceiver(),
+    Controller {
+    override fun start() {
+        Timber.i("start UsbDetachedReceiverController")
+        ContextCompat.registerReceiver(
+            context,
+            this,
+            IntentFilter(UsbManager.ACTION_USB_DEVICE_DETACHED),
+            ContextCompat.RECEIVER_NOT_EXPORTED,
+        )
+    }
+
+    override fun stop() {
+        Timber.i("stop UsbDetachedReceiverController")
+        context.unregisterReceiver(this)
+    }
+
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
+        Timber.i("UsbDetachedReceiverController:onReceive")
+        val usbDevice: UsbDevice = intent.getAndroidUsbDevice()
+        val ledgerUsbDevice: LedgerUsbDevice? = usbDevice.toLedgerUsbDevice()
+        if (ledgerUsbDevice != null) {
+            androidUsbTransport.updateUsbState(
+                state = UsbState.Detached(
+                    ledgerUsbDevice = ledgerUsbDevice,
+                )
+            )
+        }
+    }
+}

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

@@ -0,0 +1,92 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb.controller
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.hardware.usb.UsbManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import com.ledger.devicesdk.shared.androidMain.transport.usb.AndroidUsbTransport
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.UsbPermissionEvent
+import com.ledger.devicesdk.shared.androidMain.transport.usb.utils.toLedgerUsbDevice
+import com.ledger.devicesdk.shared.internal.service.logger.LoggerService
+import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleDebugLogInfo
+import com.ledger.devicesdk.shared.internal.utils.Controller
+import timber.log.Timber
+
+internal const val ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"
+
+internal class UsbPermissionReceiver(
+    private val context: Context,
+    private val androidUsbTransport: AndroidUsbTransport,
+    private val usbManager: UsbManager,
+    private val loggerService: LoggerService,
+) : BroadcastReceiver(),
+    Controller {
+    override fun start() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            ContextCompat.registerReceiver(
+                context,
+                this,
+                IntentFilter(ACTION_USB_PERMISSION),
+                ContextCompat.RECEIVER_NOT_EXPORTED,
+            )
+        } else {
+            ContextCompat.registerReceiver(
+                context,
+                this,
+                IntentFilter(ACTION_USB_PERMISSION),
+                null,
+                null,
+                ContextCompat.RECEIVER_NOT_EXPORTED,
+            )
+        }
+    }
+
+    override fun stop() {
+        context.unregisterReceiver(this)
+    }
+
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
+        Timber.i("UsbPermissionReceiver:onReceive")
+        if (ACTION_USB_PERMISSION == intent.action) {
+            synchronized(this) {
+                val androidUsbDevice = usbManager.deviceList.values.firstOrNull {
+                    usbManager.hasPermission(it) && it.toLedgerUsbDevice() != null
+                }
+                val ledgerUsbDevice = androidUsbDevice?.toLedgerUsbDevice()
+                if (ledgerUsbDevice != null) {
+                    loggerService.log(
+                        buildSimpleDebugLogInfo(
+                            "UsbPermissionReceiver:onReceive",
+                            "permission granted"
+                        )
+                    )
+                    androidUsbTransport.updateUsbEvent(
+                        UsbPermissionEvent.PermissionGranted(ledgerUsbDevice = ledgerUsbDevice)
+                    )
+                } else {
+                    loggerService.log(
+                        buildSimpleDebugLogInfo(
+                            "UsbPermissionReceiver:onReceive",
+                            "permission denied"
+                        )
+                    )
+                    androidUsbTransport.updateUsbEvent(
+                        UsbPermissionEvent.PermissionDenied
+                    )
+                }
+
+            }
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb.model
+
+import com.ledger.devicesdk.shared.api.device.LedgerDevice
+
+internal class LedgerUsbDevice(
+    val uid: String,
+    val name: String,
+    val vendorId: VendorId,
+    val productId: ProductId,
+    val ledgerDevice: LedgerDevice,
+)

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

@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb.model
+
+@JvmInline
+public value class ProductId(
+    public val id: Int,
+)