@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/androidtransporthid/TransportHidModule.kt

@@ -0,0 +1,241 @@
+package com.ledger.androidtransporthid
+
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.hardware.usb.UsbManager
+import android.util.Base64
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.ledger.androidtransporthid.bridge.toWritableMap
+import com.ledger.devicesdk.shared.androidMain.transport.usb.AndroidUsbTransport
+import com.ledger.devicesdk.shared.androidMain.transport.usb.DefaultAndroidUsbTransport
+import com.ledger.devicesdk.shared.androidMain.transport.usb.controller.ACTION_USB_PERMISSION
+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.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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import kotlin.random.Random
+import kotlin.time.Duration.Companion.milliseconds
+
+class TransportHidModule(
+    private val reactContext: ReactApplicationContext,
+    private val coroutineScope: CoroutineScope
+) :
+    ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+    override fun getName(): String = "RCTTransportHIDModule"
+
+    private var usbPermissionReceiver: UsbPermissionReceiver? = null
+    private var usbAttachedReceiverController: UsbAttachedReceiverController? = null
+    private var usbDetachedReceiverController: UsbDetachedReceiverController? = null
+    private var sdkEventDispatcher: SdkEventDispatcher = SdkEventDispatcher()
+    private var eventDispatcherListeningJob: Job
+    private val loggerService: LoggerService =
+        LoggerService { info ->
+            Timber.tag("RNHIDModule " + info.tag).d(info.message)
+            sendEvent(reactContext, BridgeEvents.TransportLog(info))
+        }
+
+    private val transport: AndroidUsbTransport? by lazy {
+        val currentActivity = reactContext.currentActivity
+        val currentApplication = currentActivity?.application
+
+        var transport: AndroidUsbTransport? = null
+        if (currentApplication != null) {
+            val usbManager = reactContext.getSystemService(Context.USB_SERVICE) as UsbManager
+            transport = DefaultAndroidUsbTransport(
+                application = currentApplication,
+                usbManager = usbManager,
+                permissionRequester = { context, manager, device ->
+                    manager.requestPermission(
+                        device,
+                        PendingIntent.getBroadcast(
+                            context,
+                            Random.nextInt(),
+                            Intent(ACTION_USB_PERMISSION).apply {
+                                setPackage(context.packageName)
+                            },
+                            PendingIntent.FLAG_IMMUTABLE,
+                        ),
+                    )
+                },
+                eventDispatcher = sdkEventDispatcher,
+                coroutineDispatcher = Dispatchers.IO,
+                loggerService = loggerService,
+                scanDelay = 500.milliseconds,
+            )
+            usbPermissionReceiver = UsbPermissionReceiver(
+                context = reactContext,
+                androidUsbTransport = transport,
+                usbManager = usbManager,
+                loggerService = loggerService
+            )
+            usbDetachedReceiverController = UsbDetachedReceiverController(
+                context = reactContext,
+                androidUsbTransport = transport,
+            )
+            usbAttachedReceiverController = UsbAttachedReceiverController(
+                context = reactContext,
+                androidUsbTransport = transport,
+            )
+            usbPermissionReceiver!!.start()
+            usbAttachedReceiverController!!.start()
+            usbDetachedReceiverController!!.start()
+        }
+        transport
+    }
+
+    private val discoveryDevices: MutableList<DiscoveryDevice> = mutableListOf()
+    private val connectedDevices: MutableList<InternalConnectedDevice> = mutableListOf()
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+        Timber.plant(Timber.DebugTree())
+        eventDispatcherListeningJob = sdkEventDispatcher.listen().onEach {
+            when (it) {
+                is TransportEvent.DeviceConnectionLost -> {
+                    Timber.tag("RNHIDModule")
+                    Timber.i("TransportEvent.DeviceConnectionLost ${it.id}")
+                    connectedDevices.removeIf { device -> device.id == it.id }
+                    sendEvent(reactContext, BridgeEvents.DeviceDisconnected(it))
+                }
+
+                else -> {}
+            }
+        }.launchIn(scope = coroutineScope)
+    }
+
+    override fun onHostResume() {}
+
+    override fun onHostPause() {}
+
+    override fun onHostDestroy() {
+        usbPermissionReceiver?.stop()
+        usbAttachedReceiverController?.stop()
+        usbDetachedReceiverController?.stop()
+        eventDispatcherListeningJob.cancel()
+        transport?.stopScan()
+    }
+
+    private var discoveryCount = 0
+
+    @ReactMethod
+    fun startScan(promise: Promise) {
+        discoveryCount += 1
+        if (discoveryCount > 1) {
+            promise.resolve(null)
+            return
+        }
+        try {
+            transport!!.startScan().onEach {
+                discoveryDevices.clear()
+                discoveryDevices += it
+                sendEvent(reactContext, BridgeEvents.DiscoveredDevices(it))
+            }.launchIn(scope = coroutineScope)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject(e);
+        }
+    }
+
+    @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);
+        }
+    }
+
+    @ReactMethod()
+    fun connectDevice(uid: String, promise: Promise) {
+        val device = discoveryDevices.firstOrNull { it.uid == uid }
+        if (device == null) {
+            promise.reject(Exception("[TransportHidModule][connectDevice] Device not found"))
+            return
+        }
+
+        coroutineScope.launch {
+            try {
+                val connectionResult = transport!!.connect(device)
+                when (connectionResult) {
+                    is InternalConnectionResult.Connected -> {
+                        connectedDevices.add(connectionResult.device)
+                    }
+
+                    else -> {}
+                }
+                promise.resolve(connectionResult.toWritableMap())
+            } catch (e: Exception) {
+                promise.reject(e)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun disconnectDevice(sessionId: String, promise: Promise) {
+        coroutineScope.launch {
+            try {
+                transport!!.disconnect(sessionId)
+                promise.resolve(null);
+            } catch (e: Exception) {
+                promise.reject(e)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun sendApdu(sessionId: String, apduBase64: String, promise: Promise) {
+        try {
+            val device = connectedDevices.firstOrNull() { it.id == sessionId }
+            if (device == null) {
+                promise.reject(Exception("[TransportHidModule][sendApdu] Device not found"))
+                return
+            }
+            coroutineScope.launch {
+                try {
+                    val apdu: ByteArray = Base64.decode(apduBase64, Base64.DEFAULT)
+                    val res = device.sendApduFn(apdu)
+                    promise.resolve(res.toWritableMap())
+                } catch (e: Exception) {
+                    Timber.i("$e, ${e.cause}")
+                    promise.reject(e)
+                }
+            }
+        } catch (e: Exception) {
+            Timber.i("$e, ${e.cause}")
+            promise.reject(e)
+        }
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Nothing to do in our case, but React Native will issue a warning if this isn't implemented
+    }
+
+    @ReactMethod
+    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/TransportHidPackage.kt

@@ -0,0 +1,25 @@
+package com.ledger.androidtransporthid
+
+import android.view.View
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+
+class TransportHidPackage() : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
+        return mutableListOf(
+            TransportHidModule(
+                reactContext = reactContext,
+                coroutineScope = CoroutineScope(Dispatchers.Default)
+            )
+        )
+    }
+
+    override fun createViewManagers(p0: ReactApplicationContext): MutableList<ViewManager<View, ReactShadowNode<*>>> {
+        return mutableListOf()
+    }
+}

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

@@ -0,0 +1,124 @@
+package com.ledger.androidtransporthid.bridge
+
+import android.util.Base64
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.ledger.devicesdk.shared.api.apdu.SendApduFailureReason
+import com.ledger.devicesdk.shared.api.apdu.SendApduResult
+import com.ledger.devicesdk.shared.api.device.LedgerDevice
+import com.ledger.devicesdk.shared.api.discovery.ConnectivityType
+import com.ledger.devicesdk.shared.api.discovery.DiscoveryDevice
+import com.ledger.devicesdk.shared.internal.connection.InternalConnectionResult
+import com.ledger.devicesdk.shared.internal.service.logger.LogInfo
+import com.ledger.devicesdk.shared.internal.service.logger.LogLevel
+import com.ledger.devicesdk.shared.internal.transport.TransportEvent
+import kotlinx.datetime.Clock
+
+fun LedgerDevice.toWritableMap(): WritableMap =
+    Arguments.createMap().apply {
+        putString("name", name)
+        putString("usbProductIdMask", usbInfo.productIdMask)
+    }
+
+fun DiscoveryDevice.toWritableMap(): WritableMap =
+    Arguments.createMap().apply {
+        putString("uid", uid)
+        putString("name", name)
+        putMap("ledgerDevice", ledgerDevice.toWritableMap())
+    }
+
+
+internal fun LogLevel.toSerializedString(): String =
+    when (this) {
+        LogLevel.DEBUG -> "debug"
+        LogLevel.INFO -> "info"
+        LogLevel.WARNING -> "warning"
+        LogLevel.ERROR -> "error"
+    }
+
+
+internal fun LogInfo.toWritableMap(): WritableMap =
+    Arguments.createMap().apply {
+        putString("level", level.toSerializedString())
+        putString("tag", "[TransportHidModule][${tag}]")
+        putString("message", message)
+        putMap("jsonPayLoad", Arguments.makeNativeMap(jsonPayLoad))
+        putString("timestamp", Clock.System.now().toEpochMilliseconds().toString())
+    }
+
+internal fun InternalConnectionResult.toWritableMap(): WritableMap =
+    when (this) {
+        is InternalConnectionResult.Connected -> {
+            Arguments.createMap().apply {
+                putBoolean("success", true)
+                putString("sessionId", sessionId)
+                putMap("ledgerDevice", device.ledgerDevice.toWritableMap())
+                putString("deviceName", device.name)
+            }
+        }
+        is InternalConnectionResult.ConnectionError -> {
+            Arguments.createMap().apply {
+                putString("error", when (error) {
+                    /**
+                     * Most of these errors are for the BLE lib so it does not really make sense
+                     * to have them here but for the sake of being explicit and not using an "else"
+                     * where a new error type could be added, we list everything.
+                     */
+                    InternalConnectionResult.Failure.BleNotSupported -> "BleNotSupported"
+                    InternalConnectionResult.Failure.ConnectionTimeout -> "ConnectionTimeout"
+                    InternalConnectionResult.Failure.DeviceConnectivityBluetoothDisabled -> "DeviceConnectivityBluetoothDisabled"
+                    InternalConnectionResult.Failure.DeviceConnectivityLocationDisabled -> "DeviceConnectivityLocationDisabled"
+                    InternalConnectionResult.Failure.DeviceNotFound -> "DeviceNotFound"
+                    InternalConnectionResult.Failure.InitializingFailed -> "InitializingFailed"
+                    InternalConnectionResult.Failure.InternalState -> "InternalState"
+                    InternalConnectionResult.Failure.NoDeviceAddress -> "NoDeviceAddress"
+                    InternalConnectionResult.Failure.PairingFailed -> "PairingFailed"
+                    InternalConnectionResult.Failure.PermissionNotGranted -> "PermissionNotGranted"
+                    InternalConnectionResult.Failure.ServiceNotFound -> "ServiceNotFound"
+                    is InternalConnectionResult.Failure.Unknown -> "UnknownError: ${error.msg}"
+                })
+                putBoolean("success", false)
+            }
+        }
+    }
+
+internal fun SendApduResult.toWritableMap(): WritableMap {
+    when(this) {
+        is SendApduResult.Success -> {
+            return Arguments.createMap().apply {
+                putBoolean("success", true)
+                putString("apdu", Base64.encodeToString(apdu, Base64.DEFAULT))
+            }
+        }
+        is SendApduResult.Failure -> {
+            return Arguments.createMap().apply {
+                putBoolean("success", false)
+                putString("error", when (reason) {
+                    SendApduFailureReason.ApduNotWellFormatted -> "ApduNotWellFormatted"
+                    SendApduFailureReason.DeviceBusy -> "DeviceBusy"
+                    SendApduFailureReason.DeviceLocked -> "DeviceLocked"
+                    SendApduFailureReason.DeviceNotFound -> "DeviceNotFound"
+                    SendApduFailureReason.NoResponse -> "NoResponse"
+                    SendApduFailureReason.NoUsbEndpointFound -> "NoUsbEndpointFound"
+                    SendApduFailureReason.DeviceDisconnected -> "DeviceDisconnected"
+                    SendApduFailureReason.Unknown -> "Unknown"
+                })
+            }
+        }
+    }
+}
+
+internal fun TransportEvent.DeviceConnectionLost.toWritableMap(): WritableMap =
+    Arguments.createMap().apply {
+        putString("id", id)
+    }
+
+/* lists */
+
+fun List<DiscoveryDevice>.toWritableArray(): WritableArray =
+    Arguments.createArray().apply {
+        forEach {
+            pushMap(it.toWritableMap())
+        }
+    }

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

@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.androidMain.transport.usb
+
+import com.ledger.devicesdk.shared.internal.transport.Transport
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.UsbPermissionEvent
+import com.ledger.devicesdk.shared.androidMain.transport.usb.model.UsbState
+
+internal interface AndroidUsbTransport: Transport {
+    fun updateUsbState(state: UsbState)
+
+    fun updateUsbEvent(event: UsbPermissionEvent)
+}