@pagopa/io-react-native-cie 1.0.0

package/android/build.gradle

@@ -0,0 +1,83 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['IoReactNativeCie_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["IoReactNativeCie_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.pagopa.ioreactnativecie"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  // CIE SDK
+  implementation "it.pagopa.io.app.cie:cie:0.1.4"
+}
+

package/android/gradle.properties

@@ -0,0 +1,5 @@
+IoReactNativeCie_kotlinVersion=2.0.21
+IoReactNativeCie_minSdkVersion=24
+IoReactNativeCie_targetSdkVersion=34
+IoReactNativeCie_compileSdkVersion=35
+IoReactNativeCie_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.pagopa.ioreactnativecie">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/pagopa/ioreactnativecie/IoReactNativeCieModule.kt

@@ -0,0 +1,302 @@
+package com.pagopa.ioreactnativecie
+
+import android.util.Base64
+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.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.pagopa.ioreactnativecie.cie.Atr
+import it.pagopa.io.app.cie.CieLogger
+import it.pagopa.io.app.cie.CieSDK
+import it.pagopa.io.app.cie.cie.CieAtrCallback
+import it.pagopa.io.app.cie.cie.NfcError
+import it.pagopa.io.app.cie.cie.NfcEvent
+import it.pagopa.io.app.cie.network.NetworkCallback
+import it.pagopa.io.app.cie.network.NetworkError
+import it.pagopa.io.app.cie.nfc.NfcEvents
+import java.net.URL
+
+typealias ME = IoReactNativeCieModule.Companion.ModuleException
+
+class IoReactNativeCieModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  init {
+    CieLogger.enabled = BuildConfig.DEBUG
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  /**
+   * Lazy value ensures it is initialized with a valid activity when first used.
+   */
+  val cieSdk: CieSDK by lazy {
+    CieSDK.withContext(currentActivity)
+  };
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+  }
+
+  @ReactMethod
+  fun hasNfcFeature(promise: Promise) {
+    try {
+      cieSdk.hasNfcFeature().let {
+        promise.resolve(it)
+      }
+    } catch (e: Exception) {
+      ME.UNKNOWN_EXCEPTION.reject(
+        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
+      )
+    }
+  }
+
+  @ReactMethod
+  fun isNfcEnabled(promise: Promise) {
+    try {
+      cieSdk.isNfcAvailable().let {
+        promise.resolve(it)
+      }
+    } catch (e: Exception) {
+      ME.UNKNOWN_EXCEPTION.reject(
+        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
+      )
+    }
+  }
+
+  @ReactMethod
+  fun isCieAuthenticationSupported(promise: Promise) {
+    cieSdk.isCieAuthenticationSupported().apply {
+      promise.resolve(this)
+    }
+  }
+
+  @ReactMethod
+  fun openNfcSettings(promise: Promise) {
+    try {
+      cieSdk.openNfcSettings()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      ME.UNKNOWN_EXCEPTION.reject(
+        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
+      )
+    }
+  }
+
+  @ReactMethod
+  fun setAlertMessage(key: String, value: String, promise: Promise) {
+    // Android does not support alert messages for NFC reading
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun setCurrentAlertMessage(value: String, promise: Promise) {
+    // Android does not support alert messages for NFC reading
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun setCustomIdpUrl(url: String) {
+    cieSdk.withCustomIdpUrl(url)
+  }
+
+  @ReactMethod
+  fun startReadingAttributes(
+    timeout: Int = 10000,
+    promise: Promise,
+  ) {
+    try {
+      cieSdk.startReadingCieAtr(timeout, object : NfcEvents {
+        override fun event(event: NfcEvent) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.EVENT.value, WritableNativeMap().apply {
+              putString("name", event.name)
+              putDouble(
+                "progress",
+                (event.numeratorForKindOf.toDouble() / NfcEvent.totalKindOfNumeratorEvent.toDouble())
+              )
+            })
+        }
+
+        override fun error(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+
+        }
+      }, object : CieAtrCallback {
+        override fun onSuccess(atr: ByteArray) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ATTRIBUTES_SUCCESS.value, WritableNativeMap().apply {
+              putString("base64", Base64.encodeToString(atr, Base64.DEFAULT))
+              putString("type", Atr(atr).getCieType().name)
+            })
+        }
+
+        override fun onError(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("message", it) }
+            })
+        }
+      })
+      promise.resolve(null)
+    } catch (e: Exception) {
+      ME.UNKNOWN_EXCEPTION.reject(
+        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
+      )
+    }
+  }
+
+  @ReactMethod
+  fun startReading(
+    pin: String,
+    authenticationUrl: String,
+    timeout: Int = 10000,
+    promise: Promise,
+  ) {
+    try {
+      cieSdk.setPin(pin)
+    } catch (e: Exception) {
+      ME.PIN_REGEX_NOT_VALID.reject(
+        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
+      )
+      return;
+    }
+
+    try {
+      cieSdk.withUrl(URL(authenticationUrl).toString())
+    } catch (e: Exception) {
+      ME.INVALID_AUTH_URL.reject(promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty()))
+      return
+    }
+
+    try {
+      cieSdk.startReading(timeout, object : NfcEvents {
+        override fun event(event: NfcEvent) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.EVENT.value, WritableNativeMap().apply {
+              putString("name", event.name)
+              putDouble(
+                "progress", (event.numerator.toDouble() / NfcEvent.totalNumeratorEvent.toDouble())
+              )
+            })
+        }
+
+        override fun error(error: NfcError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNfcError(error).name)
+              error.msg?.let { putString("msg", it) }
+              error.numberOfAttempts?.let { putInt("attempts", it) }
+            })
+
+        }
+      }, object : NetworkCallback {
+        override fun onSuccess(url: String) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.SUCCESS.value, url)
+        }
+
+        override fun onError(networkError: NetworkError) {
+          this@IoReactNativeCieModule.reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EventType.ERROR.value, WritableNativeMap().apply {
+              putString("name", mapNetworkError(networkError).name)
+              networkError.msg?.let { putString("message", it) }
+            })
+        }
+      })
+      promise.resolve(null)
+    } catch (e: Exception) {
+      ME.UNKNOWN_EXCEPTION.reject(
+        promise, Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
+      )
+    }
+  }
+
+  @ReactMethod
+  fun stopReading() {
+    cieSdk.stopNFCListening()
+  }
+
+  fun mapNfcError(error: NfcError): ErrorType {
+    return when (error) {
+      NfcError.NOT_A_CIE -> ErrorType.NOT_A_CIE
+      NfcError.TAG_LOST -> ErrorType.TAG_LOST
+      NfcError.APDU_ERROR -> ErrorType.APDU_ERROR
+      NfcError.EXTENDED_APDU_NOT_SUPPORTED -> ErrorType.APDU_ERROR
+      NfcError.WRONG_PIN -> ErrorType.WRONG_PIN
+      NfcError.PIN_BLOCKED -> ErrorType.CARD_BLOCKED
+      else -> ErrorType.GENERIC_ERROR
+    }
+  }
+
+  fun mapNetworkError(error: NetworkError): ErrorType {
+    return when (error) {
+      NetworkError.NO_INTERNET_CONNECTION -> ErrorType.NO_INTERNET_CONNECTION
+      NetworkError.CERTIFICATE_EXPIRED -> ErrorType.CERTIFICATE_EXPIRED
+      NetworkError.CERTIFICATE_REVOKED -> ErrorType.CERTIFICATE_REVOKED
+      NetworkError.AUTHENTICATION_ERROR -> ErrorType.AUTHENTICATION_ERROR
+      else -> ErrorType.GENERIC_ERROR
+    }
+  }
+
+  companion object {
+    const val NAME = "IoReactNativeCie"
+    const val ERROR_USER_INFO_KEY = "error"
+
+    enum class EventType(val value: String) {
+      EVENT("onEvent"),
+      ERROR("onError"),
+      ATTRIBUTES_SUCCESS("onAttributesSuccess"),
+      SUCCESS("onSuccess")
+    }
+
+    enum class ErrorType {
+      NOT_A_CIE,
+      TAG_LOST,
+      APDU_ERROR,
+      WRONG_PIN,
+      CARD_BLOCKED,
+      NO_INTERNET_CONNECTION,
+      CERTIFICATE_EXPIRED,
+      CERTIFICATE_REVOKED,
+      AUTHENTICATION_ERROR,
+      GENERIC_ERROR,
+    }
+
+    enum class ModuleException(
+      val ex: Exception
+    ) {
+      PIN_REGEX_NOT_VALID(Exception("PIN_REGEX_NOT_VALID")),
+      INVALID_AUTH_URL(Exception("INVALID_AUTH_URL")),
+      UNKNOWN_EXCEPTION(Exception("UNKNOWN_EXCEPTION"));
+
+      fun reject(
+        promise: Promise, vararg args: Pair<String, String>
+      ) {
+        exMap(*args).let {
+          promise.reject(it.first, ex.message, it.second)
+        }
+      }
+
+      private fun exMap(vararg args: Pair<String, String>): Pair<String, WritableMap> {
+        val writableMap = WritableNativeMap()
+        args.forEach { writableMap.putString(it.first, it.second) }
+        return Pair(this.ex.message ?: "UNKNOWN", writableMap)
+      }
+    }
+  }
+}

