@ledgerhq/device-transport-kit-react-native-hid 0.0.0-develop-20250415001140

package/android/gradlew.bat

@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

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