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

package/ios/eudi/BLETransfer/MdocGATTServer.swift

@@ -0,0 +1,315 @@
+/*
+Copyright (c) 2023 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.
+*/
+
+import Foundation
+import SwiftCBOR
+import CoreBluetooth
+import Logging
+import MdocDataModel18013
+import MdocSecurity18013
+import WalletStorage
+
+public class MdocGattServer: @unchecked Sendable, ObservableObject {
+	var secureArea: SecureEnclaveSecureArea!
+	var crv = CoseEcCurve.P256
+	
+	var peripheralManager: CBPeripheralManager!
+	var bleDelegate: Delegate!
+	var remoteCentral: CBCentral!
+	var stateCharacteristic: CBMutableCharacteristic!
+	var server2ClientCharacteristic: CBMutableCharacteristic!
+	public var deviceEngagement: DeviceEngagement?
+	public var qrCodePayload: String?
+	public weak var delegate: (any MdocOfflineDelegate)?
+	var continuationQrCodeReady: CheckedContinuation<Void, Error>?
+	public var advertising: Bool = false
+	public var error: Error? = nil {
+		willSet {
+			handleErrorSet(newValue)
+		}
+	}
+	public var status: TransferStatus = .initializing {
+		willSet {
+			Task { @MainActor in
+				await handleStatusChange(newValue)
+			}
+		}
+	}
+	public var unlockData: [String: Data]!
+	public var deviceResponseBytes: Data?
+	var readBuffer = Data()
+	var sendBuffer = [Data]()
+	var numBlocks: Int = 0
+	var subscribeCount: Int = 0
+	var initSuccess:Bool = false
+
+	public init()  {
+		secureArea = SecureEnclaveSecureArea.create(storage: KeyChainSecureKeyStorage(serviceName: "TODO_SERVICE_NAME", accessGroup: nil))
+		status = .initialized
+		initPeripheralManager()
+		initSuccess = true
+	}
+
+	@objc(CBPeripheralManagerDelegate)
+	class Delegate: NSObject, CBPeripheralManagerDelegate {
+		unowned var server: MdocGattServer
+
+		init(server: MdocGattServer) {
+			self.server = server
+		}
+
+		func peripheralManagerIsReady(toUpdateSubscribers peripheral: CBPeripheralManager) {
+			if server.sendBuffer.count > 0 {
+				self.server.sendDataWithUpdates()
+			}
+		}
+
+		func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
+			logger.info("CBPeripheralManager didUpdateState:")
+			logger.info(peripheral.state == .poweredOn ? "Powered on" : peripheral.state == .unauthorized ? "Unauthorized" : peripheral.state == .unsupported ? "Unsupported" : "Powered off")
+			if peripheral.state == .poweredOn, server.qrCodePayload != nil {
+				server.continuationQrCodeReady?.resume()
+				server.continuationQrCodeReady = nil
+			}
+		}
+
+		func peripheralManager(_ peripheral: CBPeripheralManager, didReceiveWrite requests: [CBATTRequest]) {
+			if requests[0].characteristic.uuid == MdocServiceCharacteristic.state.uuid, let h = requests[0].value?.first {
+				if h == BleTransferMode.START_REQUEST.first! {
+					logger.info("Start request received to state characteristic") // --> start
+					server.status = .started
+					server.readBuffer.removeAll()
+				} else if h == BleTransferMode.END_REQUEST.first! {
+					guard server.status == .responseSent else {
+						logger.error("State END command rejected. Not in responseSent state")
+						peripheral.respond(to: requests[0], withResult: .unlikelyError)
+						return
+					}
+					logger.info("End received to state characteristic") // --> end
+					server.status = .disconnected
+				}
+			} else if requests[0].characteristic.uuid == MdocServiceCharacteristic.client2Server.uuid {
+				for r in requests {
+					guard let data = r.value, let h = data.first else {
+						continue
+					}
+					let bStart = h == BleTransferMode.START_DATA.first!
+					let bEnd = (h == BleTransferMode.END_DATA.first!)
+					if data.count > 1 {
+						server.readBuffer.append(data.advanced(by: 1))
+					}
+					if !bStart && !bEnd {
+						logger.warning("Not a valid request block: \(data)")
+					}
+					if bEnd {
+						server.status = .requestReceived
+					}
+				}
+			}
+			peripheral.respond(to: requests[0], withResult: .success)
+		}
+
+		public func peripheralManager(_ peripheral: CBPeripheralManager, central: CBCentral, didSubscribeTo characteristic: CBCharacteristic) {
+			guard server.status == .qrEngagementReady else {
+				return
+			}
+			let mdocCbc = MdocServiceCharacteristic(uuid: characteristic.uuid)
+			logger.info("Remote central \(central.identifier) connected for \(mdocCbc?.rawValue ?? "") characteristic")
+			server.remoteCentral = central
+			if characteristic.uuid == MdocServiceCharacteristic.state.uuid || characteristic.uuid == MdocServiceCharacteristic.server2Client.uuid {
+				server.subscribeCount += 1
+			}
+			if server.subscribeCount > 1 {
+				server.status = .connected
+			}
+		}
+
+		public func peripheralManager(_ peripheral: CBPeripheralManager, central: CBCentral, didUnsubscribeFrom characteristic: CBCharacteristic) {
+			let mdocCbc = MdocServiceCharacteristic(uuid: characteristic.uuid)
+			logger.info("Remote central \(central.identifier) disconnected for \(mdocCbc?.rawValue ?? "") characteristic")
+		}
+	}
+
+	/// Returns true if the peripheralManager state is poweredOn
+	public var isBlePoweredOn: Bool { peripheralManager.state == .poweredOn }
+
+	/// Returns true if the peripheralManager state is unauthorized
+	public var isBlePermissionDenied: Bool { peripheralManager.state == .unauthorized }
+
+	// Create a new device engagement object and start the device engagement process.
+	///
+	/// ``qrCodePayload`` is set to QR code data corresponding to the device engagement.
+	public func performDeviceEngagement() async throws -> String {
+		guard status == .initialized || status == .disconnected || status == .responseSent else {
+			throw MdocHelpers.makeError(code: .unexpected_error, str: error?.localizedDescription ?? "Not initialized!")
+		}
+		deviceEngagement = DeviceEngagement(isBleServer: true, rfus: nil)
+		try await deviceEngagement!.makePrivateKey(crv: crv, secureArea: secureArea)
+		qrCodePayload = deviceEngagement!.getQrCodePayload()
+		guard peripheralManager.state != .unauthorized else {
+			throw MdocHelpers.makeError(code: .bleNotAuthorized)
+		}
+		if !isBlePoweredOn {
+			try await withCheckedThrowingContinuation { c in
+				continuationQrCodeReady = c
+			}
+		}
+		startBleAdvertising()
+		return qrCodePayload!
+	}
+
+	func buildServices(uuid: String) {
+		let bleUserService = CBMutableService(type: CBUUID(string: uuid), primary: true)
+		stateCharacteristic = CBMutableCharacteristic(type: MdocServiceCharacteristic.state.uuid, properties: [.notify, .writeWithoutResponse], value: nil, permissions: [.writeable])
+		let client2ServerCharacteristic = CBMutableCharacteristic(type: MdocServiceCharacteristic.client2Server.uuid, properties: [.writeWithoutResponse], value: nil, permissions: [.writeable])
+		server2ClientCharacteristic = CBMutableCharacteristic(type: MdocServiceCharacteristic.server2Client.uuid, properties: [.notify], value: nil, permissions: [])
+		bleUserService.characteristics = [stateCharacteristic, client2ServerCharacteristic, server2ClientCharacteristic]
+		peripheralManager.removeAllServices()
+		peripheralManager.add(bleUserService)
+	}
+
+	func startBleAdvertising() {
+		guard !isPreview && !isInErrorState else {
+			logger.info("Current status is \(status)")
+			return
+		}
+		if peripheralManager.state == .poweredOn {
+			logger.info("Peripheral manager powered on")
+			error = nil
+			guard let uuid = deviceEngagement?.ble_uuid else {
+				logger.error("BLE initialization error")
+				return
+			}
+			buildServices(uuid: uuid)
+			let advertisementData: [String: Any] = [ CBAdvertisementDataServiceUUIDsKey: [CBUUID(string: uuid)], CBAdvertisementDataLocalNameKey: uuid ]
+			// advertise the peripheral with the short UUID
+			peripheralManager.startAdvertising(advertisementData)
+			advertising = true
+			status = .qrEngagementReady
+		} else {
+		// once bt is powered on, advertise
+		if peripheralManager.state == .resetting {
+			DispatchQueue.main.asyncAfter(deadline: .now()+1) {
+				self.startBleAdvertising()
+			}
+		} else {
+			logger.info("Peripheral manager powered off")
+		}
+		}
+	}
+
+	public func stop() {
+		guard !isPreview else {
+			return
+		}
+		if let peripheralManager, peripheralManager.isAdvertising {
+			peripheralManager.stopAdvertising()
+		}
+		qrCodePayload = nil
+		advertising = false
+		subscribeCount = 0
+		if let pk = deviceEngagement?.privateKey {
+			Task { @MainActor in
+				try? await pk.secureArea.deleteKeyBatch(id: pk.privateKeyId, startIndex: 0, batchSize: 1)
+				deviceEngagement?.privateKey = nil
+			}
+		}
+		if status == .error && initSuccess {
+			status = .initializing
+		}
+	}
+
+	fileprivate func initPeripheralManager() {
+		guard peripheralManager == nil else {
+			return
+		}
+		bleDelegate = Delegate(server: self)
+		logger.info("Initializing BLE peripheral manager")
+		peripheralManager = CBPeripheralManager(delegate: bleDelegate, queue: nil)
+		subscribeCount = 0
+	}
+
+	func handleStatusChange(_ newValue: TransferStatus) async {
+		guard !isPreview && !isInErrorState else {
+			return
+		}
+		logger.log(level: .info, "Transfer status will change to \(newValue)")
+		delegate?.didChangeStatus(newValue)
+		if newValue == .requestReceived {
+			peripheralManager.stopAdvertising()
+			delegate?.didReceiveRequest(readBuffer)
+		}
+		else if newValue == .initialized {
+			initPeripheralManager()
+		} else if newValue == .disconnected && status != .disconnected {
+			stop()
+		}
+	}
+
+	var isPreview: Bool {
+		ProcessInfo.processInfo.environment["XCODE_RUNNING_FOR_PREVIEWS"] == "1"
+	}
+
+	var isInErrorState: Bool { status == .error }
+
+	func handleErrorSet(_ newValue: Error?) {
+		guard let newValue else {
+			return
+		}
+		status = .error
+		delegate?.didFinishedWithError(newValue)
+		logger.log(level: .error, "Transfer error \(newValue) (\(newValue.localizedDescription)")
+	}
+
+	func prepareDataToSend(_ msg: Data) {
+		let mbs = min(511, remoteCentral.maximumUpdateValueLength-1)
+		numBlocks = MdocHelpers.CountNumBlocks(dataLength: msg.count, maxBlockSize: mbs)
+		logger.info("Sending response of total bytes \(msg.count) in \(numBlocks) blocks and block size: \(mbs)")
+		sendBuffer.removeAll()
+		// send blocks
+		for i in 0..<numBlocks {
+			let (block,bEnd) = MdocHelpers.CreateBlockCommand(data: msg, blockId: i, maxBlockSize: mbs)
+			var blockWithHeader = Data()
+			blockWithHeader.append(contentsOf: !bEnd ? BleTransferMode.START_DATA : BleTransferMode.END_DATA)
+			// send actual data after header
+			blockWithHeader.append(contentsOf: block)
+			sendBuffer.append(blockWithHeader)
+		}
+	}
+
+	func sendDataWithUpdates() {
+		guard !isPreview else {
+			return
+		}
+		guard sendBuffer.count > 0 else {
+			status = .responseSent
+			logger.info("Finished sending BLE data")
+			stop()
+			return
+		}
+		let b = peripheralManager.updateValue(sendBuffer.first!, for: server2ClientCharacteristic, onSubscribedCentrals: [remoteCentral])
+		if b, sendBuffer.count > 0 {
+			sendBuffer.removeFirst()
+			sendDataWithUpdates()
+		}
+	}
+    
+    func sendDeviceResponse(deviceResponse: Data) {
+        self.prepareDataToSend(deviceResponse)
+        self.sendDataWithUpdates()
+    }
+}
+