package/android/src/main/java/com/pagopa/ioreactnativecie/IoReactNativeCiePackage.kt

@@ -0,0 +1,17 @@
+package com.pagopa.ioreactnativecie
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class IoReactNativeCiePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(IoReactNativeCieModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/pagopa/ioreactnativecie/cie/Atr.kt

@@ -0,0 +1,39 @@
+package com.pagopa.ioreactnativecie.cie
+
+import it.pagopa.io.app.cie.CieLogger
+
+class Atr(private val atr: ByteArray) {
+  fun getCieType(): CieType {
+    CieLogger.i("ATR_MAIN:", this.atr.toHexString())
+    CieType.entries.forEach {
+      CieLogger.i("ATR_OTHE:", it.atr.toHexString())
+      if (it.atr.isSubsetInOrder(this.atr))
+        return it
+    }
+    return CieType.UNKNOWN
+  }
+
+  private fun ByteArray.toHexString(): String {
+    return joinToString(separator = " ") { byte ->
+      "0x%02X".format(byte)
+    }
+  }
+
+  private fun ByteArray.isSubsetInOrder(second: ByteArray): Boolean {
+    if (this.size > second.size) return false
+    var indexSecond = 0
+    for (element in this) {
+      // Find the element in the second array starting from the current index
+      while (indexSecond < second.size && second[indexSecond] != element) {
+        indexSecond++
+      }
+      // If we reach the end of the second array without finding the element, return false
+      if (indexSecond == second.size) {
+        return false
+      }
+      // Increment the index for the next iteration
+      indexSecond++
+    }
+    return true
+  }
+}

package/android/src/main/java/com/pagopa/ioreactnativecie/cie/CieType.kt

@@ -0,0 +1,157 @@
+package com.pagopa.ioreactnativecie.cie
+
+/**Returns Cie Manufacturer*/
+enum class CieType(val atr: ByteArray) {
+  NXP(
+    byteArrayOf(
+      0x80.toByte(),
+      0x00,
+      0x43,
+      0x01,
+      0xB8.toByte(),
+      0x46,
+      0x04,
+      0x10,
+      0x10,
+      0x10,
+      0x10,
+      0x47,
+      0x03,
+      0x94.toByte(),
+      0x01,
+      0x80.toByte()
+    )
+  ),
+  GEMALTO(
+    byteArrayOf(
+      0x49, 0x61, 0x73, 0x45, 0x63, 0x63, 0x52, 0x6F, 0x6F, 0x74
+    )
+  ),
+  GEMALTO_2(
+    byteArrayOf(
+      0x47, 0x03, 0x94.toByte(), 0x41, 0xC0.toByte()
+    )
+  ),
+  ACTALIS(
+    byteArrayOf(
+      0x80.toByte(),
+      0x00,
+      0x43,
+      0x01,
+      0xB8.toByte(),
+      0x46,
+      0x04,
+      0x10,
+      0x10,
+      0x10,
+      0x10,
+      0x47,
+      0x03,
+      0x94.toByte(),
+      0x01,
+      0xE0.toByte(),
+      0x7F,
+      0x66,
+      0x08,
+      0x02,
+      0x02,
+      0x04,
+      0xD6.toByte(),
+      0x02,
+      0x02,
+      0x07,
+      0xE3.toByte(),
+      0xE0.toByte(),
+      0x10,
+      0x02,
+      0x02,
+      0x01,
+      0x04,
+      0x02,
+      0x02,
+      0x00,
+      0xE6.toByte(),
+      0x02,
+      0x02,
+      0x00,
+      0xE6.toByte(),
+      0x02.toByte(),
+      0x02,
+      0x00,
+      0xE6.toByte(),
+      0x78,
+      0x08,
+      0x06,
+      0x06,
+      0x2B,
+      0x81.toByte(),
+      0x22,
+      0xF8.toByte(),
+      0x78,
+      0x02
+    )
+  ),
+  ST(
+    byteArrayOf(
+      0x80.toByte(),
+      0x00,
+      0x43,
+      0x01,
+      0xB9.toByte(),
+      0x46,
+      0x04,
+      0x00,
+      0x00,
+      0x00,
+      0x10,
+      0x47,
+      0x03,
+      0x94.toByte(),
+      0x01,
+      0x81.toByte(),
+      0x4F,
+      0x0C,
+      0xA0.toByte(),
+      0x00,
+      0x00,
+      0x00,
+      0x95.toByte(),
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x8A.toByte(),
+      0x00,
+      0x01,
+      0xE0.toByte(),
+      0x10,
+      0x02,
+      0x02,
+      0x00,
+      0xFF.toByte(),
+      0x02,
+      0x02,
+      0x00,
+      0xFF.toByte(),
+      0x02,
+      0x02,
+      0x01,
+      0x00,
+      0x02,
+      0x02,
+      0x01,
+      0x00,
+      0x78,
+      0x08,
+      0x06,
+      0x06,
+      0x2B,
+      0x81.toByte(),
+      0x22,
+      0xF8.toByte(),
+      0x78,
+      0x02
+    )
+  ),
+  UNKNOWN(byteArrayOf())
+}

package/ios/CIEType.swift

@@ -0,0 +1,81 @@
+import Foundation
+
+enum CIEType: String, Sendable {
+    case CIE_Unknown = "UNKNOWN"
+    case CIE_Gemalto = "GEMALTO"
+    case CIE_Gemalto2 = "GEMALTO_2"
+    case CIE_NXP = "NXP"
+    case CIE_ST = "ST"
+    case CIE_Actalis = "ACTALIS"
+    
+    static func fromATR(_ atr: [UInt8]) -> CIEType {
+        let Gemalto_ATR: [UInt8] = [ 0x49, 0x61, 0x73, 0x45, 0x63, 0x63, 0x52, 0x6F, 0x6F, 0x74 ]
+        let NXP_ATR: [UInt8] = [0x80, 0x00, 0x43, 0x01, 0xB8, 0x46, 0x04, 0x10, 0x10, 0x10, 0x10, 0x47, 0x03, 0x94 ]
+        let Gemalto2_ATR: [UInt8] = [ 0x47, 0x03, 0x94, 0x41, 0xC0 ]
+        let ST_ATR: [UInt8] = [ 0x80, 0x00, 0x43, 0x01, 0xB9, 0x46, 0x04, 0x00, 0x00, 0x00, 0x10, 0x47, 0x03, 0x94, 0x01, 0x81, 0x4F, 0x0C, 0xA0, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x00, 0x8A, 0x00, 0x01, 0xE0, 0x10, 0x02, 0x02, 0x00, 0xFF, 0x02, 0x02, 0x00, 0xFF, 0x02, 0x02, 0x01, 0x00, 0x02, 0x02, 0x01, 0x00, 0x78, 0x08, 0x06 , 0x06 , 0x2B , 0x81 , 0x22 , 0xF8 , 0x78, 0x02, 0x82, 0x02, 0x90, 0x00 ]
+        let Actalis_ATR: [UInt8] = [0x80, 0x00, 0x43, 0x01, 0xB8, 0x46, 0x04, 0x10, 0x10, 0x10, 0x10, 0x47, 0x03, 0x94, 0x01, 0xE0, 0x7F, 0x66, 0x08, 0x02, 0x02, 0x04, 0xD6, 0x02, 0x02, 0x07, 0xE3, 0xE0, 0x10, 0x02, 0x02, 0x01, 0x04, 0x02, 0x02, 0x00, 0xE6, 0x02, 0x02, 0x00, 0xE6, 0x02, 0x02, 0x00, 0xE6, 0x78, 0x08, 0x06, 0x06, 0x2B, 0x81, 0x22, 0xF8, 0x78, 0x02 ]
+        
+        if #available(iOS 16.0, *) {
+            if atr.contains(Actalis_ATR) {
+                return .CIE_Actalis
+            }
+            if atr.contains(ST_ATR) {
+                return .CIE_ST
+            }
+            if atr.contains(NXP_ATR) {
+                return .CIE_NXP
+            }
+            if atr.contains(Gemalto2_ATR) {
+                return .CIE_Gemalto2
+            }
+            if atr.contains(Gemalto_ATR) {
+                return .CIE_Gemalto
+            }
+        }
+        else {
+            let atrStr = atr.hexEncodedString
+            if atrStr.contains(Actalis_ATR.hexEncodedString) {
+                return .CIE_Actalis
+            }
+            if atrStr.contains(ST_ATR.hexEncodedString) {
+                return .CIE_ST
+            }
+            if atrStr.contains(NXP_ATR.hexEncodedString) {
+                return .CIE_NXP
+            }
+            if atrStr.contains(Gemalto2_ATR.hexEncodedString) {
+                return .CIE_Gemalto
+            }
+            if atrStr.contains(Gemalto_ATR.hexEncodedString) {
+                return .CIE_Gemalto
+            }
+        }
+        
+        return .CIE_Unknown
+    }
+}
+
+extension Data {
+    struct HexEncodingOptions: OptionSet {
+        public let rawValue: Int
+        
+        public init(rawValue: Int) {
+            self.rawValue = rawValue
+        }
+        
+        public static let upperCase = HexEncodingOptions(rawValue: 1 << 0)
+    }
+    
+    func hexEncodedString(options: HexEncodingOptions = []) -> String {
+        let format = options.contains(.upperCase) ? "%02hhX" : "%02hhx"
+        return map { String(format: format, $0) }.joined()
+    }
+}
+
+
+extension Array<UInt8> {
+    
+    var hexEncodedString: String {
+        return Data(self).hexEncodedString()
+    }
+}

package/ios/IoReactNativeCie-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>