@procivis/react-native-one-core 1.26730.0

package/android/src/main/java/ch/procivis/one/core/DeserializeSpecific.kt

@@ -0,0 +1,94 @@
+package ch.procivis.one.core
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import kotlin.reflect.KClass
+
+object DeserializeSpecific {
+    object Obj {
+        private val CustomConversionTypes = arrayOf(CredentialSchemaTypeBindingEnum::class)
+
+        fun isCustomConversionType(type: KClass<*>): Boolean {
+            return CustomConversionTypes.contains(type)
+        }
+
+        fun convertCustom(type: KClass<*>, input: ReadableMap, field: String): Any? {
+            return when (type) {
+                CredentialSchemaTypeBindingEnum::class -> input.getString(field)
+                    ?.let { credentialSchemaType(it) }
+
+                else -> {
+                    throw IllegalArgumentException("Invalid map conversion: $input")
+                }
+            }
+        }
+    }
+
+    private fun credentialSchemaType(
+        credentialSchemaType: String
+    ): CredentialSchemaTypeBindingEnum {
+        return when (credentialSchemaType) {
+            "PROCIVIS_ONE_SCHEMA2024" -> CredentialSchemaTypeBindingEnum.ProcivisOneSchema2024
+            "FALLBACK_SCHEMA2024" -> CredentialSchemaTypeBindingEnum.FallbackSchema2024
+            "MDOC" -> CredentialSchemaTypeBindingEnum.Mdoc
+            else -> CredentialSchemaTypeBindingEnum.Other(credentialSchemaType)
+        }
+    }
+
+    fun ids(ids: ReadableArray): List<String> {
+        val result = mutableListOf<String>()
+        for (n in 0 until ids.size()) {
+            result.add(ids.getString(n))
+        }
+        return result
+    }
+
+    fun historyListQuery(query: ReadableMap): HistoryListQueryBindingDto {
+        return HistoryListQueryBindingDto(
+            page = query.getUInt("page")!!,
+            pageSize = query.getUInt("pageSize")!!,
+            organisationId = query.getString("organisationId").toString(),
+            entityId = query.getString("entityId"),
+            action = opt(query.getString("action"), HistoryActionBindingEnum::valueOf),
+            entityTypes = opt(query.getArray("entityTypes")) { types ->
+                enumList(types, HistoryEntityTypeBindingEnum::valueOf)
+            },
+            createdDateFrom = query.getString("createdDateFrom"),
+            createdDateTo = query.getString("createdDateTo"),
+            didId = query.getString("didId"),
+            credentialId = query.getString("credentialId"),
+            credentialSchemaId = query.getString("credentialSchemaId"),
+            search = historySearch(
+                query.getString("searchText"),
+                query.getString("searchType"),
+            ),
+            proofSchemaId = query.getString("proofSchemaId"),
+        )
+    }
+
+    private fun historySearch(text: String?, type: String?): HistorySearchBindingDto? {
+        if (text == null) {
+            return null
+        }
+
+        return HistorySearchBindingDto(
+            text = text,
+            type = opt(type, HistorySearchEnumBindingEnum::valueOf),
+        )
+    }
+
+    private fun <F, T> opt(input: F?, fn: (F) -> T): T? {
+        if (input == null) {
+            return null
+        }
+        return fn(input)
+    }
+
+    private fun <T> enumList(entries: ReadableArray, fn: (String) -> T): List<T> {
+        val result = mutableListOf<T>()
+        for (n in 0 until entries.size()) {
+            result.add(fn(entries.getString(n)))
+        }
+        return result
+    }
+}

package/android/src/main/java/ch/procivis/one/core/ProcivisOneCoreModule.kt