package/ios/eudi/BLETransfer/MdocOfflineDelegate.swift

@@ -0,0 +1,15 @@
+//
+//  MdocOfflineHandler.swift
+
+import Foundation
+import MdocDataModel18013
+import MdocSecurity18013
+
+/// delegate protocol for clients of the mdoc offline transfer manager
+public protocol MdocOfflineDelegate: AnyObject {
+	func didChangeStatus(_ newStatus: TransferStatus)
+	func didFinishedWithError(_ error: Error)
+	func didReceiveRequest(_ deviceRequest: Data)
+}
+
+

package/ios/eudi/BLETransfer/ServiceCharacteristics.swift

@@ -0,0 +1,48 @@
+/*
+Copyright (c) 2023 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.
+*/
+
+//  ServiceDefinition.swift
+import Foundation
+import CoreBluetooth
+import SwiftCBOR
+
+/// The enum BleTransferMode defines the two roles in the communication, which can be a server or a client.
+///
+/// The four static variables are used to signal the start and the end of the communication. This is done by sending the bytes 0x01 and 0x02 for the start and end of the communication, respectively. For the start and end of the data transmission, the bytes 0x01 and 0x00 are used.
+public enum BleTransferMode: Sendable {
+	case server
+	case client
+	// signals for coordination
+	static let START_REQUEST: [UInt8] = [0x01]
+	static let END_REQUEST: [UInt8] = [0x02]
+	static let START_DATA: [UInt8] = [0x01]
+	static let END_DATA: [UInt8] = [0x00]
+	public static let BASE_UUID_SUFFIX_SERVICE = "-0000-1000-8000-00805F9B34FB"
+	public static let QRHandover = CBOR.null
+}
+
+/// mdoc service characteristic definitions (mdoc is the GATT server)
+public enum MdocServiceCharacteristic: String, Sendable {
+	case state = "00000001-A123-48CE-896B-4C76973373E6"
+	case client2Server = "00000002-A123-48CE-896B-4C76973373E6"
+	case server2Client = "00000003-A123-48CE-896B-4C76973373E6"
+}
+
+extension MdocServiceCharacteristic {
+	init?(uuid: CBUUID) {	self.init(rawValue: uuid.uuidString.uppercased()) }
+	var uuid: CBUUID { CBUUID(string: rawValue) }
+}
+

