@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/internal/coroutine/SDKScopeHandler.kt

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.coroutine
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+
+private lateinit var scope: SdkCloseableScope
+
+internal fun getSdkScope(): SdkCloseableScope {
+    if (!::scope.isInitialized) {
+        scope = SdkCloseableScope(context = Dispatchers.Default + SupervisorJob())
+    }
+    return scope
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/event/SdkEventDispatcher.kt

@@ -0,0 +1,19 @@
+package com.ledger.devicesdk.shared.internal.event
+
+import com.ledger.devicesdk.shared.internal.coroutine.sdkScope
+import com.ledger.devicesdk.shared.internal.transport.TransportEvent
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.launch
+
+internal class SdkEventDispatcher  {
+    private val eventFlow: MutableSharedFlow<TransportEvent> = MutableSharedFlow()
+
+    fun listen(): Flow<TransportEvent> = eventFlow
+
+    fun dispatch(event: TransportEvent) {
+        sdkScope.launch {
+            eventFlow.emit(value = event)
+        }
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/service/logger/DisableLoggerService.kt

@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.service.logger
+
+internal class DisableLoggerService : LoggerService {
+    override fun log(info: LogInfo) {
+        //DO NOTING
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/service/logger/LogInfo.kt

@@ -0,0 +1,52 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.service.logger
+
+internal data class LogInfo(
+    val level: LogLevel,
+    val tag: String,
+    val message: String,
+    val jsonPayLoad: Map<String, String>,
+)
+
+internal fun buildSimpleDebugLogInfo(
+    tag: String,
+    message: String,
+): LogInfo =
+    LogInfo(level = LogLevel.DEBUG, tag = tag, message = message, emptyMap())
+
+internal fun buildSimpleErrorLogInfo(
+    tag: String,
+    message: String,
+): LogInfo =
+    LogInfo(level = LogLevel.ERROR, tag = tag, message = message, emptyMap())
+
+internal fun buildSimpleWarningLogInfo(
+    tag: String,
+    message: String,
+): LogInfo =
+    LogInfo(level = LogLevel.WARNING, tag = tag, message = message, emptyMap())
+
+internal fun buildSimpleInfoLogInfo(
+    tag: String,
+    message: String,
+): LogInfo =
+    LogInfo(level = LogLevel.INFO, tag = tag, message = message, emptyMap())
+
+private fun buildSimpleLogInfo(
+    level: LogLevel,
+    tag: String,
+    message: String,
+): LogInfo =
+    LogInfo(level = level, tag = tag, message = message, emptyMap())
+
+internal fun buildComplexLogInfo(
+    level: LogLevel,
+    tag: String,
+    message: String,
+    jsonPayLoad: Map<String, String>,
+): LogInfo =
+    LogInfo(level = level, tag = tag, message = message, jsonPayLoad = jsonPayLoad)

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/service/logger/LogLevel.kt

@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.service.logger
+
+internal enum class LogLevel {
+    DEBUG,
+    INFO,
+    WARNING,
+    ERROR
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/service/logger/LoggerService.kt

@@ -0,0 +1,10 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.service.logger
+
+internal fun interface LoggerService {
+    fun log(info: LogInfo)
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/Transport.kt

@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport
+
+import com.ledger.devicesdk.shared.api.discovery.DiscoveryDevice
+import com.ledger.devicesdk.shared.internal.connection.InternalConnectionResult
+import kotlinx.coroutines.flow.Flow
+
+internal interface Transport {
+    fun startScan(): Flow<List<DiscoveryDevice>>
+
+    fun stopScan()
+
+    // TODO change by Flow<ConnectedDeviceState> or add observe device connection for listening device state flow through?
+    suspend fun connect(discoveryDevice: DiscoveryDevice): InternalConnectionResult
+
+    suspend fun disconnect(deviceId: String)
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/TransportEvent.kt

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport
+
+internal sealed class TransportEvent {
+    data class DeviceConnectionLost(
+        val id: String,
+    ) : TransportEvent()
+}
+
+internal sealed class BluetoothTransportEvent : TransportEvent() {
+    data object BluetoothDisable : BluetoothTransportEvent()
+
+    data object BluetoothEnable : BluetoothTransportEvent()
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/framer/FramerService.kt

@@ -0,0 +1,210 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.framer
+
+import com.ledger.devicesdk.shared.api.apdu.ApduParser
+import com.ledger.devicesdk.shared.api.utils.toHexadecimalString
+import com.ledger.devicesdk.shared.internal.service.logger.LoggerService
+import com.ledger.devicesdk.shared.internal.service.logger.buildSimpleInfoLogInfo
+import com.ledger.devicesdk.shared.internal.transport.framer.model.ApduFrame
+import com.ledger.devicesdk.shared.internal.transport.framer.model.ApduFramerHeader
+import com.ledger.devicesdk.shared.internal.transport.framer.model.HEADER_SIZE
+import com.ledger.devicesdk.shared.internal.transport.framer.model.MAXIMUM_HEADER_SIZE
+import com.ledger.devicesdk.shared.internal.transport.utils.extractApduSize
+import com.ledger.devicesdk.shared.internal.transport.utils.extractFrameHeader
+
+private const val TAG = "FramerService"
+
+internal class FramerService(
+    private val loggerService: LoggerService
+) {
+    fun serialize(
+        mtu: Int,
+        channelId: ByteArray?,
+        rawApdu: ByteArray,
+    ): List<ApduFrame> {
+        val header = ApduFramerHeader(channelId = channelId, frameId = byteArrayOf(0x00, 0x00))
+        val apduSize = rawApdu.size.to2BytesArray()
+        val frames =
+            if (rawApdu.isShortApdu(mtu = mtu)) {
+                val paddingSize = mtu - header.size() - apduSize.size - rawApdu.size
+                val finalApdu = rawApdu + ByteArray(paddingSize)
+                listOf(
+                    ApduFrame(
+                        header = header,
+                        apduSize = apduSize,
+                        apdu = finalApdu,
+                    ),
+                )
+            } else {
+                var isBuildingFrames = true
+                var counter = 0
+                var startIndex = 0
+                var endIndex = mtu - header.size() - apduSize.size
+                buildList {
+                    while (isBuildingFrames) {
+                        if (counter == 0) {
+//                            loggerService.log(
+//                                info = buildSimpleInfoLogInfo(
+//                                    tag = TAG,
+//                                    message = "-- IF -- startIndex = $startIndex / endIndex = $endIndex",
+//                                ),
+//                            )
+                            add(
+                                ApduFrame(
+                                    header = header,
+                                    apduSize = apduSize,
+                                    apdu = rawApdu.slice(startIndex..<endIndex).toByteArray(),
+                                ),
+                            )
+                        } else {
+                            startIndex = endIndex
+                            endIndex = (mtu - header.size()) + startIndex
+//                            loggerService.log(
+//                                info = buildSimpleInfoLogInfo(
+//                                    tag = TAG,
+//                                    message = "-- ELSE -- startIndex = $startIndex / endIndex = $endIndex",
+//                                ),
+//                            )
+                            if (endIndex <= rawApdu.size) {
+                                add(
+                                    ApduFrame(
+                                        ApduFramerHeader(
+                                            channelId = channelId,
+                                            frameId = counter.to2BytesArray(),
+                                        ),
+                                        apduSize = null,
+                                        apdu = rawApdu.slice(startIndex..<endIndex).toByteArray(),
+                                    ),
+                                )
+                            } else {
+                                val apduExtracted = rawApdu.slice(startIndex..<rawApdu.size).toByteArray()
+                                val paddingSize = mtu - header.size() - apduExtracted.size
+                                val finalApdu =
+                                    apduExtracted + ByteArray(paddingSize)
+                                add(
+                                    ApduFrame(
+                                        header =
+                                        ApduFramerHeader(
+                                            channelId = channelId,
+                                            frameId = counter.to2BytesArray(),
+                                        ),
+                                        apduSize = null,
+                                        apdu = finalApdu,
+                                    ),
+                                )
+                                isBuildingFrames = false
+                            }
+                        }
+                        counter += 1
+                    }
+                }
+            }
+//        loggerService.log(
+//            info = buildSimpleInfoLogInfo(
+//                tag = TAG,
+//                message = "APDU SERIALIZATION RESULT : \n${frames.toHexadecimalString()}",
+//            ),
+//        )
+        return frames
+    }
+
+    fun deserialize(
+        mtu: Int,
+        frames: List<ApduFrame>,
+    ): ByteArray {
+//        loggerService.log(
+//            info = buildSimpleInfoLogInfo(
+//                tag = TAG,
+//                message = "APDU DESERIALIZATION RESULT : \n",
+//            ),
+//        )
+        var payload = byteArrayOf()
+        return if (frames.isEmpty()) {
+            payload
+        } else {
+            var rawApdu: ByteArray
+            var offset = mtu - MAXIMUM_HEADER_SIZE
+            var apduSize = frames.first().apduSize!!.toIntOn2Bytes()
+//            loggerService.log(
+//                info = buildSimpleInfoLogInfo(
+//                    tag = TAG,
+//                    message =
+//                    "Header: ${frames.first().header}\n" +
+//                        "ApduSize : $apduSize",
+//                ),
+//            )
+            for (apduFrame in frames) {
+                if (offset < apduSize) {
+                    rawApdu = apduFrame.apdu.extractApdu(toExclusive = offset)
+                    payload += rawApdu
+                    apduSize -= offset
+                    offset = mtu - HEADER_SIZE
+                } else {
+                    rawApdu = apduFrame.apdu.extractApdu(toExclusive = apduSize)
+                    payload += rawApdu
+                    break
+                }
+//                loggerService.log(
+//                    info = buildSimpleInfoLogInfo(
+//                        tag = TAG,
+//                        message = "Apdu : ${rawApdu.toHexadecimalString()}",
+//                    ),
+//                )
+            }
+            return payload
+        }
+    }
+
+    fun createApduFrames(
+        mtu: Int,
+        isUsbTransport: Boolean,
+        onCreateBuffer: ()->ByteArray,
+    ): List<ApduFrame> {
+        var firstFrame = true
+        var nbrDataRead = 0
+        var apduSizeInt = 0
+        return buildList {
+            do {
+                val rawApdu: ByteArray
+                val apduSize: ByteArray?
+                val buffer = onCreateBuffer()
+                if(buffer.isEmpty()){
+                    return emptyList()
+                }
+                val parser = ApduParser(response = buffer)
+                val header = buffer.extractFrameHeader(isUsbTransport = isUsbTransport, parser = parser)
+                if (firstFrame) {
+                    apduSize = buffer.extractApduSize(parser = parser)
+                    apduSizeInt = apduSize.toIntOn2Bytes()
+                    rawApdu = parser.extractRemainingBytesValue()
+                    firstFrame = false
+                } else {
+                    apduSize = null
+                    rawApdu = parser.extractRemainingBytesValue()
+                }
+                nbrDataRead += mtu
+                add(
+                    ApduFrame(
+                        header = header,
+                        apduSize = apduSize,
+                        apdu = rawApdu,
+                    ),
+                )
+//                loggerService.log(
+//                    buildSimpleInfoLogInfo(
+//                        tag = TAG,
+//                        message = "APDU received = ${rawApdu.toHexadecimalString()}",
+//                    ),
+//                )
+            } while (nbrDataRead < apduSizeInt)
+        }
+    }
+
+    private fun ByteArray.isShortApdu(mtu: Int): Boolean = this.size < mtu - MAXIMUM_HEADER_SIZE
+
+    private fun ByteArray.extractApdu(toExclusive: Int) = this.sliceArray(0..<toExclusive)
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/framer/FramerUtils.kt

@@ -0,0 +1,35 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.framer
+
+import com.ditchoom.buffer.ByteOrder
+import com.ditchoom.buffer.PlatformBuffer
+import com.ditchoom.buffer.allocate
+import com.ditchoom.buffer.wrap
+import com.ledger.devicesdk.shared.internal.transport.framer.model.ApduFrame
+
+internal fun Int.to2BytesArray(): ByteArray {
+    val result = PlatformBuffer.allocate(Int.SIZE_BYTES).apply { writeShort(this@to2BytesArray.toShort()) }
+
+    return byteArrayOf(result[0], result[1])
+}
+
+internal fun List<ApduFrame>.toHexadecimalString(): String {
+    var result = ""
+    forEach { result += it.toString() }
+    return result
+}
+
+internal fun ByteArray.toIntOn2Bytes(): Int =
+    PlatformBuffer.wrap(this).readShort().toInt()
+
+internal fun ByteArray.toUInt(bo: ByteOrder = ByteOrder.LITTLE_ENDIAN) = this.toInt(bo = bo).toUInt()
+
+internal fun ByteArray.toInt(bo: ByteOrder = ByteOrder.LITTLE_ENDIAN): Int {
+    val paddedByteArray = ByteArray(Int.SIZE_BYTES)
+    this.copyInto(paddedByteArray)
+    return PlatformBuffer.wrap(array = paddedByteArray, byteOrder = bo).readInt()
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/framer/model/ApduConst.kt

@@ -0,0 +1,9 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.framer.model
+
+internal const val MINIMUM_APDU_SIZE = 4
+internal const val APDU_SIZE_SIZE = 2

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/framer/model/ApduFrame.kt

@@ -0,0 +1,66 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.framer.model
+
+@OptIn(ExperimentalStdlibApi::class) // Use of Byte.toHexString()
+internal data class ApduFrame(
+    val header: ApduFramerHeader,
+    val apduSize: ByteArray?,
+    val apdu: ByteArray,
+) {
+    init {
+        apduSize?.let { require(it.size == APDU_SIZE_SIZE) }
+    }
+
+    fun toByteArray(): ByteArray =
+        header.toByteArray() +
+            (apduSize?.let { byteArrayOf(apduSize[0], apduSize[1]) } ?: byteArrayOf()) +
+            apdu
+
+    fun size(): Int {
+        val apduSize = apduSize?.size ?: 0
+        return header.size() +
+            apduSize +
+            apdu.size
+    }
+
+    override fun toString(): String {
+        var result = "$header\napduSize = "
+        apduSize?.map {
+            result += "${it.toHexString().uppercase()} "
+        }
+        result += "\napdu = "
+        apdu.map {
+            result += "${it.toHexString().uppercase()} "
+        }
+        return result
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ApduFrame
+
+        if (header != other.header) return false
+        if (apduSize != null) {
+            if (other.apduSize == null) return false
+            if (!apduSize.contentEquals(other.apduSize)) return false
+        } else if (other.apduSize != null) {
+            return false
+        }
+        if (!apdu.contentEquals(other.apdu)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = header.hashCode()
+        result = 31 * result + (apduSize?.contentHashCode() ?: 0)
+        result = 31 * result + apdu.contentHashCode()
+        return result
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/framer/model/ApduFramerHeader.kt

@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.framer.model
+
+@OptIn(ExperimentalStdlibApi::class)
+internal data class ApduFramerHeader(
+    val channelId: ByteArray?,
+    val tagId: Byte = 0x05.toByte(),
+    val frameId: ByteArray,
+) {
+    init {
+        if(channelId != null){
+            require(channelId.size == CHANNEL_ID_SIZE)
+        }
+        require(frameId.size == FRAME_ID_SIZE)
+    }
+
+    fun toByteArray(): ByteArray {
+        return if(channelId != null){
+            channelId +
+                tagId +
+                frameId
+        }
+        else{
+            byteArrayOf(tagId) + frameId
+        }
+    }
+
+    override fun toString(): String {
+        var result = "--HEADER FRAME--\nchannelId = "
+        channelId?.map {
+            result += "${it.toHexString().uppercase()} "
+        }
+        result += "\ntagId = ${tagId.toHexString().uppercase()}"
+        result += "\nframeId = "
+        frameId.map {
+            result += "${it.toHexString().uppercase()} "
+        }
+        return result
+    }
+
+    fun size(): Int {
+        val size = frameId.size + 1 // 1 byte relating to the tagId
+        return if(channelId != null){
+            size + channelId.size
+        }
+        else{
+            size
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ApduFramerHeader
+
+        if (!channelId.contentEquals(other.channelId)) return false
+        if (tagId != other.tagId) return false
+        if (!frameId.contentEquals(other.frameId)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = channelId.contentHashCode()
+        result = 31 * result + tagId
+        result = 31 * result + frameId.contentHashCode()
+        return result
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/framer/model/FramerConst.kt

@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.framer.model
+
+internal const val HEADER_SIZE = 5
+internal const val CHANNEL_ID_INDEX = 0
+internal const val CHANNEL_ID_SIZE = 2
+internal const val TAG_ID_INDEX = 2
+internal const val FRAME_ID_INDEX = 3
+internal const val FRAME_ID_SIZE = 2
+internal const val MAXIMUM_HEADER_SIZE = HEADER_SIZE + APDU_SIZE_SIZE

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/utils/ByteExtension.kt

@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.utils
+
+import com.ledger.devicesdk.shared.api.utils.isHexadecimal
+
+internal fun Byte.isNotHexadecimal(): Boolean = !this.isHexadecimal()
+
+@OptIn(ExperimentalStdlibApi::class)
+internal fun Byte.isHexadecimal(): Boolean {
+    return try {
+        this.toHexString().isHexadecimal()
+        true
+    }
+    catch (e: NumberFormatException){
+        false
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/transport/utils/InternalByteArrayExtension.kt

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.transport.utils
+
+import com.ledger.devicesdk.shared.api.apdu.ApduParser
+import com.ledger.devicesdk.shared.internal.transport.framer.model.ApduFramerHeader
+
+internal fun ByteArray.extractFrameHeader(isUsbTransport: Boolean, parser: ApduParser) =
+    ApduFramerHeader(
+        channelId = if(isUsbTransport) parser.extract2BytesValue() else null,
+        tagId = parser.extractByteValue(),
+        frameId = parser.extract2BytesValue(),
+    )
+
+internal fun ByteArray.extractApduSize(parser: ApduParser) = parser.extract2BytesValue()

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/utils/Controller.kt

@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.utils
+
+internal interface Controller {
+    fun start()
+
+    fun stop()
+}