@ledgerhq/device-transport-kit-react-native-hid 0.0.0-rn-hid-20250221112139 → 0.0.0-rn-ble-logs-20250416162013

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

@@ -0,0 +1,101 @@
+buildscript {
+    ext {
+        // Kotlin and JVM Versions
+        kotlin_version = '2.0.20'
+        coroutines_version = '1.7.3'
+        jvmTargetVersion = "17"
+
+        // Libraries Versions
+        androidCoreKtx_version = '1.13.1'
+        kotlin_stdlib_version = kotlin_version
+        kotlin_coroutines_version = coroutines_version
+        kotlinx_datetime_version = '0.6.1'
+        mockk_version = '1.13.5'
+        kotlin_junit_test_version = kotlin_version
+        kotlin_coroutines_test_version = coroutines_version
+        timber_version = '5.0.1'
+        buffer_version = '1.4.2'
+    }
+    repositories {
+        mavenCentral()
+        google()
+        maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
+    }
+
+    dependencies {
+        // Android Gradle Plugin
+        classpath "com.android.tools.build:gradle:8.3.2"
+        
+        // Kotlin Gradle Plugin
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+allprojects {
+    repositories {
+        mavenCentral()
+        google()
+        maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
+        maven {
+            // React Native Android binaries
+            url "$rootDir/../node_modules/react-native/android"
+        }
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    namespace "com.ledger.androidtransporthid"
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 30)
+        targetSdkVersion safeExtGet("targetSdkVersion", 34)
+        versionCode 1
+        versionName "1.0"
+    }
+
+    compileOptions {
+        // Use JavaVersion enums for compatibility
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = jvmTargetVersion
+    }
+
+    lintOptions {
+        abortOnError false
+        warning 'InvalidPackage'
+    }
+}
+
+repositories {
+    mavenCentral()
+    google()
+    maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
+    maven {
+        // React Native Android binaries
+        url "$rootDir/../node_modules/react-native/android"
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    implementation "androidx.core:core-ktx:$androidCoreKtx_version"
+    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 "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/gradle.properties

@@ -0,0 +1 @@
+android.useAndroidX=true

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-feature android:name="android.hardware.usb.host" android:required="false"/>
+</manifest>

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

@@ -0,0 +1,42 @@
+package com.ledger.androidtransporthid
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.ledger.androidtransporthid.bridge.toWritableArray
+import com.ledger.androidtransporthid.bridge.toWritableMap
+import com.ledger.devicesdk.shared.api.discovery.DiscoveryDevice
+import com.ledger.devicesdk.shared.internal.service.logger.LogInfo
+import com.ledger.devicesdk.shared.internal.transport.TransportEvent
+
+internal sealed class EventParams {
+    data class WMap(val map: WritableMap): EventParams()
+    data class WArray(val arr: WritableArray): EventParams()
+    data object Empty: EventParams()
+}
+
+internal sealed class BridgeEvents(val eventName: String, val params: EventParams) {
+    data class DiscoveredDevices(
+        val devices: List<DiscoveryDevice>,
+    ): BridgeEvents("DiscoveredDevices", EventParams.WArray(devices.toWritableArray()))
+    data class TransportLog(
+        val logInfo: LogInfo,
+    ): BridgeEvents("TransportLog", EventParams.WMap(logInfo.toWritableMap()));
+    data class DeviceDisconnected(
+        val deviceConnectionLost: TransportEvent.DeviceConnectionLost,
+    ): BridgeEvents("DeviceDisconnected", EventParams.WMap(deviceConnectionLost.toWritableMap()))
+}
+
+internal fun sendEvent(reactContext: ReactContext, bridgeEvent: BridgeEvents) {
+    reactContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(
+            bridgeEvent.eventName,
+            when (bridgeEvent.params) {
+                is EventParams.WMap -> bridgeEvent.params.map
+                is EventParams.WArray -> bridgeEvent.params.arr
+                is EventParams.Empty -> null
+            }
+        )
+}

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 = "LDMKTransportHIDModule"
+
+    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("LDMKTransportHIDModule " + 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)
+}