package/ios/eudi/Enumerations.swift

@@ -0,0 +1,67 @@
+/*
+Copyright (c) 2023 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.
+*/
+
+//  TransferStatus.swift
+
+import Foundation
+
+/// Transfer status enumeration
+public enum TransferStatus: String, Sendable {
+	case initializing
+	case initialized
+	case qrEngagementReady
+	case connected
+	case started
+	case requestReceived
+	case userSelected
+	case responseSent
+	case disconnected
+	case error
+}
+
+public enum ErrorCode: Int, CustomStringConvertible, Sendable {
+	case documents_not_provided
+	case invalidInputDocument
+	case invalidUrl
+	case device_private_key_not_provided
+	case noDocumentToReturn
+	case userRejected
+	case requestDecodeError
+	case bleNotAuthorized
+	case bleNotSupported
+	case unexpected_error
+	case sessionEncryptionNotInitialized
+	case deviceEngagementMissing
+	case readerKeyMissing
+	
+	public var description: String {
+		switch self {
+		case .documents_not_provided: return "DOCUMENTS_NOT_PROVIDED"
+		case .invalidInputDocument: return "INVALID_INPUT_DOCUMENT"
+		case .invalidUrl: return "INVALID_URL"
+		case .device_private_key_not_provided: return "DEVICE_PRIVATE_KEY_NOT_PROVIDED"
+		case .noDocumentToReturn: return "NO_DOCUMENT_TO_RETURN"
+		case .requestDecodeError: return "REQUEST_DECODE_ERROR"
+		case .userRejected: return "USER_REJECTED"
+		case .bleNotAuthorized: return "BLE_NOT_AUTHORIZED"
+		case .bleNotSupported: return "BLE_NOT_SUPPORTED"
+		case .deviceEngagementMissing: return "DEVICE_ENGAGEMENT_MISSING"
+		case .readerKeyMissing: return "READER_KEY_MISSING"
+		case .sessionEncryptionNotInitialized: return "SESSION_ENCYPTION_NOT_INITIALIZED"
+		default: return "GENERIC_ERROR"
+		}
+	}
+}

