@animo-id/expo-mdoc-data-transfer 0.1.6 → 0.2.0-alpha.0

package/android/build.gradle

@@ -1,6 +1,6 @@
 apply plugin: 'com.android.library'
 
-group = 'id.animo.mdocdatatransfer'
+group = 'id.animo.mdoc.datatransfer'
 version = '0.1.0'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -9,30 +9,21 @@ applyKotlinExpoModulesCorePlugin()
 useCoreDependencies()
 useExpoPublishing()
 
-// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
-// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
-// Most of the time, you may like to manage the Android SDK versions yourself.
-def useManagedAndroidSdkVersions = false
-if (useManagedAndroidSdkVersions) {
-    useDefaultAndroidSdkVersions()
-} else {
-    buildscript {
-        // Simple helper that allows the root project to override versions declared by this library.
-        ext.safeExtGet = { prop, fallback ->
-            rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-        }
+buildscript {
+    ext.safeExtGet = { prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
     }
-    project.android {
-        compileSdkVersion safeExtGet("compileSdkVersion", 34)
-        defaultConfig {
-            minSdkVersion safeExtGet("minSdkVersion", 26)
-            targetSdkVersion safeExtGet("targetSdkVersion", 34)
-        }
+}
+project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 24)
+        targetSdkVersion safeExtGet("targetSdkVersion", 36)
     }
 }
 
 android {
-    namespace "id.animo.mdocdatatransfer"
+    namespace "id.animo.mdoc.datatransfer"
     defaultConfig {
         versionCode 1
         versionName "0.1.0"
@@ -42,27 +33,11 @@ android {
     }
 }
 
-dependencies {
-    implementation("eu.europa.ec.eudi:eudi-lib-android-wallet-document-manager:0.9.0") {
-        exclude group: 'org.bouncycastle'
-        exclude module: 'bcprov-jdk18on'
-    }
-
-    implementation("com.android.identity:identity-android:202408.1") {
-        exclude group: 'org.bouncycastle'
-        exclude module: 'bcprov-jdk18on'
-    }
 
-    implementation("eu.europa.ec.eudi:eudi-lib-android-iso18013-data-transfer:0.6.0") {
-        exclude group: 'org.bouncycastle'
-        exclude module: 'bcprov-jdk18on'
-    }
-
-    implementation("org.bouncycastle:bcprov-jdk18on") {
-        version {
-            strictly '1.72'
-        }
-    }
-
-    implementation "androidx.biometric:biometric-ktx:1.2.0-alpha05"
+dependencies {
+    implementation("androidx.appcompat:appcompat:1.7.1")
+    implementation("org.jetbrains.kotlinx:kotlinx-io-core:0.5.4")
+    implementation("org.jetbrains.kotlinx:kotlinx-io-bytestring:0.5.4")
+    implementation("org.multipaz:multipaz-android:0.95.0")
+    implementation("org.multipaz:multipaz-android-legacy:0.95.0")
 }

package/android/src/main/java/eu/europa/ec/eudi/iso18013/transfer/TransferEvent.kt

@@ -0,0 +1,39 @@
+package eu.europa.ec.eudi.iso18013.transfer
+
+import android.content.Intent
+import java.net.URI
+
+sealed interface TransferEvent {
+    data class QrEngagementReady(val qrCode: String) : TransferEvent
+
+    data object Connecting : TransferEvent
+
+    data object Connected : TransferEvent
+
+    data class RequestReceived(
+        val deviceRequestBytes: ByteArray,
+        val sessionTranscriptBytes: ByteArray
+    ) : TransferEvent
+
+    data object ResponseSent : TransferEvent
+
+    data class Redirect(val redirectUri: URI) : TransferEvent
+
+    data class IntentToSend(val intent: Intent) : TransferEvent
+
+    data object Disconnected : TransferEvent
+
+    data class Error(val error: Throwable) : TransferEvent
+
+    fun interface Listener {
+        fun onTransferEvent(event: TransferEvent)
+    }
+
+    interface Listenable {
+        fun addTransferEventListener(listener: Listener): Listenable
+
+        fun removeTransferEventListener(listener: Listener): Listenable
+
+        fun removeAllTransferEventListeners(): Listenable
+    }
+}

package/android/src/main/java/eu/europa/ec/eudi/iso18013/transfer/TransferManager.kt

@@ -0,0 +1,34 @@
+package eu.europa.ec.eudi.iso18013.transfer
+
+import android.content.Context
+import android.content.Intent
+import eu.europa.ec.eudi.iso18013.transfer.engagement.DeviceRetrievalMethod
+import eu.europa.ec.eudi.iso18013.transfer.engagement.NfcEngagementService
+
+interface TransferManager : TransferEvent.Listenable {
+    fun setRetrievalMethods(retrievalMethods: List<DeviceRetrievalMethod>): TransferManager
+
+    fun setupNfcEngagement(service: NfcEngagementService): TransferManager
+
+    fun startQrEngagement()
+
+
+    fun startEngagementToApp(intent: Intent)
+
+    fun sendResponse(deviceResponseBytes: ByteArray)
+
+    fun stopPresentation(
+        sendSessionTerminationMessage: Boolean = true,
+        useTransportSpecificSessionTermination: Boolean = false,
+    )
+
+    companion object {
+        @JvmStatic
+        fun getDefault(
+            context: Context,
+            retrievalMethods: List<DeviceRetrievalMethod>? = null,
+        ): TransferManager = TransferManagerImpl(context) {
+            retrievalMethods?.let { retrievalMethods(it) }
+        }
+    }
+}

package/android/src/main/java/eu/europa/ec/eudi/iso18013/transfer/TransferManagerImpl.kt

@@ -0,0 +1,258 @@
+package eu.europa.ec.eudi.iso18013.transfer
+
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import androidx.core.net.toUri
+import com.android.identity.android.mdoc.deviceretrieval.DeviceRetrievalHelper
+import eu.europa.ec.eudi.iso18013.transfer.engagement.DeviceRetrievalMethod
+import eu.europa.ec.eudi.iso18013.transfer.engagement.NfcEngagementService
+import eu.europa.ec.eudi.iso18013.transfer.internal.EngagementToApp
+import eu.europa.ec.eudi.iso18013.transfer.internal.QrEngagement
+import eu.europa.ec.eudi.iso18013.transfer.internal.TAG
+import eu.europa.ec.eudi.iso18013.transfer.internal.stopPresentation
+import eu.europa.ec.eudi.iso18013.transfer.internal.transportOptions
+import org.multipaz.mdoc.origininfo.OriginInfo
+import org.multipaz.mdoc.origininfo.OriginInfoDomain
+import org.multipaz.util.Constants
+
+class TransferManagerImpl @JvmOverloads constructor(
+    context: Context,
+    retrievalMethods: List<DeviceRetrievalMethod>? = null,
+) : TransferManager {
+    private val context = context.applicationContext
+
+    @JvmSynthetic
+    internal var deviceRetrievalHelper: DeviceRetrievalHelper? = null
+
+    @JvmSynthetic
+    internal var engagementToApp: EngagementToApp? = null
+
+    @JvmSynthetic
+    internal var qrEngagement: QrEngagement? = null
+
+    @JvmSynthetic
+    internal var hasStarted = false
+
+    var retrievalMethods: List<DeviceRetrievalMethod> =
+        retrievalMethods?.let { listOf(*it.toTypedArray()) } ?: emptyList()
+        private set(value) {
+            field = listOf(*value.toTypedArray())
+        }
+
+    @JvmSynthetic
+    internal val transferEventListeners = mutableListOf<TransferEvent.Listener>()
+
+    override fun addTransferEventListener(listener: TransferEvent.Listener) = apply {
+        transferEventListeners.add(listener)
+    }
+
+    override fun removeTransferEventListener(listener: TransferEvent.Listener) = apply {
+        transferEventListeners.remove(listener)
+    }
+
+    override fun removeAllTransferEventListeners() = apply {
+        transferEventListeners.clear()
+    }
+
+    override fun setRetrievalMethods(retrievalMethods: List<DeviceRetrievalMethod>) = apply {
+        this.retrievalMethods = retrievalMethods
+    }
+
+    override fun startQrEngagement() {
+        if (hasStarted) {
+            Log.d(this.TAG, TRANSFER_STARTED_MSG)
+            transferEventListeners.onTransferEvent(
+                TransferEvent.Error(
+                    IllegalStateException(
+                        TRANSFER_STARTED_MSG,
+                    ),
+                ),
+            )
+            return
+        }
+        qrEngagement = QrEngagement(
+            context = context,
+            retrievalMethods = retrievalMethods,
+            onQrEngagementReady = { qrCode ->
+                transferEventListeners.onTransferEvent(
+                    TransferEvent.QrEngagementReady(qrCode),
+                )
+            },
+            onConnecting = {
+                transferEventListeners.onTransferEvent(TransferEvent.Connecting)
+            },
+            onDeviceRetrievalHelperReady = { deviceRetrievalHelper ->
+                this.deviceRetrievalHelper = deviceRetrievalHelper
+                transferEventListeners.onTransferEvent(TransferEvent.Connected)
+            },
+            onNewDeviceRequest = { deviceRequestBytes ->
+                transferEventListeners.onTransferEvent(
+                    TransferEvent.RequestReceived(
+                        deviceRequestBytes,
+                        deviceRetrievalHelper?.sessionTranscript!!,
+                    )
+                )
+            },
+            onDisconnected = {
+                transferEventListeners.onTransferEvent(TransferEvent.Disconnected)
+            },
+            onCommunicationError = { error ->
+                Log.d(this.TAG, "onError: ${error.message}")
+                transferEventListeners.onTransferEvent(TransferEvent.Error(error))
+            },
+        ).apply { configure() }
+        hasStarted = true
+    }
+
+    override fun setupNfcEngagement(service: NfcEngagementService) = apply {
+        service.apply {
+            retrievalMethods = this@TransferManagerImpl.retrievalMethods
+            onConnecting = {
+                transferEventListeners.onTransferEvent(TransferEvent.Connecting)
+            }
+            onDeviceRetrievalHelperReady = { deviceRetrievalHelper ->
+                this@TransferManagerImpl.deviceRetrievalHelper = deviceRetrievalHelper
+                transferEventListeners.onTransferEvent(TransferEvent.Connected)
+            }
+            onNewDeviceRequest = { deviceRequestBytes ->
+                transferEventListeners.onTransferEvent(
+                    TransferEvent.RequestReceived(
+                        deviceRequestBytes,
+                        deviceRetrievalHelper?.sessionTranscript!!
+                    )
+                )
+            }
+            onDisconnected = {
+                transferEventListeners.onTransferEvent(TransferEvent.Disconnected)
+            }
+            onCommunicationError = { error ->
+                Log.d(this.TAG, "onError: ${error.message}")
+                transferEventListeners.onTransferEvent(TransferEvent.Error(error))
+            }
+        }
+    }
+
+    override fun startEngagementToApp(intent: Intent) {
+        if (hasStarted) {
+            Log.d(this.TAG, TRANSFER_STARTED_MSG)
+            transferEventListeners.onTransferEvent(
+                TransferEvent.Error(
+                    IllegalStateException(
+                        TRANSFER_STARTED_MSG,
+                    ),
+                ),
+            )
+            return
+        }
+        Log.d(this.TAG, "New intent $intent")
+
+        var mdocUri: String? = null
+        var mdocReferrerUri: String? = null
+        if (intent.scheme.equals("mdoc")) {
+            val uri = intent.toUri(0).toUri()
+            mdocUri = "mdoc://" + uri.authority
+            mdocReferrerUri = intent.extras?.getString(Intent.EXTRA_REFERRER)
+        }
+
+        if (mdocUri == null) {
+            Log.e(this.TAG, "No mdoc:// URI")
+            return
+        }
+        Log.i(this.TAG, "uri: $mdocUri")
+
+        val originInfos = ArrayList<OriginInfo>()
+        if (mdocReferrerUri == null) {
+            Log.w(this.TAG, "No referrer URI")
+        } else {
+            Log.i(this.TAG, "referrer: $mdocReferrerUri")
+            originInfos.add(OriginInfoDomain(mdocReferrerUri))
+        }
+
+        engagementToApp = EngagementToApp(
+            context = context,
+            dataTransportOptions = retrievalMethods.transportOptions,
+            onPresentationReady = { deviceRetrievalHelper ->
+                this.deviceRetrievalHelper = deviceRetrievalHelper
+                transferEventListeners.onTransferEvent(TransferEvent.Connected)
+            },
+            onNewRequest = { deviceRequestBytes ->
+                transferEventListeners.onTransferEvent(
+                    TransferEvent.RequestReceived(
+                        deviceRequestBytes,
+                        deviceRetrievalHelper?.sessionTranscript!!
+                    )
+                )
+            },
+            onDisconnected = {
+                transferEventListeners.onTransferEvent(TransferEvent.Disconnected)
+            },
+            onCommunicationError = { error ->
+                Log.d(this.TAG, "onError: ${error.message}")
+                transferEventListeners.onTransferEvent(TransferEvent.Error(error))
+            },
+        ).apply {
+            configure(mdocUri, originInfos)
+        }
+        hasStarted = true
+    }
+
+    override fun sendResponse(deviceResponseBytes: ByteArray) {
+        deviceRetrievalHelper?.sendDeviceResponse(
+            deviceResponseBytes,
+            Constants.SESSION_DATA_STATUS_SESSION_TERMINATION
+        )
+        transferEventListeners.onTransferEvent(TransferEvent.ResponseSent)
+    }
+
+    override fun stopPresentation(
+        sendSessionTerminationMessage: Boolean,
+        useTransportSpecificSessionTermination: Boolean,
+    ) {
+        deviceRetrievalHelper?.stopPresentation(
+            sendSessionTerminationMessage,
+            useTransportSpecificSessionTermination,
+        )
+        disconnect()
+    }
+
+    private fun disconnect() {
+        qrEngagement?.close()
+        destroy()
+    }
+
+    private fun destroy() {
+        deviceRetrievalHelper = null
+        qrEngagement = null
+        engagementToApp = null
+        hasStarted = false
+    }
+
+    companion object {
+        private const val TRANSFER_STARTED_MSG = "Transfer has already started."
+
+        private fun Collection<TransferEvent.Listener>.onTransferEvent(event: TransferEvent) {
+            forEach { it.onTransferEvent(event) }
+        }
+
+        operator fun invoke(context: Context, builder: Builder.() -> Unit): TransferManagerImpl {
+            val builder = Builder(context).apply(builder)
+            return builder.build()
+        }
+    }
+
+    class Builder(context: Context) {
+        private val context = context.applicationContext
+        var retrievalMethods: List<DeviceRetrievalMethod>? = null
+
+        fun retrievalMethods(retrievalMethods: List<DeviceRetrievalMethod>) =
+            apply { this.retrievalMethods = retrievalMethods }
+
+        fun build(): TransferManagerImpl {
+            return TransferManagerImpl(
+                context = context,
+                retrievalMethods = retrievalMethods ?: emptyList()
+            )
+        }
+    }
+}

package/android/src/main/java/eu/europa/ec/eudi/iso18013/transfer/engagement/BleRetrievalMethod.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2023-2024 European Commission
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package eu.europa.ec.eudi.iso18013.transfer.engagement
+
+data class BleRetrievalMethod(
+    val peripheralServerMode: Boolean,
+    val centralClientMode: Boolean,
+    val clearBleCache: Boolean,
+) : DeviceRetrievalMethod

package/android/src/main/java/eu/europa/ec/eudi/iso18013/transfer/engagement/DeviceRetrievalMethod.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2023-2024 European Commission
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package eu.europa.ec.eudi.iso18013.transfer.engagement
+
+interface DeviceRetrievalMethod : RetrievalMethod