@myazahq/kyc-sdk-react-native 2.0.2 → 2.2.0

package/android/src/main/java/com/margelo/nitro/myazakyc/HybridMyazaFaceDetector.kt

@@ -45,6 +45,10 @@ class HybridMyazaFaceDetector : HybridMyazaFaceDetectorSpec() {
     // frame → CameraX ImageProxy → the underlying android.media.Image for ML Kit.
     val proxy: ImageProxy = (frame as? NativeFrame)?.image ?: return noFace(128.0)
     val brightness = averageLuma(proxy)
+    // Mean RGB of the face region, for flash (screen-reflection) liveness.
+    // Taken in this same pass because the planes are already mapped — a second
+    // native module would walk the whole frame again for numbers available now.
+    val faceRgb = averageFaceRgb(proxy)
     val mediaImage = proxy.image ?: return noFace(brightness)
 
     val rotation = proxy.imageInfo.rotationDegrees
@@ -55,7 +59,9 @@ class HybridMyazaFaceDetector : HybridMyazaFaceDetectorSpec() {
     detector.process(input)
       .addOnSuccessListener { faces ->
         val face = faces.maxByOrNull { it.boundingBox.width() * it.boundingBox.height() }
-        result = face?.let { toResult(it, mediaImage.width, mediaImage.height, rotation, faces.size, brightness) }
+        result = face?.let {
+          toResult(it, mediaImage.width, mediaImage.height, rotation, faces.size, brightness, faceRgb)
+        }
         latch.countDown()
       }
       .addOnFailureListener { latch.countDown() }
@@ -71,11 +77,13 @@ class HybridMyazaFaceDetector : HybridMyazaFaceDetectorSpec() {
     rotation: Int,
     faceCount: Int,
     brightness: Double,
+    faceRgb: Triple<Double, Double, Double>,
   ): FaceResult {
     // After rotation the frame is upright; when rotated 90/270 the stored width/
     // height are swapped, so the smaller dimension is the upright "width".
     val frameWidth = if (rotation == 90 || rotation == 270) imageHeight else imageWidth
     val ratio = (face.boundingBox.width().toDouble() / frameWidth).coerceIn(0.0, 1.0)
+    val frameHeight = if (rotation == 90 || rotation == 270) imageWidth else imageHeight
     return FaceResult(
       headEulerAngleX = face.headEulerAngleX.toDouble(),
       headEulerAngleY = face.headEulerAngleY.toDouble(),
@@ -86,9 +94,82 @@ class HybridMyazaFaceDetector : HybridMyazaFaceDetectorSpec() {
       faceSizeRatio = ratio,
       faceCount = faceCount.toDouble(),
       brightness = brightness,
+      // Face centre, so the TS continuity guard can tell "the same face moved"
+      // from "a different face appeared" — size alone cannot, since two people
+      // at the same distance measure alike.
+      faceCenterX = (face.boundingBox.exactCenterX().toDouble() / frameWidth).coerceIn(0.0, 1.0),
+      faceCenterY = (face.boundingBox.exactCenterY().toDouble() / frameHeight).coerceIn(0.0, 1.0),
+      // ML Kit's per-face id, stable while it follows the SAME face. A change is
+      // PROOF of a different face — something Vision cannot report on iOS — so
+      // it strengthens the geometric guard rather than replacing it.
+      trackingId = (face.trackingId ?: -1).toDouble(),
+      faceR = faceRgb.first,
+      faceG = faceRgb.second,
+      faceB = faceRgb.third,
     )
   }
 
+  /**
+   * Mean RGB (0–255 each) of the centre crop, where the positioning gate has
+   * already put the face. Flash liveness measures how that patch of skin
+   * reflects each emitted colour.
+   *
+   * The crop matches the web and iOS SDKs (centre 40% × 50%) so all three — and
+   * the server's re-analysis of the recorded video — measure the same region.
+   * Sampled from the raw YUV planes rather than converting the frame: a full
+   * colour conversion per frame would cost far more than the ~1k samples taken
+   * here.
+   */
+  private fun averageFaceRgb(image: ImageProxy): Triple<Double, Double, Double> {
+    val yPlane = image.planes.getOrNull(0) ?: return Triple(-1.0, -1.0, -1.0)
+    val uPlane = image.planes.getOrNull(1) ?: return Triple(-1.0, -1.0, -1.0)
+    val vPlane = image.planes.getOrNull(2) ?: return Triple(-1.0, -1.0, -1.0)
+    val w = image.width
+    val h = image.height
+    if (w <= 0 || h <= 0) return Triple(-1.0, -1.0, -1.0)
+
+    val x0 = (w * 0.3).toInt()
+    val x1 = (w * 0.7).toInt()
+    val y0 = (h * 0.25).toInt()
+    val y1 = (h * 0.75).toInt()
+    val stepX = maxOf(1, (x1 - x0) / 32)
+    val stepY = maxOf(1, (y1 - y0) / 32)
+
+    val yBuf = yPlane.buffer
+    val uBuf = uPlane.buffer
+    val vBuf = vPlane.buffer
+    var rs = 0.0
+    var gs = 0.0
+    var bs = 0.0
+    var count = 0
+
+    var y = y0
+    while (y < y1) {
+      var x = x0
+      while (x < x1) {
+        val yIdx = y * yPlane.rowStride + x * yPlane.pixelStride
+        // Chroma is quarter-resolution on 4:2:0, hence the halved coordinates.
+        val cIdx = (y / 2) * uPlane.rowStride + (x / 2) * uPlane.pixelStride
+        val vIdx = (y / 2) * vPlane.rowStride + (x / 2) * vPlane.pixelStride
+        if (yIdx < yBuf.limit() && cIdx < uBuf.limit() && vIdx < vBuf.limit()) {
+          val luma = (yBuf.get(yIdx).toInt() and 0xFF).toDouble()
+          val cb = (uBuf.get(cIdx).toInt() and 0xFF) - 128.0
+          val cr = (vBuf.get(vIdx).toInt() and 0xFF) - 128.0
+          rs += luma + 1.402 * cr
+          gs += luma - 0.344136 * cb - 0.714136 * cr
+          bs += luma + 1.772 * cb
+          count++
+        }
+        x += stepX
+      }
+      y += stepY
+    }
+
+    if (count == 0) return Triple(-1.0, -1.0, -1.0)
+    fun clamp(v: Double) = (v / count).coerceIn(0.0, 255.0)
+    return Triple(clamp(rs), clamp(gs), clamp(bs))
+  }
+
   /** Mean luma (0–255) sampled on a coarse ~64×48 grid from the Y plane. */
   private fun averageLuma(image: ImageProxy): Double {
     val plane = image.planes.getOrNull(0) ?: return 128.0
@@ -130,5 +211,11 @@ class HybridMyazaFaceDetector : HybridMyazaFaceDetectorSpec() {
     faceSizeRatio = 0.0,
     faceCount = 0.0,
     brightness = brightness,
+    faceCenterX = -1.0,
+    faceCenterY = -1.0,
+    trackingId = -1.0,
+    faceR = -1.0,
+    faceG = -1.0,
+    faceB = -1.0,
   )
 }

package/android/src/main/java/com/margelo/nitro/myazakyc/HybridMyazaRectDetector.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro.myazakyc
+
+import com.margelo.nitro.camera.HybridFrameSpec
+
+/**
+ * Android half of document edge detection — deliberately a NO-OP.
+ *
+ * ML Kit has no frame-by-frame rectangle detector, and there is no honest way to
+ * fake one: a hand-rolled contour finder over camera frames would be slower than
+ * the text pass it sits beside and far less reliable, and a detector that
+ * reports a box it isn't sure about is worse than none, because auto-capture
+ * would shoot on it.
+ *
+ * So Android's auto-capture rides TEXT recognition alone. That is not a
+ * degraded path — the text gate answers framing (from the region the recognised
+ * text occupies) and identity (from the printed words) by itself on both
+ * platforms; iOS simply gets geometry as an extra corroborating signal.
+ *
+ * Reporting `found = false` is what makes the shared TypeScript gate fall back
+ * cleanly, with no platform branch at the call site.
+ */
+class HybridMyazaRectDetector : HybridMyazaRectDetectorSpec() {
+
+  override fun detectRect(frame: HybridFrameSpec): DetectedRect =
+    DetectedRect(
+      found = false,
+      x = 0.0,
+      y = 0.0,
+      width = 0.0,
+      height = 0.0,
+      aspect = 0.0,
+      confidence = 0.0,
+    )
+}

package/android/src/main/java/com/margelo/nitro/myazakyc/HybridMyazaTextRecognizer.kt

@@ -0,0 +1,118 @@
+package com.margelo.nitro.myazakyc
+
+import androidx.camera.core.ExperimentalGetImage
+import androidx.camera.core.ImageProxy
+import com.margelo.nitro.camera.HybridFrameSpec
+import com.margelo.nitro.camera.public.NativeFrame
+import android.net.Uri
+import com.google.mlkit.vision.common.InputImage
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.google.mlkit.vision.text.TextRecognition
+import com.google.mlkit.vision.text.TextRecognizer
+import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * Android half of on-device text recognition, implementing the nitrogen-generated
+ * `HybridMyazaTextRecognizerSpec` from src/specs/MyazaTextRecognizer.nitro.ts.
+ * The iOS half is HybridMyazaTextRecognizer.swift (Apple Vision).
+ *
+ * Used for reading the MRZ off a passport or ID card. Returns LINES only —
+ * parsing lives in TypeScript, where it is testable against the ICAO specimen
+ * without a device, and where the check digits do the actual deciding.
+ *
+ * Like the face detector, the Nitro worklet calls this synchronously, so ML
+ * Kit's async recogniser is awaited on the worklet thread with a short bound.
+ * Text recognition is heavier than face detection, hence the longer timeout —
+ * but it still returns empty rather than stalling the camera pipeline.
+ */
+class HybridMyazaTextRecognizer : HybridMyazaTextRecognizerSpec() {
+  private val recognizer: TextRecognizer =
+    TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+
+  @ExperimentalGetImage
+  override fun recognizeText(frame: HybridFrameSpec, bottomFraction: Double): TextResult {
+    val proxy: ImageProxy = (frame as? NativeFrame)?.image ?: return TextResult(emptyArray())
+    val mediaImage = proxy.image ?: return TextResult(emptyArray())
+
+    val rotation = proxy.imageInfo.rotationDegrees
+    val input = InputImage.fromMediaImage(mediaImage, rotation)
+
+    // The upright frame height: when rotated 90/270 the stored dimensions swap.
+    val uprightHeight = if (rotation == 90 || rotation == 270) mediaImage.width else mediaImage.height
+    val fraction = bottomFraction.coerceIn(0.05, 1.0)
+    // ML Kit has no region-of-interest, so the crop is applied to the RESULT:
+    // anything whose box sits above the band is page text, not MRZ. That still
+    // buys the important half of the benefit — the printed fields stop
+    // competing with the MRZ for the extractor's attention.
+    val cutoffY = uprightHeight * (1.0 - fraction)
+
+    var lines: Array<String> = emptyArray()
+    val latch = CountDownLatch(1)
+    recognizer.process(input)
+      .addOnSuccessListener { text ->
+        lines = text.textBlocks
+          .flatMap { it.lines }
+          .filter { line ->
+            val box = line.boundingBox
+            // A line with no box cannot be placed, so it is kept rather than
+            // dropped — the check digits will reject it if it is noise.
+            box == null || fraction >= 1.0 || box.centerY() >= cutoffY
+          }
+          // Top to bottom: the MRZ's rows must arrive adjacent and in order for
+          // the extractor's grouping to work.
+          .sortedBy { it.boundingBox?.centerY() ?: 0 }
+          .map { it.text }
+          .toTypedArray()
+        latch.countDown()
+      }
+      .addOnFailureListener { latch.countDown() }
+
+    // 2s, not the 400ms this shipped with. ML Kit runs full-frame latin
+    // recognition here (it has no ROI), which routinely takes longer than
+    // 400ms on mid-tier hardware — so the await expired and returned EMPTY,
+    // and auto-capture on Android almost never saw a single line of text.
+    // The frame processor drops frames while busy, so a longer wait costs
+    // fps, not a queue; an empty result costs the whole feature.
+    latch.await(2000, TimeUnit.MILLISECONDS)
+    return TextResult(lines)
+  }
+
+  override fun recognizeTextInImage(uri: String, bottomFraction: Double): Promise<TextResult> {
+    return Promise.async {
+      val ctx = NitroModules.applicationContext
+        ?: return@async TextResult(emptyArray())
+      // A still is already upright — unlike the live frame, which arrives
+      // rotated by the camera pipeline and needs the rotation passed in.
+      val input = runCatching { InputImage.fromFilePath(ctx, Uri.parse(uri)) }
+        .getOrNull() ?: return@async TextResult(emptyArray())
+
+      val fraction = bottomFraction.coerceIn(0.05, 1.0)
+      val cutoffY = input.height * (1.0 - fraction)
+
+      val latch = CountDownLatch(1)
+      var lines: Array<String> = emptyArray()
+      recognizer.process(input)
+        .addOnSuccessListener { text ->
+          lines = text.textBlocks
+            .flatMap { it.lines }
+            .filter { line ->
+              val box = line.boundingBox
+              box == null || fraction >= 1.0 || box.centerY() >= cutoffY
+            }
+            .sortedBy { it.boundingBox?.centerY() ?: 0 }
+            .map { it.text }
+            .toTypedArray()
+          latch.countDown()
+        }
+        .addOnFailureListener { latch.countDown() }
+
+      // A still can be large, so this is more generous than the per-frame path
+      // — it runs once, off the camera thread, and the user is already waiting.
+      latch.await(4, TimeUnit.SECONDS)
+      TextResult(lines)
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/myazakyc/Jp2Decoder.kt

@@ -0,0 +1,117 @@
+package com.margelo.nitro.myazakyc
+
+import android.graphics.Bitmap
+import jj2000.j2k.codestream.HeaderInfo
+import jj2000.j2k.codestream.reader.BitstreamReaderAgent
+import jj2000.j2k.codestream.reader.HeaderDecoder
+import jj2000.j2k.decoder.Decoder
+import jj2000.j2k.fileformat.reader.FileFormatReader
+import jj2000.j2k.image.DataBlkInt
+import jj2000.j2k.image.ImgDataConverter
+import jj2000.j2k.image.invcomptransf.InvCompTransf
+import jj2000.j2k.util.ISRandomAccessIO
+import jj2000.j2k.util.ParameterList
+import jj2000.j2k.wavelet.synthesis.InverseWT
+import java.io.ByteArrayInputStream
+
+/**
+ * JPEG 2000 → Bitmap, for the DG2 chip portrait.
+ *
+ * Android's BitmapFactory has NO JPEG 2000 decoder — on iOS ImageIO registers
+ * `public.jpeg-2000`, which is why the portrait always showed there and never
+ * here (the Flutter SDK documents the same asymmetry in dg2_image.dart). Since
+ * no platform API will ever decode it, the decoder is bundled: JJ2000, the
+ * JPEG 2000 reference implementation (pure Java, `edu.ucar:jj2000`), driven
+ * through the same header→bitstream→entropy→dequant→inverse-DWT→inverse-CT
+ * chain JMRTD's Android decoder uses.
+ *
+ * Null on ANY failure, including exotic codestreams (component subsampling) —
+ * the portrait is a courtesy and the caller falls back to the generic mark,
+ * exactly as it does today.
+ */
+internal object Jp2Decoder {
+
+  fun decode(bytes: ByteArray): Bitmap? =
+    try {
+      decodeUnsafe(bytes)
+    } catch (_: Throwable) {
+      null
+    }
+
+  private fun decodeUnsafe(bytes: ByteArray): Bitmap? {
+    val input = ISRandomAccessIO(ByteArrayInputStream(bytes), bytes.size, 1, bytes.size)
+
+    // The decoder's own defaults; JJ2000 refuses to run without a full list.
+    val defaults = ParameterList()
+    for (p in Decoder.getAllParameters()) if (p[3] != null) defaults[p[0]] = p[3]
+    val pl = ParameterList(defaults)
+
+    // DG2 stores either a bare codestream or the full JP2 container; the
+    // FileFormatReader tells them apart and finds the codestream box.
+    val ff = FileFormatReader(input)
+    ff.readFileFormat()
+    if (ff.JP2FFUsed) input.seek(ff.firstCodeStreamPos)
+
+    val hi = HeaderInfo()
+    val hd = HeaderDecoder(input, pl, hi)
+    val nComp = hd.numComps
+    if (nComp != 1 && nComp != 3) return null
+    val depth = IntArray(nComp) { hd.getOriginalBitDepth(it) }
+    val decSpec = hd.decoderSpecs
+
+    val reader = BitstreamReaderAgent.createInstance(input, hd, pl, decSpec, false, hi)
+    val entropy = hd.createEntropyDecoder(reader, pl)
+    val roi = hd.createROIDeScaler(entropy, pl, decSpec)
+    val dequant = hd.createDequantizer(roi, depth, decSpec)
+    val invWT = InverseWT.createInstance(dequant, decSpec)
+    invWT.setImgResLevel(reader.imgRes)
+    val converter = ImgDataConverter(invWT, 0)
+    val ict = InvCompTransf(converter, decSpec, depth, pl)
+
+    ict.setTile(0, 0)
+    val width = ict.imgWidth
+    val height = ict.imgHeight
+    if (width <= 0 || height <= 0 || width * height > 4_000_000) return null
+    // Subsampled components would need per-component upsampling; every real
+    // DG2 portrait observed is 4:4:4 or grayscale, so anything else bails to
+    // the caller's fallback rather than risking a garbled face.
+    for (c in 0 until nComp) {
+      if (ict.getCompImgWidth(c) != width || ict.getCompImgHeight(c) != height) return null
+    }
+
+    val channels = Array(nComp) { c ->
+      val blk = DataBlkInt(0, 0, width, height)
+      var out = ict.getInternCompData(blk, c) as DataBlkInt
+      // A progressive return means the data isn't final yet — ask again.
+      while (out.progressive) out = ict.getInternCompData(out, c) as DataBlkInt
+
+      val fixed = ict.getFixedPoint(c)
+      val shift = 1 shl (depth[c] - 1)
+      val max = (1 shl depth[c]) - 1
+      val plane = IntArray(width * height)
+      for (y in 0 until height) {
+        var src = out.offset + y * out.scanw
+        var dst = y * width
+        for (x in 0 until width) {
+          // Undo the fixed-point scaling, then the DC level shift, clamp to
+          // the component's range, and normalise to 8 bits.
+          var v = (out.data[src] shr fixed) + shift
+          if (v < 0) v = 0 else if (v > max) v = max
+          plane[dst] = if (max == 255) v else (v * 255) / max
+          src += 1
+          dst += 1
+        }
+      }
+      plane
+    }
+
+    val argb = IntArray(width * height)
+    val r = channels[0]
+    val g = if (nComp == 3) channels[1] else channels[0]
+    val b = if (nComp == 3) channels[2] else channels[0]
+    for (i in argb.indices) {
+      argb[i] = (0xFF shl 24) or (r[i] shl 16) or (g[i] shl 8) or b[i]
+    }
+    return Bitmap.createBitmap(argb, width, height, Bitmap.Config.ARGB_8888)
+  }
+}

package/app.plugin.js

@@ -1,28 +1,58 @@
-const { withInfoPlist, withAndroidManifest, createRunOncePlugin, AndroidConfig } = require('expo/config-plugins');
+const {
+  withInfoPlist,
+  withEntitlementsPlist,
+  withAndroidManifest,
+  createRunOncePlugin,
+  AndroidConfig,
+} = require('expo/config-plugins');
 
 const pkg = require('./package.json');
 
 // ---------------------------------------------------------------------------
 // Expo config plugin for @myazahq/kyc-sdk-react-native.
 //
-// The native face-detector frame-processor plugin (iOS Apple Vision / Android
-// ML Kit) is autolinked via expo-module.config.json (the podspec + the Android
-// Gradle project + MyazaFaceDetectorPackage). This config plugin only handles
-// the things that must be written into the HOST app's native config:
+// The native modules (face detector, text recogniser, eMRTD reader) autolink
+// via expo-module.config.json. This plugin only handles what must be written
+// into the HOST app's native config:
 //
-//   • iOS  — NSCameraUsageDescription (document scan + selfie liveness).
+//   • iOS  — NSCameraUsageDescription (document scan + selfie liveness), and,
+//            when NFC is enabled, NFCReaderUsageDescription plus the
+//            reader-session entitlements.
 //            NOTE: voice guidance is TTS OUTPUT only, so NO microphone usage
 //            string and no NSMicrophoneUsageDescription are added.
-//   • Android — CAMERA + INTERNET permissions.
+//   • Android — CAMERA + INTERNET, plus NFC when enabled.
 //
-// Camera *preview/capture* itself comes from react-native-vision-camera; add its
-// own config plugin too (it injects the VisionCamera frame-processor build flag).
-// This plugin is intentionally minimal and idempotent (createRunOncePlugin).
+// NFC is OPT-IN (`nfc: true`). The entitlement requires the App ID to carry the
+// "NFC Tag Reading" capability in the Apple Developer portal; adding it
+// unconditionally would break code-signing for every consumer who does not read
+// chips and has not enabled it.
+//
+// Camera preview/capture itself comes from react-native-vision-camera; add its
+// config plugin too. This one is intentionally minimal and idempotent.
 // ---------------------------------------------------------------------------
 
 const CAMERA_USAGE =
   'We use the camera to photograph your ID document and to capture a live selfie for identity verification.';
 
+const NFC_USAGE =
+  'We read the secure chip in your passport or ID card to confirm the document is genuine.';
+
+/**
+ * The eMRTD application identifier.
+ *
+ * iOS will not open an ISO-7816 session at all unless the AID the app intends
+ * to select is declared — an undeclared one fails at connect time with an error
+ * that says nothing about the cause.
+ */
+const EMRTD_AID = 'A0000002471001';
+
+/** Adds a value to a plist array, leaving any existing entries alone. */
+function addToList(container, key, value) {
+  const current = container[key];
+  const list = Array.isArray(current) ? current : [];
+  if (!list.includes(value)) container[key] = [...list, value];
+}
+
 function withIosCameraUsage(config, customMessage) {
   return withInfoPlist(config, (cfg) => {
     if (!cfg.modResults.NSCameraUsageDescription) {
@@ -32,11 +62,62 @@ function withIosCameraUsage(config, customMessage) {
   });
 }
 
-function withAndroidCameraPermissions(config) {
+const AID_KEY = 'com.apple.developer.nfc.readersession.iso7816.select-identifiers';
+const FORMATS_KEY = 'com.apple.developer.nfc.readersession.formats';
+
+/**
+ * Info.plist half of NFC. Exported so the split below can be tested without a
+ * device build — which is the only thing that caught it being wrong.
+ * @param {Record<string, unknown>} plist
+ */
+function applyNfcInfoPlist(plist, customMessage) {
+  if (!plist.NFCReaderUsageDescription) {
+    plist.NFCReaderUsageDescription = customMessage || NFC_USAGE;
+  }
+  // The AID list is an Info.plist key, NOT an entitlement — Apple documents it
+  // there, and the App ID's "NFC Tag Reading" capability covers only the
+  // formats entitlement. Adding it to the entitlements file as well fails the
+  // build outright: Xcode finds no matching capability to put in the profile
+  // and refuses to sign ("not found and could not be included in profile").
+  addToList(plist, AID_KEY, EMRTD_AID);
+  return plist;
+}
+
+/**
+ * Entitlements half of NFC.
+ * @param {Record<string, unknown>} plist
+ */
+function applyNfcEntitlements(plist) {
+  // 'TAG' is the raw ISO-7816 format a passport needs; 'NDEF' is a different
+  // capability entirely and does not cover it.
+  addToList(plist, FORMATS_KEY, 'TAG');
+  // Actively REMOVE the AID list from here. An earlier version of this plugin
+  // wrote it to the entitlements too, and prebuild MERGES into whatever
+  // entitlements file already exists — so without this, anyone who built once
+  // with that version keeps a key that makes signing fail forever, and
+  // re-running prebuild never clears it.
+  delete plist[AID_KEY];
+  return plist;
+}
+
+function withIosNfc(config, customMessage) {
+  config = withInfoPlist(config, (cfg) => {
+    applyNfcInfoPlist(cfg.modResults, customMessage);
+    return cfg;
+  });
+
+  return withEntitlementsPlist(config, (cfg) => {
+    applyNfcEntitlements(cfg.modResults);
+    return cfg;
+  });
+}
+
+function withAndroidPermissions(config, { nfc }) {
   return withAndroidManifest(config, (cfg) => {
     AndroidConfig.Permissions.ensurePermissions(cfg.modResults, [
       'android.permission.CAMERA',
       'android.permission.INTERNET',
+      ...(nfc ? ['android.permission.NFC'] : []),
     ]);
     return cfg;
   });
@@ -44,12 +125,20 @@ function withAndroidCameraPermissions(config) {
 
 /**
  * @param {object} config
- * @param {{ cameraPermission?: string }} [props]
+ * @param {{ cameraPermission?: string, nfc?: boolean, nfcPermission?: string }} [props]
  */
 function withMyazaKyc(config, props = {}) {
   config = withIosCameraUsage(config, props.cameraPermission);
-  config = withAndroidCameraPermissions(config);
+  config = withAndroidPermissions(config, { nfc: props.nfc === true });
+  if (props.nfc === true) {
+    config = withIosNfc(config, props.nfcPermission);
+  }
   return config;
 }
 
 module.exports = createRunOncePlugin(withMyazaKyc, pkg.name, pkg.version);
+// Named exports for the tests. The plugin itself stays the default export, so
+// consumers' app.json entries are unaffected.
+module.exports.applyNfcInfoPlist = applyNfcInfoPlist;
+module.exports.applyNfcEntitlements = applyNfcEntitlements;
+module.exports.EMRTD_AID = EMRTD_AID;