package/ios/eudi/MdocDataTransfer18013.swift

@@ -0,0 +1,21 @@
+/*
+Copyright (c) 2023 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.
+*/
+
+// The Swift Programming Language
+// https://docs.swift.org/swift-book
+import Logging
+// abstract logger. By default writes to console
+let logger = Logger(label: "MdocDataTransfer18013")

package/ios/eudi/MdocHelpers.swift

@@ -0,0 +1,94 @@
+/*
+Copyright (c) 2023 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.
+*/
+
+//  Helpers.swift
+import Foundation
+//import CoreBluetooth
+//import Combine
+import MdocDataModel18013
+import MdocSecurity18013
+//import AVFoundation
+import SwiftCBOR
+import Logging
+
+/// Helper methods
+public class MdocHelpers {
+	
+	static var errorNoDocumentsDescriptionKey: String { "doctype_not_found" }
+	static func getErrorNoDocuments(_ docType: String) -> Error { NSError(domain: "\(MdocGattServer.self)", code: 0, userInfo: ["key": Self.errorNoDocumentsDescriptionKey, "%s": docType]) }
+	
+	public static func makeError(code: ErrorCode, str: String? = nil) -> NSError {
+		let errorMessage = str ?? NSLocalizedString(code.description, comment: code.description)
+		logger.error(Logger.Message(unicodeScalarLiteral: errorMessage))
+		return NSError(domain: "\(MdocGattServer.self)", code: code.rawValue, userInfo: [NSLocalizedDescriptionKey: errorMessage, "key": code.description])
+	}
+	
+	/// Get the session data to send to the reader. The session data is encrypted using the session encryption object
+	/// - Parameters:
+	///   - sessionEncryption: Instance of session encryption object
+	///   - status: Transfer status
+	///   - docToSend: Device response object to send
+	///
+	/// - Returns: A tuple containing the encrypted session data and the clear text data to send.
+	public static func getSessionDataToSend(sessionEncryption: SessionEncryption?, status: TransferStatus, docToSend: DeviceResponse) async -> Result<(Data, Data), Error> {
+		do {
+			guard var sessionEncryption else { logger.error("Session Encryption not initialized"); return .failure(Self.makeError(code: .sessionEncryptionNotInitialized)) }
+			if docToSend.documents == nil, status != .error { logger.error("Could not create documents to send") }
+			let cborToSend = docToSend.toCBOR(options: CBOROptions())
+			let clearBytesToSend = cborToSend.encode()
+			let cipherData = try await sessionEncryption.encrypt(clearBytesToSend)
+			let sd = SessionData(cipher_data: status == .error ? nil : cipherData, status: status == .error ? 11 : 20)
+			return .success((Data(sd.encode(options: CBOROptions())), Data(clearBytesToSend)))
+		} catch { return .failure(error) }
+	}
+	
+	/// Creates a block for a given block id from a data object. The block size is limited to maxBlockSize bytes.
+	/// - Parameters:
+	///   - data: The data object to be sent
+	///   - blockId: The id (number) of the block to be sent
+	///   - maxBlockSize: The maximum block size
+	/// - Returns: (chunk:The data block, bEnd: True if this is the last block, false otherwise)
+	public static func CreateBlockCommand(data: Data, blockId: Int, maxBlockSize: Int) -> (Data, Bool) {
+		let start = blockId * maxBlockSize
+		var end = (blockId+1) * maxBlockSize
+		var bEnd = false
+		if end >= data.count {
+			end = data.count
+			bEnd = true
+		}
+		let chunk = data.subdata(in: start..<end)
+		return (chunk,bEnd)
+	}
+	
+	/// Returns the number of blocks that dataLength bytes of data can be split into, given a maximum block size of maxBlockSize bytes.
+	/// - Parameters:
+	///   - dataLength: Length of data to be split
+	///   - maxBlockSize: The maximum block size
+	/// - Returns: Number of blocks
+	public static func CountNumBlocks(dataLength: Int, maxBlockSize: Int) -> Int {
+		let blockSize = maxBlockSize
+		var numBlocks = 0
+		if dataLength > maxBlockSize {
+			numBlocks = dataLength / blockSize;
+			if numBlocks * blockSize < dataLength {
+				numBlocks += 1
+			}
+		} else if dataLength > 0 {
+			numBlocks = 1
+		}
+		return numBlocks
+	}
+}