@@ -0,0 +1,444 @@
+package ch.procivis.one.core
+
+import ch.procivis.one.core.Deserialize.construct
+import ch.procivis.one.core.Serialize.convertToRN
+import ch.procivis.one.core.Util.asyncCall
+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.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+class ProcivisOneCoreModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "ProcivisOneCoreModule"
+
+    private var oneCore: OneCoreBindingInterface? = null
+
+    private fun getCore(): OneCoreBindingInterface {
+        return oneCore ?: throw BindingException.Uninitialized("core not initialized")
+    }
+
+    @ReactMethod
+    fun initializeHolder(promise: Promise) {
+        asyncCall(promise) {
+            val dataDirPath = this.reactApplicationContext.filesDir.absolutePath
+            oneCore =
+                initializeHolderCore(
+                    dataDirPath,
+                    AndroidKeyStoreKeyStorage(this.reactApplicationContext),
+                    AndroidBLECentral(this.reactApplicationContext),
+                    AndroidBLEPeripheral(this.reactApplicationContext)
+                )
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun initializeVerifier(promise: Promise) {
+        asyncCall(promise) {
+            val dataDirPath = this.reactApplicationContext.filesDir.absolutePath
+            oneCore =
+                initializeVerifierCore(
+                    dataDirPath,
+                    AndroidKeyStoreKeyStorage(this.reactApplicationContext),
+                    AndroidBLECentral(this.reactApplicationContext),
+                    AndroidBLEPeripheral(this.reactApplicationContext)
+                )
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun getVersion(promise: Promise) {
+        asyncCall(promise) {
+            val version = getCore().version()
+            return@asyncCall convertToRN(version)
+        }
+    }
+
+    @ReactMethod
+    fun getConfig(promise: Promise) {
+        asyncCall(promise) {
+            val config = getCore().getConfig()
+            return@asyncCall convertToRN(config)
+        }
+    }
+
+    @ReactMethod
+    fun runTask(task: String, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().runTask(task)
+        }
+    }
+
+    @ReactMethod
+    fun deleteProofClaims(proofId: String, promise: Promise) {
+        asyncCall(promise) {
+            getCore().deleteProofClaims(proofId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun shareCredentialSchema(credentialSchemaId: String, promise: Promise) {
+        asyncCall(promise) {
+            val result = getCore().shareCredentialSchema(credentialSchemaId)
+            return@asyncCall convertToRN(result)
+        }
+    }
+
+    @ReactMethod
+    fun shareProofSchema(proofSchemaId: String, promise: Promise) {
+        asyncCall(promise) {
+            val result = getCore().shareProofSchema(proofSchemaId)
+            return@asyncCall convertToRN(result)
+        }
+    }
+
+    @ReactMethod
+    fun createOrganisation(uuid: String?, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().createOrganisation(uuid)
+        }
+    }
+
+    @ReactMethod
+    fun generateKey(keyRequest: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().generateKey(construct(keyRequest))
+        }
+    }
+
+    @ReactMethod
+    fun createDid(didRequest: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().createDid(construct(didRequest))
+        }
+    }
+
+    @ReactMethod
+    fun getDids(query: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            val dids = getCore().getDids(construct(query))
+            return@asyncCall convertToRN(dids)
+        }
+    }
+
+    @ReactMethod
+    fun handleInvitation(
+        url: String,
+        organisationId: String,
+        transport: ReadableArray?,
+        promise: Promise
+    ) {
+        asyncCall(promise) {
+            val transportList = transport?.let { DeserializeSpecific.ids(it) }
+            val invitationResult = getCore().handleInvitation(url, organisationId, transportList)
+            return@asyncCall convertToRN(invitationResult)
+        }
+    }
+
+    @ReactMethod
+    fun holderAcceptCredential(
+        interactionId: String,
+        didId: String,
+        keyId: String?,
+        promise: Promise
+    ) {
+        asyncCall(promise) {
+            getCore().holderAcceptCredential(interactionId, didId, keyId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun holderRejectCredential(interactionId: String, promise: Promise) {
+        asyncCall(promise) {
+            getCore().holderRejectCredential(interactionId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun getPresentationDefinition(proofId: String, promise: Promise) {
+        asyncCall(promise) {
+            val presentationDefinition = getCore().getPresentationDefinition(proofId)
+            return@asyncCall convertToRN(presentationDefinition)
+        }
+    }
+
+    @ReactMethod
+    fun holderRejectProof(interactionId: String, promise: Promise) {
+        asyncCall(promise) {
+            getCore().holderRejectProof(interactionId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun holderSubmitProof(
+        interactionId: String,
+        credentials: ReadableMap,
+        didId: String,
+        keyId: String?,
+        promise: Promise
+    ) {
+        asyncCall(promise) {
+            val submitCredentials =
+                mutableMapOf<String, PresentationSubmitCredentialRequestBindingDto>()
+            for (entry in credentials.entryIterator) {
+                val credential = entry.value as ReadableMap
+                submitCredentials[entry.key] = construct(credential)
+            }
+            getCore().holderSubmitProof(interactionId, submitCredentials, didId, keyId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun getCredentials(query: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            val credentials = getCore().getCredentials(construct(query))
+            return@asyncCall convertToRN(credentials)
+        }
+    }
+
+    @ReactMethod
+    fun getCredential(credentialId: String, promise: Promise) {
+        asyncCall(promise) {
+            val credential = getCore().getCredential(credentialId)
+            return@asyncCall convertToRN(credential)
+        }
+    }
+
+    @ReactMethod
+    fun deleteCredential(credentialId: String, promise: Promise) {
+        asyncCall(promise) {
+            getCore().deleteCredential(credentialId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun importCredentialSchema(request: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().importCredentialSchema(construct(request))
+        }
+    }
+
+    @ReactMethod
+    fun getCredentialSchema(credentialSchemaId: String, promise: Promise) {
+        asyncCall(promise) {
+            val schema = getCore().getCredentialSchema(credentialSchemaId)
+            return@asyncCall convertToRN(schema)
+        }
+    }
+
+    @ReactMethod
+    fun getCredentialSchemas(query: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            val schemas = getCore().getCredentialSchemas(construct(query))
+            return@asyncCall convertToRN(schemas)
+        }
+    }
+
+    @ReactMethod
+    fun deleteCredentialSchema(credentialSchemaId: String, promise: Promise) {
+        asyncCall(promise) {
+            getCore().deleteCredentialSchema(credentialSchemaId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun createProof(request: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().createProof(construct(request))
+        }
+    }
+
+    @ReactMethod
+    fun shareProof(proofId: String, promise: Promise) {
+        asyncCall(promise) {
+            val shareProof = getCore().shareProof(proofId)
+            return@asyncCall convertToRN(shareProof)
+        }
+    }
+
+    @ReactMethod
+    fun getProof(proofId: String, promise: Promise) {
+        asyncCall(promise) {
+            val proof = getCore().getProof(proofId)
+            return@asyncCall convertToRN(proof)
+        }
+    }
+
+    @ReactMethod
+    fun getProofs(query: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            val proofs = getCore().getProofs(construct(query))
+            return@asyncCall convertToRN(proofs)
+        }
+    }
+
+    @ReactMethod
+    fun retractProof(proofId: String, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().retractProof(proofId)
+        }
+    }
+
+    @ReactMethod
+    fun proposeProof(exchange: String, organisationId: String, promise: Promise) {
+        asyncCall(promise) {
+            val result = getCore().proposeProof(exchange, organisationId)
+            return@asyncCall convertToRN(result)
+        }
+    }
+
+    @ReactMethod
+    fun createProofSchema(request: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().createProofSchema(construct(request))
+        }
+    }
+
+    @ReactMethod
+    fun getProofSchemas(query: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            val schemas = getCore().getProofSchemas(construct(query))
+            return@asyncCall convertToRN(schemas)
+        }
+    }
+
+    @ReactMethod
+    fun getProofSchema(proofSchemaId: String, promise: Promise) {
+        asyncCall(promise) {
+            val schema = getCore().getProofSchema(proofSchemaId)
+            return@asyncCall convertToRN(schema)
+        }
+    }
+
+    @ReactMethod
+    fun deleteProofSchema(proofSchemaId: String, promise: Promise) {
+        asyncCall(promise) {
+            getCore().deleteProofSchema(proofSchemaId)
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun importProofSchema(request: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().importProofSchema(construct(request))
+        }
+    }
+
+    @ReactMethod
+    fun checkRevocation(credentialIds: ReadableArray, promise: Promise) {
+        asyncCall(promise) {
+            val ids = DeserializeSpecific.ids(credentialIds)
+            val results = getCore().checkRevocation(ids)
+            return@asyncCall convertToRN(results)
+        }
+    }
+
+    @ReactMethod
+    fun getHistory(query: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            val listQuery = DeserializeSpecific.historyListQuery(query)
+            val history = getCore().getHistoryList(listQuery)
+            return@asyncCall convertToRN(history)
+        }
+    }
+
+    @ReactMethod
+    fun getHistoryEntry(historyId: String, promise: Promise) {
+        asyncCall(promise) {
+            val result = getCore().getHistoryEntry(historyId)
+            return@asyncCall convertToRN(result)
+        }
+    }
+
+    @ReactMethod
+    fun createTrustAnchor(request: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            return@asyncCall getCore().createTrustAnchor(construct(request))
+        }
+    }
+
+    @ReactMethod
+    fun getTrustAnchor(trustAnchorId: String, promise: Promise) {
+        asyncCall(promise) {
+            val trustAnchor = getCore().getTrustAnchor(trustAnchorId)
+            return@asyncCall convertToRN(trustAnchor)
+        }
+    }
+
+    @ReactMethod
+    fun getTrustAnchors(query: ReadableMap, promise: Promise) {
+        asyncCall(promise) {
+            val trustAnchors = getCore().listTrustAnchors(construct(query))
+            return@asyncCall convertToRN(trustAnchors)
+        }
+    }
+
+    @ReactMethod
+    fun createBackup(password: String, outputPath: String, promise: Promise) {
+        asyncCall(promise) {
+            val result = getCore().createBackup(password, outputPath)
+            return@asyncCall convertToRN(result)
+        }
+    }
+
+    @ReactMethod
+    fun backupInfo(promise: Promise) {
+        asyncCall(promise) {
+            val backupInfo = getCore().backupInfo()
+            return@asyncCall convertToRN(backupInfo)
+        }
+    }
+
+    @ReactMethod
+    fun unpackBackup(password: String, inputPath: String, promise: Promise) {
+        asyncCall(promise) {
+            val result = getCore().unpackBackup(password, inputPath)
+            return@asyncCall convertToRN(result)
+        }
+    }
+
+    @ReactMethod
+    fun finalizeImport(promise: Promise) {
+        asyncCall(promise) {
+            getCore().finalizeImport()
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun rollbackImport(promise: Promise) {
+        asyncCall(promise) {
+            getCore().rollbackImport()
+            return@asyncCall null
+        }
+    }
+
+    @ReactMethod
+    fun resolveJsonldContext(url: String, promise: Promise) {
+        asyncCall(promise) {
+            val result = getCore().resolveJsonldContext(url)
+            return@asyncCall convertToRN(result)
+        }
+    }
+
+    @ReactMethod
+    fun uninitialize(deleteData: Boolean, promise: Promise) {
+        asyncCall(promise) {
+            getCore().uninitialize(deleteData)
+            oneCore = null
+            return@asyncCall null
+        }
+    }
+}

package/android/src/main/java/ch/procivis/one/core/ProcivisOneCorePackage.kt

@@ -0,0 +1,19 @@
+package ch.procivis.one.core
+
+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
+
+class ProcivisOneCorePackage : ReactPackage {
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): MutableList<ViewManager<View, ReactShadowNode<*>>> = mutableListOf()
+
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): MutableList<NativeModule> = listOf(ProcivisOneCoreModule(reactContext)).toMutableList()
+}

package/android/src/main/java/ch/procivis/one/core/Serialize.kt

@@ -0,0 +1,115 @@
+package ch.procivis.one.core
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+
+object Serialize {
+    fun convertToRN(input: Any?): Any? {
+        val (type, value) = getRNType(input)
+        return when (type) {
+            RNType.MAP -> value?.let { convertObjectToRN(it) }
+            RNType.ARRAY -> convertArrayToRN(input as Collection<*>)
+            else -> throw IllegalArgumentException("Invalid conversion: $input")
+        }
+    }
+
+    private enum class RNType {
+        MAP,
+        ARRAY,
+        NULL,
+        INT,
+        DOUBLE,
+        BOOLEAN,
+        STRING
+    }
+
+    private fun getRNType(input: Any?): Pair<RNType, *> {
+        if (input == null) {
+            return Pair(RNType.NULL, null)
+        }
+
+        val type = input.javaClass
+
+        if (Collection::class.java.isAssignableFrom(type)) {
+            return Pair(RNType.ARRAY, input as Collection<*>)
+        } else if (type.isEnum) {
+            return Pair(RNType.STRING, (input as Enum<*>).name)
+        } else if (type == Boolean::class.java || type == java.lang.Boolean::class.java) {
+            return Pair(RNType.BOOLEAN, input as Boolean)
+        } else if (type == String::class.java || type == java.lang.String::class.java) {
+            return Pair(RNType.STRING, input as String)
+        } else if (type == Int::class.java || type == java.lang.Integer::class.java) {
+            return Pair(RNType.INT, input as Int)
+        } else if (type == Byte::class.java || type == java.lang.Byte::class.java) {
+            return Pair(RNType.INT, (input as Byte).toInt())
+        } else if (type == Short::class.java || type == java.lang.Short::class.java) {
+            return Pair(RNType.INT, (input as Short).toInt())
+        } else if (type == Long::class.java || type == java.lang.Long::class.java) {
+            return Pair(RNType.DOUBLE, (input as Long).toDouble())
+        } else if (type == Float::class.java || type == java.lang.Float::class.java) {
+            return Pair(RNType.DOUBLE, (input as Float).toDouble())
+        } else if (type == Double::class.java || type == java.lang.Double::class.java) {
+            return Pair(RNType.DOUBLE, input as Double)
+        } else if (type == Char::class.java || type == java.lang.Character::class.java) {
+            return Pair(RNType.STRING, (input as Char).toString())
+        } else if (SerializeSpecific.Str.isCustomConversionType(input)) {
+            return Pair(RNType.STRING, SerializeSpecific.Str.convertCustom(input))
+        } else {
+            return Pair(RNType.MAP, input)
+        }
+    }
+
+    private fun convertObjectToRN(input: Any): ReadableMap {
+        if (SerializeSpecific.Obj.isCustomConversionType(input)) {
+            return SerializeSpecific.Obj.convertCustom(input)
+        }
+
+        val result = Arguments.createMap()
+        if (input is Map<*, *>) {
+            input.forEach { entry ->
+                convertObjectItemToRN(result, entry.key.toString(), entry.value)
+            }
+        } else {
+            input.javaClass.declaredFields.forEach { field ->
+                if (field.name != "Companion") // skip child companion objects generated by uniffi
+                {
+                    field.isAccessible = true
+                    convertObjectItemToRN(result, field.name, field.get(input))
+                }
+            }
+        }
+        return result
+    }
+
+    private fun convertObjectItemToRN(map: WritableMap, itemName: String, itemValue: Any?) {
+        val (type, value) = getRNType(itemValue)
+        when (type) {
+            RNType.MAP -> map.putMap(itemName, value?.let { convertObjectToRN(it) })
+            RNType.ARRAY -> map.putArray(itemName, convertArrayToRN(value as Collection<*>))
+            RNType.NULL -> {} // null fields are not present in the final JSON object
+            RNType.INT -> map.putInt(itemName, value as Int)
+            RNType.DOUBLE -> map.putDouble(itemName, value as Double)
+            RNType.BOOLEAN -> map.putBoolean(itemName, value as Boolean)
+            RNType.STRING -> map.putString(itemName, value as String)
+        }
+    }
+
+    private fun convertArrayToRN(input: Collection<*>): ReadableArray {
+        val result = Arguments.createArray()
+        input.forEach { item ->
+            val (type, value) = getRNType(item)
+            when (type) {
+                RNType.MAP -> result.pushMap(value?.let { convertObjectToRN(it) })
+                RNType.ARRAY -> result.pushArray(convertArrayToRN(value as Collection<*>))
+                RNType.NULL -> result.pushNull()
+                RNType.INT -> result.pushInt(value as Int)
+                RNType.DOUBLE -> result.pushDouble(value as Double)
+                RNType.BOOLEAN -> result.pushBoolean(value as Boolean)
+                RNType.STRING -> result.pushString(value as String)
+            }
+        }
+        return result
+    }
+}