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

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

@@ -0,0 +1,198 @@
+/*
+ * 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
+
+import android.content.ComponentName
+import android.nfc.NfcAdapter
+import android.nfc.cardemulation.CardEmulation
+import android.nfc.cardemulation.HostApduService
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.activity.ComponentActivity
+import com.android.identity.android.mdoc.deviceretrieval.DeviceRetrievalHelper
+import com.android.identity.android.mdoc.engagement.NfcEngagementHelper
+import com.android.identity.android.mdoc.transport.DataTransport
+import eu.europa.ec.eudi.iso18013.transfer.TransferManager
+import eu.europa.ec.eudi.iso18013.transfer.internal.TAG
+import eu.europa.ec.eudi.iso18013.transfer.internal.connectionMethods
+import eu.europa.ec.eudi.iso18013.transfer.internal.mainExecutor
+import eu.europa.ec.eudi.iso18013.transfer.internal.transportOptions
+import org.multipaz.crypto.Crypto
+import org.multipaz.crypto.EcCurve
+import org.multipaz.crypto.EcPublicKey
+
+abstract class NfcEngagementService : HostApduService() {
+    abstract val transferManager: TransferManager
+
+    internal lateinit var retrievalMethods: List<DeviceRetrievalMethod>
+    internal lateinit var onConnecting: () -> Unit
+    internal lateinit var onDeviceRetrievalHelperReady: (deviceRetrievalHelper: DeviceRetrievalHelper) -> Unit
+    internal lateinit var onNewDeviceRequest: (request: ByteArray) -> Unit
+    internal lateinit var onDisconnected: (transportSpecificTermination: Boolean) -> Unit
+    internal lateinit var onCommunicationError: (error: Throwable) -> Unit
+
+    private lateinit var nfcEngagement: NfcEngagementHelper
+
+    private var deviceRetrievalHelper: DeviceRetrievalHelper? = null
+
+    private val eDevicePrivateKey by lazy {
+        Crypto.createEcPrivateKey(EcCurve.P256)
+    }
+
+    companion object {
+        @JvmStatic
+        fun enable(
+            activity: ComponentActivity,
+            preferredNfcEngSerCls: Class<out NfcEngagementService>? = null,
+        ) {
+            // set preferred Nfc Engagement Service
+            preferredNfcEngSerCls?.let {
+                setAsPreferredNfcEngagementService(activity, preferredNfcEngSerCls)
+            }
+        }
+
+        @JvmStatic
+        fun disable(activity: ComponentActivity) {
+            // unset preferred Nfc Engagement Service
+            unsetAsPreferredNfcEngagementService(activity)
+        }
+
+        @JvmStatic
+        private fun setAsPreferredNfcEngagementService(
+            activity: ComponentActivity,
+            nfcEngagementServiceClass: Class<out NfcEngagementService>,
+        ) {
+            val cardEmulation = CardEmulation.getInstance(NfcAdapter.getDefaultAdapter(activity))
+            val allowsForeground =
+                cardEmulation.categoryAllowsForegroundPreference(CardEmulation.CATEGORY_OTHER)
+            if (allowsForeground) {
+                val hceComponentName = ComponentName(
+                    activity,
+                    nfcEngagementServiceClass,
+                )
+                cardEmulation.setPreferredService(activity, hceComponentName)
+            }
+        }
+
+        @JvmStatic
+        private fun unsetAsPreferredNfcEngagementService(activity: ComponentActivity) {
+            val cardEmulation = CardEmulation.getInstance(NfcAdapter.getDefaultAdapter(activity))
+            val allowsForeground =
+                cardEmulation.categoryAllowsForegroundPreference(CardEmulation.CATEGORY_OTHER)
+            if (allowsForeground) {
+                cardEmulation.unsetPreferredService(activity)
+            }
+        }
+    }
+
+    private val nfcEngagementListener = object : NfcEngagementHelper.Listener {
+        override fun onTwoWayEngagementDetected() {
+            Log.d(this.TAG, "Engagement Listener: Two Way Engagement Detected.")
+        }
+
+        override fun onDeviceConnecting() {
+            Log.d(this.TAG, "NFC Engagement: Device Connecting")
+            onConnecting()
+        }
+
+        override fun onDeviceConnected(transport: DataTransport) {
+            if (deviceRetrievalHelper != null) {
+                Log.d(
+                    TAG,
+                    "Engagement Listener: Device Connected -> ignored due to active presentation",
+                )
+                return
+            }
+
+            Log.d(this.TAG, "onDeviceConnected via NFC: nfcEngagement=$nfcEngagement")
+
+            val builder = DeviceRetrievalHelper.Builder(
+                applicationContext,
+                deviceRetrievalHelperListener,
+                application.mainExecutor(),
+                eDevicePrivateKey,
+            )
+            builder.useForwardEngagement(
+                transport,
+                nfcEngagement.deviceEngagement,
+                nfcEngagement.handover,
+            )
+            deviceRetrievalHelper = builder.build()
+            nfcEngagement.close()
+            onDeviceRetrievalHelperReady(requireNotNull(deviceRetrievalHelper))
+        }
+
+        override fun onError(error: Throwable) {
+            Log.d(this.TAG, "NFC onError: ${error.message}")
+            onCommunicationError(error)
+        }
+
+        override fun onHandoverSelectMessageSent() {
+            Log.d(this.TAG, "NFC Engagement: Handover Select Message Sent")
+            Log.d(this.TAG, "NFC Engagement: NegotiatedHandover not supported yet")
+        }
+    }
+
+    private val deviceRetrievalHelperListener = object : DeviceRetrievalHelper.Listener {
+        override fun onEReaderKeyReceived(eReaderKey: EcPublicKey) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (NFC): onEReaderKeyReceived")
+        }
+
+        override fun onDeviceRequest(deviceRequestBytes: ByteArray) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (NFC): onDeviceRequest")
+            onNewDeviceRequest(deviceRequestBytes)
+        }
+
+        override fun onDeviceDisconnected(transportSpecificTermination: Boolean) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (NFC): onDeviceDisconnected")
+            onDisconnected(transportSpecificTermination)
+        }
+
+        override fun onError(error: Throwable) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (NFC): onError -> ${error.message}")
+            onCommunicationError(error)
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        transferManager.setupNfcEngagement(this)
+        nfcEngagement = NfcEngagementHelper.Builder(
+            applicationContext,
+            eDevicePrivateKey.publicKey,
+            retrievalMethods.transportOptions,
+            nfcEngagementListener,
+            applicationContext.mainExecutor(),
+        ).apply {
+            useStaticHandover(retrievalMethods.connectionMethods)
+        }.build()
+    }
+
+    override fun processCommandApdu(commandApdu: ByteArray, extras: Bundle?): ByteArray {
+        return nfcEngagement.nfcProcessCommandApdu(commandApdu)
+    }
+
+    override fun onDeactivated(reason: Int) {
+        nfcEngagement.nfcOnDeactivated(reason)
+        val timeoutSeconds = 15
+        Handler(Looper.getMainLooper()).postDelayed({
+            nfcEngagement.close()
+        }, timeoutSeconds * 1000L)
+    }
+}

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

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 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 RetrievalMethod

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

@@ -0,0 +1,41 @@
+/*
+ * 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.internal
+
+import android.util.Log
+import com.android.identity.android.mdoc.deviceretrieval.DeviceRetrievalHelper
+import org.multipaz.util.Constants
+
+internal fun DeviceRetrievalHelper.stopPresentation(
+    sendSessionTerminationMessage: Boolean,
+    useTransportSpecificSessionTermination: Boolean,
+) {
+    try {
+        if (sendSessionTerminationMessage) {
+            if (useTransportSpecificSessionTermination) {
+                sendTransportSpecificTermination()
+            } else {
+                sendDeviceResponse(
+                    null,
+                    Constants.SESSION_DATA_STATUS_SESSION_TERMINATION,
+                )
+            }
+        }
+        disconnect()
+    } catch (e: Exception) {
+        Log.e(this.TAG, "Error ignored.", e)
+    }
+}

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

@@ -0,0 +1,55 @@
+/*
+ * 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.internal
+
+import com.android.identity.android.mdoc.transport.DataTransportOptions
+import eu.europa.ec.eudi.iso18013.transfer.engagement.BleRetrievalMethod
+import eu.europa.ec.eudi.iso18013.transfer.engagement.DeviceRetrievalMethod
+import org.multipaz.mdoc.connectionmethod.MdocConnectionMethod
+import org.multipaz.mdoc.connectionmethod.MdocConnectionMethodBle
+import org.multipaz.util.UUID
+
+internal val DeviceRetrievalMethod.connectionMethod: List<MdocConnectionMethod>
+    get() = when (this) {
+        is BleRetrievalMethod -> {
+            if (!peripheralServerMode && !centralClientMode) emptyList()
+            else {
+                mutableListOf<MdocConnectionMethod>().apply {
+                    val randomUUID = UUID.randomUUID()
+                    add(
+                        MdocConnectionMethodBle(
+                            peripheralServerMode,
+                            centralClientMode,
+                            if (peripheralServerMode) randomUUID else null,
+                            if (centralClientMode) randomUUID else null
+                        )
+                    )
+                }
+            }
+        }
+
+        else -> throw IllegalArgumentException("Unsupported connection method")
+    }
+
+internal val List<DeviceRetrievalMethod>.transportOptions: DataTransportOptions
+    get() = DataTransportOptions.Builder().apply {
+        for (m in this@transportOptions) {
+            if (m is BleRetrievalMethod) setBleClearCache(m.clearBleCache)
+        }
+    }.build()
+
+internal val List<DeviceRetrievalMethod>.connectionMethods: List<MdocConnectionMethod>
+    get() = flatMap { it.connectionMethod }

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

@@ -0,0 +1,97 @@
+/*
+ * 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.internal
+
+import android.content.Context
+import android.util.Base64
+import android.util.Log
+import androidx.core.net.toUri
+import com.android.identity.android.mdoc.deviceretrieval.DeviceRetrievalHelper
+import com.android.identity.android.mdoc.transport.DataTransport
+import com.android.identity.android.mdoc.transport.DataTransportOptions
+import org.multipaz.cbor.Cbor
+import org.multipaz.crypto.Crypto
+import org.multipaz.crypto.EcCurve
+import org.multipaz.crypto.EcPublicKey
+import org.multipaz.mdoc.engagement.DeviceEngagement
+import org.multipaz.mdoc.origininfo.OriginInfo
+
+internal class EngagementToApp(
+    private val context: Context,
+    private val dataTransportOptions: DataTransportOptions,
+    private val onPresentationReady: (deviceRetrievalHelper: DeviceRetrievalHelper) -> Unit,
+    private val onNewRequest: (request: ByteArray) -> Unit,
+    private val onDisconnected: () -> Unit,
+    private val onCommunicationError: (error: Throwable) -> Unit,
+) {
+
+    @JvmSynthetic
+    internal val eDevicePrivateKey = Crypto.createEcPrivateKey(EcCurve.P256)
+
+    private val presentationListener = object : DeviceRetrievalHelper.Listener {
+        override fun onEReaderKeyReceived(eReaderKey: EcPublicKey) {
+            Log.d(TAG, "DeviceRetrievalHelper Listener (QR): OnEReaderKeyReceived")
+        }
+
+        override fun onDeviceRequest(deviceRequestBytes: ByteArray) {
+            onNewRequest(deviceRequestBytes)
+        }
+
+        override fun onDeviceDisconnected(transportSpecificTermination: Boolean) {
+            onDisconnected()
+        }
+
+        override fun onError(error: Throwable) {
+            onCommunicationError(error)
+        }
+    }
+
+    fun configure(
+        reverseEngagementUri: String,
+        origins: List<OriginInfo>,
+    ) {
+        val uri = reverseEngagementUri.toUri()
+        check(uri.scheme.equals("mdoc")) { "Only supports mdoc URIs" }
+
+        val encodedReaderEngagement = Base64.decode(
+            uri.encodedSchemeSpecificPart,
+            Base64.URL_SAFE or Base64.NO_PADDING,
+        )
+        val engagement = DeviceEngagement.fromDataItem(Cbor.decode(encodedReaderEngagement))
+        check(engagement.connectionMethods.isNotEmpty()) { "No connection methods in engagement" }
+
+        // For now, just pick the first transport
+        val connectionMethod = engagement.connectionMethods[0]
+        Log.d(this.TAG, "Using connection method $connectionMethod")
+
+        val transport = DataTransport.fromConnectionMethod(
+            context,
+            connectionMethod,
+            DataTransport.Role.MDOC,
+            dataTransportOptions,
+        )
+
+        val builder = DeviceRetrievalHelper.Builder(
+            context,
+            presentationListener,
+            context.mainExecutor(),
+            eDevicePrivateKey,
+        ).useReverseEngagement(transport, encodedReaderEngagement, origins)
+        builder.build().apply {
+            onPresentationReady(this)
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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.internal
+
+import android.content.Context
+import android.os.Build
+import androidx.core.content.ContextCompat
+import java.util.concurrent.Executor
+
+internal val Any.TAG: String
+    get() {
+        if (this is String) return this
+        val fullClassName: String = this::class.qualifiedName ?: this::class.java.typeName
+        val outerClassName = fullClassName.substringBefore('$')
+        val simplerOuterClassName = outerClassName.substringAfterLast('.')
+        return if (simplerOuterClassName.isEmpty()) {
+            fullClassName
+        } else {
+            simplerOuterClassName.removeSuffix("Kt")
+        }
+    }
+
+internal fun Context.mainExecutor(): Executor {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        mainExecutor
+    } else {
+        ContextCompat.getMainExecutor(applicationContext)
+    }
+}

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

@@ -0,0 +1,141 @@
+/*
+ * 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.internal
+
+import android.content.Context
+import android.util.Log
+import com.android.identity.android.mdoc.deviceretrieval.DeviceRetrievalHelper
+import com.android.identity.android.mdoc.engagement.QrEngagementHelper
+import com.android.identity.android.mdoc.transport.DataTransport
+import eu.europa.ec.eudi.iso18013.transfer.engagement.DeviceRetrievalMethod
+import org.multipaz.crypto.Crypto
+import org.multipaz.crypto.EcCurve
+import org.multipaz.crypto.EcPublicKey
+
+internal class QrEngagement(
+    private val context: Context,
+    val retrievalMethods: List<DeviceRetrievalMethod>,
+    val onConnecting: () -> Unit,
+    val onQrEngagementReady: (qrCode: String) -> Unit,
+    val onDeviceRetrievalHelperReady: (deviceRetrievalHelper: DeviceRetrievalHelper) -> Unit,
+    val onNewDeviceRequest: (request: ByteArray) -> Unit,
+    val onDisconnected: (transportSpecificTermination: Boolean) -> Unit,
+    val onCommunicationError: (error: Throwable) -> Unit,
+) {
+
+    @JvmSynthetic
+    internal var deviceRetrievalHelper: DeviceRetrievalHelper? = null
+
+    @get:JvmSynthetic
+    internal val eDevicePrivateKey by lazy {
+        Crypto.createEcPrivateKey(EcCurve.P256)
+    }
+
+    @get:JvmSynthetic
+    internal val qrEngagementListener = object : QrEngagementHelper.Listener {
+
+        override fun onDeviceConnecting() {
+            Log.d(this.TAG, "QR Engagement: Device Connecting")
+            onConnecting()
+        }
+
+        override fun onDeviceConnected(transport: DataTransport) {
+            if (deviceRetrievalHelper != null) {
+                Log.d(
+                    this.TAG,
+                    "OnDeviceConnected for QR engagement -> ignoring due to active presentation"
+                )
+                return
+            }
+
+            Log.d(this.TAG, "OnDeviceConnected via QR: qrEngagement=$helper")
+
+            val builder = DeviceRetrievalHelper.Builder(
+                context,
+                deviceRetrievalHelperListener,
+                context.mainExecutor(),
+                eDevicePrivateKey,
+            )
+            builder.useForwardEngagement(
+                transport,
+                helper.deviceEngagement,
+                helper.handover,
+            )
+            deviceRetrievalHelper = builder.build()
+            helper.close()
+            onDeviceRetrievalHelperReady(requireNotNull(deviceRetrievalHelper))
+        }
+
+        override fun onError(error: Throwable) {
+            Log.d(this.TAG, "QR onError: ${error.message}")
+            onCommunicationError(error)
+        }
+    }
+
+    @JvmSynthetic
+    internal val deviceRetrievalHelperListener = object : DeviceRetrievalHelper.Listener {
+        override fun onEReaderKeyReceived(eReaderKey: EcPublicKey) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (QR): OnEReaderKeyReceived")
+        }
+
+        override fun onDeviceRequest(deviceRequestBytes: ByteArray) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (QR): OnDeviceRequest")
+            onNewDeviceRequest(deviceRequestBytes)
+        }
+
+        override fun onDeviceDisconnected(transportSpecificTermination: Boolean) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (QR): onDeviceDisconnected")
+            onDisconnected(transportSpecificTermination)
+        }
+
+        override fun onError(error: Throwable) {
+            Log.d(this.TAG, "DeviceRetrievalHelper Listener (QR): onError -> ${error.message}")
+            onCommunicationError(error)
+        }
+    }
+
+    @JvmSynthetic
+    internal lateinit var helper: QrEngagementHelper
+
+    val deviceEngagementUriEncoded: String
+        get() = helper.deviceEngagementUriEncoded
+
+    /**
+     * Configures the QR engagement
+     */
+    fun configure() {
+        helper = QrEngagementHelper.Builder(
+            context,
+            eDevicePrivateKey.publicKey,
+            retrievalMethods.transportOptions,
+            qrEngagementListener,
+            context.mainExecutor(),
+        ).setConnectionMethods(retrievalMethods.connectionMethods)
+            .build()
+        onQrEngagementReady(helper.deviceEngagementUriEncoded)
+    }
+
+    /**
+     * Closes the connection with the mdoc verifier
+     */
+    fun close() {
+        try {
+            helper.close()
+        } catch (exception: RuntimeException) {
+            Log.e(this.TAG, "Error closing QR engagement", exception)
+        }
+    }
+}