package/package.json

@@ -1,19 +1,12 @@
 {
   "name": "@animo-id/expo-mdoc-data-transfer",
-  "version": "0.1.5",
+  "version": "0.2.0-alpha.0",
   "description": "Expo mdoc data transfer module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "EXPO_NONINTERACTIVE=1 expo-module build && EXPO_NONINTERACTIVE=1 expo-module build plugin",
-    "style:check": "biome check --unsafe",
-    "style:fix": "pnpm style:check --write",
-    "types:check": "EXPO_NONINTERACTIVE=1 expo-module typecheck && EXPO_NONINTERACTIVE=1 expo-module plugin typecheck",
-    "release": "release-it"
-  },
   "keywords": [
     "react-native",
     "expo",
@@ -28,22 +21,27 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/animo/expo-mdoc-data-transfer#readme",
   "devDependencies": {
-    "@biomejs/biome": "1.9.3",
-    "@expo/config-types": "^51.0.3",
-    "@types/node": "^22.8.1",
+    "@expo/config-types": "^54.0.8",
+    "@types/node": "^24.10.0",
     "@types/react": "~18.2.79",
     "expo-module-scripts": "3.5.2",
     "expo-modules-core": "~1.12.26",
     "react-native": "0.75.3",
     "release-it": "^17.4.1",
-    "typescript": "~5.3.3"
+    "typescript": "~5.9.3"
   },
   "peerDependencies": {
     "expo": ">= 51",
-    "react-native": ">= 0.75",
-    "react": "*"
+    "react": "*",
+    "react-native": ">= 0.75"
   },
   "dependencies": {
-    "@expo/config-plugins": "^8.0.10"
+    "@expo/config-plugins": "^8.0.10",
+    "buffer": "^6.0.3"
+  },
+  "scripts": {
+    "build": "EXPO_NONINTERACTIVE=1 expo-module build && EXPO_NONINTERACTIVE=1 expo-module build plugin",
+    "types:check": "EXPO_NONINTERACTIVE=1 expo-module typecheck && EXPO_NONINTERACTIVE=1 expo-module plugin typecheck",
+    "release": "release-it"
   }
-}
+}

package/plugin/build/withAndroid.js

@@ -81,13 +81,13 @@ const withAndroidNfcProperties = (expoConfig) => (0, config_plugins_1.withAndroi
         });
     }
     for (const app of androidManifest.application ?? []) {
-        if (app.service?.some((s) => s.$['android:name'] === 'id.animo.mdocdatatransfer.NfcEngagementServiceImpl'))
+        if (app.service?.some((s) => s.$['android:name'] === 'id.animo.mdoc.datatransfer.NfcEngagementServiceImpl'))
             continue;
         app.service ??= [];
         app.service.push({
             $: {
                 'android:exported': 'true',
-                'android:name': 'id.animo.mdocdatatransfer.NfcEngagementServiceImpl',
+                'android:name': 'id.animo.mdoc.datatransfer.NfcEngagementServiceImpl',
                 'android:permission': 'android.permission.BIND_NFC_SERVICE',
             },
             'intent-filter': [
@@ -106,7 +106,7 @@ const withAndroidNfcProperties = (expoConfig) => (0, config_plugins_1.withAndroi
                     ],
                 },
             ],
-            // @ts-ignore
+            // @ts-expect-error
             'meta-data': {
                 $: {
                     'android:name': 'android.nfc.cardemulation.host_apdu_service',
@@ -117,10 +117,23 @@ const withAndroidNfcProperties = (expoConfig) => (0, config_plugins_1.withAndroi
     }
     return c;
 });
+const withAndroidFixMetaInfConflict = (expoConfig) => (0, config_plugins_1.withAppBuildGradle)(expoConfig, (c) => {
+    if (c.modResults.contents.includes('META-INF/versions/9/OSGI-INF/MANIFEST.MF')) {
+        return c;
+    }
+    c.modResults.contents = c.modResults.contents.replace(/android\s?{/, `android {
+        packagingOptions {
+          resources {
+            excludes += "META-INF/versions/9/OSGI-INF/MANIFEST.MF"
+          }
+        }`);
+    return c;
+});
 const withAndroid = (config) => (0, config_plugins_1.withPlugins)(config, [
     (c) => config_plugins_1.AndroidConfig.Permissions.withPermissions(c, ['android.permission.BLUETOOTH_CONNECT']),
     withBleAndroidManifest,
     withAndroidExcludeBcProv,
     withAndroidNfcProperties,
+    withAndroidFixMetaInfConflict,
 ]);
 exports.withAndroid = withAndroid;

package/plugin/src/index.ts

@@ -0,0 +1,16 @@
+import { type ConfigPlugin, createRunOncePlugin, withPlugins } from '@expo/config-plugins'
+
+import { withAndroid } from './withAndroid'
+import { withIos } from './withIos'
+
+export type Props = {
+  ios?: {
+    buildStatic?: Array<string>
+    bluetoothDescription?: string
+  }
+}
+
+const withMdocDataTransfer: ConfigPlugin<Props> = (config, props) =>
+  withPlugins(config, [withAndroid, [withIos, props]])
+
+export default createRunOncePlugin(withMdocDataTransfer, '@animo-id/mdoc-data-transfer')