package/android/src/main/java/id/animo/{mdocdatatransfer → mdoc/datatransfer}/MdocDataTransfer.kt

@@ -1,4 +1,4 @@
-package id.animo.mdocdatatransfer
+package id.animo.mdoc.datatransfer
 
 import android.app.Activity
 import android.content.Context
@@ -6,9 +6,10 @@ import android.util.Log
 import androidx.activity.ComponentActivity
 import eu.europa.ec.eudi.iso18013.transfer.TransferEvent
 import eu.europa.ec.eudi.iso18013.transfer.engagement.NfcEngagementService
-import eu.europa.ec.eudi.iso18013.transfer.response.device.DeviceRequest
-import eu.europa.ec.eudi.iso18013.transfer.response.device.DeviceResponse
+import kotlin.io.encoding.Base64
+import kotlin.io.encoding.ExperimentalEncodingApi
 
+@OptIn(ExperimentalEncodingApi::class)
 class MdocDataTransfer(
     context: Context,
     private val currentActivity: Activity,
@@ -25,7 +26,7 @@ class MdocDataTransfer(
             when (event) {
                 is TransferEvent.QrEngagementReady -> {
                     Log.d(TAG, ":::mdoc-data-transfer::: TransferEvent.QrEngagementReady")
-                    onQrEngagementReady?.let { it(event.qrCode.content) }
+                    onQrEngagementReady?.let { it(event.qrCode) }
                 }
 
                 is TransferEvent.Connecting -> {
@@ -50,11 +51,11 @@ class MdocDataTransfer(
 
                 is TransferEvent.RequestReceived -> {
                     Log.d(TAG, ":::mdoc-data-transfer::: TransferEvent.RequestReceived")
-                    val request = event.request as DeviceRequest
                     sendEvent(
-                        MdocDataTransferEvent.ON_REQUEST_RECEIVED, mapOf(
-                            "deviceRequest" to request.deviceRequestBytes.asList(),
-                            "sessionTranscript" to request.sessionTranscriptBytes.asList()
+                        MdocDataTransferEvent.ON_REQUEST_RECEIVED,
+                        mapOf(
+                            ("deviceRequest" to Base64.Default.encode(event.deviceRequestBytes)),
+                            ("sessionTranscript" to Base64.Default.encode(event.sessionTranscriptBytes))
                         )
                     )
                 }
@@ -62,9 +63,12 @@ class MdocDataTransfer(
                 is TransferEvent.ResponseSent -> {
                     Log.d(TAG, ":::mdoc-data-transfer::: TransferEvent.ResponseSent")
                     sendEvent(
-                        MdocDataTransferEvent.ON_RESPONSE_SENT, null
+                        MdocDataTransferEvent.ON_RESPONSE_SENT,
+                        null
                     )
                 }
+
+                is TransferEvent.IntentToSend -> TODO()
             }
         }
 
@@ -78,7 +82,7 @@ class MdocDataTransfer(
     }
 
     fun respond(deviceResponse: ByteArray) {
-        MdocDataTransferManager.transferManager.value.sendResponse(DeviceResponse(deviceResponse))
+        MdocDataTransferManager.transferManager.value.sendResponse(deviceResponse)
     }
 
     fun enableNfc() {
@@ -91,6 +95,9 @@ class MdocDataTransfer(
 
     fun shutdown() {
         disableNfc()
-        MdocDataTransferManager.transferManager.value.stopPresentation(true, true)
+        MdocDataTransferManager.transferManager.value.stopPresentation(
+            sendSessionTerminationMessage = true,
+            useTransportSpecificSessionTermination = true
+        )
     }
 }

package/android/src/main/java/id/animo/{mdocdatatransfer → mdoc/datatransfer}/MdocDataTransferEvent.kt

@@ -1,6 +1,6 @@
-package id.animo.mdocdatatransfer
+package id.animo.mdoc.datatransfer
 
 object MdocDataTransferEvent {
     const val ON_REQUEST_RECEIVED = "onRequestReceived"
     const val ON_RESPONSE_SENT = "onResponseSent"
-}
+}