@myazahq/kyc-sdk-react-native 2.4.0 → 2.6.0

package/README.md

@@ -56,8 +56,11 @@ npx expo install @myazahq/kyc-sdk-react-native \
   react-native-safe-area-context react-native-svg
 ```
 
-Add the config plugins to `app.json`. The SDK's plugin adds the iOS camera usage
-string + Android `CAMERA`/`INTERNET` permissions; the VisionCamera plugin wires up
+Add the config plugins to `app.json`. The SDK's plugin adds the iOS camera and
+location usage strings + Android `CAMERA`/`INTERNET` and foreground location
+permissions (location backs the address-collection step's "Use my current
+location" and presence attestation; `["@myazahq/kyc-sdk-react-native",
+{ "location": false }]` opts out); the VisionCamera plugin wires up
 the camera + frame processors. Make sure the **New Architecture** is on (it is by
 default on Expo SDK 56):
 
@@ -82,8 +85,9 @@ npx expo run:ios                                  # iOS
 JAVA_HOME=/path/to/jdk-17 npx expo run:android    # Android — needs JDK 17
 ```
 
-> The SDK plugin accepts an optional custom camera prompt:
-> `["@myazahq/kyc-sdk-react-native", { "cameraPermission": "Your message…" }]`.
+> The SDK plugin accepts optional custom prompts:
+> `["@myazahq/kyc-sdk-react-native", { "cameraPermission": "Your message…",
+> "locationPermission": "Your message…" }]`.
 
 ### Bare React Native app (no Expo prebuild)
 
@@ -100,7 +104,8 @@ npm install @myazahq/kyc-sdk-react-native \
   react-native-worklets react-native-nitro-modules react-native-nitro-image \
   react-native-safe-area-context react-native-svg \
   expo expo-image-manipulator expo-image-picker expo-speech expo-font \
-  expo-glass-effect expo-application expo-crypto expo-device expo-localization
+  expo-glass-effect expo-application expo-crypto expo-device expo-localization \
+  expo-location
 
 # 3. iOS pods:
 cd ios && pod install && cd ..
@@ -113,11 +118,15 @@ prebuild):
   ```xml
   <key>NSCameraUsageDescription</key>
   <string>We use the camera to photograph your ID and capture a live selfie.</string>
+  <key>NSLocationWhenInUseUsageDescription</key>
+  <string>We use your location to confirm you are at the address you pin during verification.</string>
   ```
 - **Android** — add to `android/app/src/main/AndroidManifest.xml`:
   ```xml
   <uses-permission android:name="android.permission.CAMERA" />
   <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   ```
 - Ensure the **New Architecture** is enabled (`newArchEnabled=true` in
   `android/gradle.properties`; `RCT_NEW_ARCH_ENABLED=1` for the iOS Podfile install),
@@ -560,3 +569,140 @@ Full documentation, configuration options, and webhook setup: **[trust.myaza.co/
 ## License
 
 MIT © Flitstack Technologies Inc.
+
+## Presence reporting (Address Intelligence)
+
+When a workflow enables presence verification (`addressCollection.presence.enabled`),
+the SDK stores the confirmed pin on-device at capture. Call the reporter from your
+app on a natural moment (app open works well):
+
+```tsx
+import { reportAddressPresence, clearPresencePin } from '@myazahq/kyc-sdk-react-native';
+
+const result = await reportAddressPresence({
+  apiKey: 'pk_live_…',
+  externalUserId: 'user_42', // the same userId the KYC flow ran with
+});
+// result.reason: 'reported' | 'no_pin' | 'services_off' | 'no_fix' | 'outside_fence' | 'network_error'
+```
+
+It never throws and never blocks startup. The geofence is evaluated ON-DEVICE:
+only the derived record (calendar day + a night flag) is transmitted, never a
+coordinate. A fix outside the fence sends nothing (the server scores presence,
+never absence); a mock-location fix is reported flagged. `clearPresencePin`
+drops the stored pin (sign-out, or once the watch resolves).
+
+### Background monitoring (OS geofencing)
+
+The stronger tier: the OS wakes the SDK on fence crossings around the stored
+pin, app closed or not, so dwell and nights accrue with nobody in the loop.
+Entries stamp a timestamp; exits fold the dwell span into per-day aggregates
+and flush them. As with the foreground tier, only the derived day records
+ever leave the phone.
+
+Three opt-ins, each deliberate:
+
+1. Install the optional peer: `npx expo install expo-task-manager` (without
+   it the background tier simply does not exist — never a crash).
+2. Declare background location via the config plugin — this is what changes
+   your app's store review posture, so it is never a default:
+
+   ```json
+   ["@myazahq/kyc-sdk-react-native", { "location": "always" }]
+   ```
+
+3. Register the task at your app's ROOT module (before the component tree —
+   a task defined inside a component never fires headlessly), then enable:
+
+   ```tsx
+   // index.js
+   import { registerBackgroundPresence } from '@myazahq/kyc-sdk-react-native';
+   registerBackgroundPresence();
+
+   // later, after the KYC flow stored a pin:
+   const result = await enableBackgroundPresence({
+     apiKey: 'pk_live_…',
+     externalUserId: 'user_42',
+   });
+   // result.reason: 'enabled' | 'module_missing' | 'no_pin'
+   //              | 'foreground_denied' | 'background_denied' | 'start_failed'
+   ```
+
+`disableBackgroundPresence()` disarms the fence. A permission refusal leaves
+the foreground tier working exactly as before — the tiers degrade, never
+break.
+
+### The Android foreground service (reliability on OEM-managed phones)
+
+A geofence alone is not reliable on Android once a manufacturer's battery
+manager decides your app is idle: transitions are dropped, nothing says so,
+and the watch quietly lapses to inconclusive. The phones on that list (Tecno,
+Infinix, itel, Xiaomi, Oppo, Vivo) are the ones the market carries. A
+foreground service, with its persistent notification, is the one thing those
+managers leave alone — and OkHi's own integration guidance for the same
+markets is exactly this.
+
+Opt-in, Android only (iOS region monitoring is reliable on its own), on the
+same `location: "always"` plugin setting, which also declares the
+`FOREGROUND_SERVICE` and `FOREGROUND_SERVICE_LOCATION` permissions it needs.
+`registerBackgroundPresence()` at the root already defines its task; then:
+
+```tsx
+const result = await enableForegroundService({
+  apiKey: 'pk_live_…',
+  externalUserId: 'user_42',
+  notification: {
+    title: 'Address verification in progress', // shown in the status bar
+    body: 'Open the app to see your progress',
+    color: '#5645F5',
+  },
+});
+// result.reason: 'enabled' | 'unsupported_platform' | 'module_missing' | 'no_pin'
+//              | 'foreground_denied' | 'background_denied' | 'start_failed'
+```
+
+While it runs, a low-power fix every ten minutes (or hundred metres) is
+turned into the same enter/exit spans the geofence folds, on the same stored
+state, so the two never double-count a stay; the queue flushes while the
+process is alive; and a fence the OS dropped (a location toggle clears every
+registered fence) is re-armed. `disableForegroundService()` stops it and its
+notification. Word the notification honestly — it is on screen for days.
+
+### Which tier is running?
+
+Permissions get revoked in Settings and nothing tells the app. Ask:
+
+```tsx
+import { presenceStatus, openLocationSettings } from '@myazahq/kyc-sdk-react-native';
+
+const status = await presenceStatus('user_42');
+// status.tier: 'background' | 'foreground' | 'none'
+// plus pinStored, alwaysOn, locationServicesEnabled, both permission states,
+// geofenceArmed, foregroundServiceRunning
+if (!status.locationServicesEnabled) {
+  // The phone's location toggle is off: permission granted or not, no fix
+  // can be taken. Android deep-links to the toggle itself.
+  await openLocationSettings('services');
+} else if (status.tier === 'none' && status.pinStored) {
+  // The road back runs through Settings — no OS allows re-prompting in-app.
+  await openLocationSettings();
+}
+```
+
+### Showing the person where the check stands
+
+Somebody kept from a feature until their address is verified should be able
+to see the progress in your app, without a webhook relayed through your
+backend. The status endpoint is publishable-safe and enumeration-safe (an
+unknown user and a user with no watch answer the same `not_started` shape):
+
+```ts
+const res = await fetch(`${serverUrl}/api/kyc/address/presence/${externalUserId}`, {
+  headers: { Authorization: `Bearer pk_live_…` },
+});
+const { status, progress, tier } = await res.json();
+// status: 'not_started' | 'in_progress' | 'verified' | 'failed' | 'inconclusive' | 'expired' | 'revoked'
+// progress.score: 0..1 on WEIGHTED evidence (five foreground nights and three
+//                 geofence nights both read 1); nightsObserved/daysObserved beside it
+// tier: 'background' | 'foreground' | null — what is actually feeding it
+```

package/android/build.gradle

@@ -109,8 +109,40 @@ dependencies {
   // CameraX core — for the ImageProxy / ExperimentalGetImage APIs.
   compileOnly 'androidx.camera:camera-core:1.3.4'
 
-  // Google ML Kit face detection — Android only. Same version as the Flutter SDK.
-  implementation 'com.google.mlkit:face-detection:16.1.6'
-  // On-device text recognition, for reading the MRZ off a passport or ID card.
+  // ── ML Kit: models fetched on demand by default ──────────────────────────
+  //
+  // Two variants of the same API exist. The `com.google.mlkit:*` artifacts embed
+  // the models in the APK; the `com.google.android.gms:play-services-mlkit-*`
+  // ones fetch them through Google Play Services on first use.
+  //
+  // Measured on a real integrator's release APK, the bundled pair cost
+  // **18.5 MB per device** (arm64: ocr_pipeline 10.55 MB + face_detector 7.95 MB)
+  // plus the .tflite files in assets/, which ship to EVERY device because assets
+  // are not split by ABI. Unbundled, that is ~0.4 MB of shims.
+  //
+  // The trade-off is real and is why the flag exists: the unbundled variants need
+  // Google Play Services, so they do not work on Huawei or AOSP builds without
+  // GMS. An org shipping to those devices sets `myazaKycBundledMlKit = true` in
+  // its root build.gradle ext and gets today's fully-offline behaviour back.
+  //
+  // Availability is NOT inferred per frame — `isModelReady()` is checked once
+  // before the camera opens (see HybridMyazaFaceDetector.kt), because a missing
+  // model would otherwise be indistinguishable from "no face in frame".
+  if (safeExtGet('myazaKycBundledMlKit', false).toString().toBoolean()) {
+    implementation 'com.google.mlkit:face-detection:16.1.6'
+  } else {
+    implementation 'com.google.android.gms:play-services-mlkit-face-detection:17.1.0'
+  }
+
+  // Text recognition is STILL BUNDLED, deliberately, and it is the larger of the
+  // two (10.55 MB vs 7.95 MB on arm64) — so this is the bigger half of the win,
+  // deferred rather than abandoned.
+  //
+  // Unbundling it needs the same isModelReady()/prepareModel() contract the face
+  // detector just gained. Without that, a missing OCR model is indistinguishable
+  // from "no text in frame": document auto-capture would simply never fire and
+  // MRZ scanning would never produce a key for the chip read, with nothing shown
+  // to the user. Shipping the dependency swap ahead of the availability handling
+  // would trade 10 MB for a silent failure on every fresh install.
   implementation 'com.google.mlkit:text-recognition:16.0.1'
 }

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

@@ -9,6 +9,9 @@ import com.google.mlkit.vision.face.Face
 import com.google.mlkit.vision.face.FaceDetection
 import com.google.mlkit.vision.face.FaceDetector
 import com.google.mlkit.vision.face.FaceDetectorOptions
+import com.google.android.gms.common.moduleinstall.ModuleInstall
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 
@@ -39,6 +42,70 @@ class HybridMyazaFaceDetector : HybridMyazaFaceDetectorSpec() {
       .build(),
   )
 
+  // ── Model availability ───────────────────────────────────────────────────
+  //
+  // The default build fetches ML Kit's models through Play Services instead of
+  // bundling them (android/build.gradle), which is what keeps ~18.5 MB per
+  // device out of the APK. The cost is a window where detection cannot run:
+  // first launch before the download completes, or a device with no GMS at all.
+  //
+  // `detectFace` CANNOT report that. Its only channel is FaceResult, where a
+  // missing model and an empty frame are both `faceCount: 0` — so a user on a
+  // fresh install would watch "position your face" forever with nothing to
+  // explain it. Hence a separate, explicit contract, checked before the camera
+  // opens rather than inferred per frame.
+  //
+  // Cached rather than queried live: `areModulesAvailable` is asynchronous and
+  // `isModelReady` is a synchronous Nitro call, so blocking the worklet thread
+  // to answer it would be worse than the problem. The flag starts false and is
+  // set by prepareModel(), which the SDK primes at flow start.
+  @Volatile private var modelReady = false
+
+  override fun isModelReady(): Boolean = modelReady
+
+  override fun prepareModel(): Promise<Boolean> = Promise.async {
+    if (modelReady) return@async true
+
+    val ctx = NitroModules.applicationContext
+      ?: return@async false // No context — cannot ask Play Services anything.
+
+    val latch = CountDownLatch(1)
+    var ok = false
+    try {
+      val client = ModuleInstall.getClient(ctx)
+      // areModulesAvailable() answers "is it already here"; deferredInstall()
+      // asks Play Services to fetch it in the background if not. Requesting the
+      // install unconditionally is simpler AND correct — it is a no-op when the
+      // module is already present, and starting it early is the entire point.
+      client.areModulesAvailable(detector)
+        .addOnSuccessListener { response ->
+          ok = response.areModulesAvailable()
+          if (!ok) {
+            // `deferredInstall` takes the OptionalModuleApi itself, varargs.
+            // A ModuleInstallRequest belongs to `installModules`, which is the
+            // FOREGROUND install with its own progress listener — a different
+            // call, and the one this used to hand its request to, which is why
+            // the Android build stopped compiling.
+            client.deferredInstall(detector)
+          }
+          latch.countDown()
+        }
+        .addOnFailureListener {
+          // Thrown on devices without Google Play Services at all (Huawei, bare
+          // AOSP). Not an error to retry — it will never succeed on this device.
+          // Such orgs should build with `myazaKycBundledMlKit = true`.
+          ok = false
+          latch.countDown()
+        }
+      latch.await(MODEL_CHECK_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+    } catch (_: Throwable) {
+      ok = false
+    }
+
+    modelReady = ok
+    ok
+  }
+
   @ExperimentalGetImage
   override fun detectFace(frame: HybridFrameSpec): FaceResult {
     // Same access pattern as iOS (cast to the public NativeFrame): VisionCamera's
@@ -218,4 +285,14 @@ class HybridMyazaFaceDetector : HybridMyazaFaceDetectorSpec() {
     faceG = -1.0,
     faceB = -1.0,
   )
+
+  private companion object {
+    /**
+     * Bound on the availability query. It is a local Play Services call, not the
+     * model download — the download runs in the background afterwards. Generous
+     * enough for a cold Play Services process, short enough that a wedged one
+     * cannot stall flow start.
+     */
+    const val MODEL_CHECK_TIMEOUT_MS = 3_000L
+  }
 }

package/app.plugin.js

@@ -37,6 +37,9 @@ const CAMERA_USAGE =
 const NFC_USAGE =
   'We read the secure chip in your passport or ID card to confirm the document is genuine.';
 
+const LOCATION_USAGE =
+  'We use your location to confirm you are at the address you pin during verification.';
+
 /**
  * The eMRTD application identifier.
  *
@@ -62,6 +65,23 @@ function withIosCameraUsage(config, customMessage) {
   });
 }
 
+/**
+ * iOS location usage string, for the address-collection step's one-shot fix
+ * ("Use my current location" + the attest-presence claim). Written by DEFAULT
+ * because its ABSENCE is a crash: iOS kills an app that requests location
+ * without a usage string, and whether the step runs is decided by the org's
+ * WORKFLOW, not by anything the host app author can see at build time. An
+ * unused usage string costs nothing. `location: false` opts out.
+ */
+function withIosLocationUsage(config, customMessage) {
+  return withInfoPlist(config, (cfg) => {
+    if (!cfg.modResults.NSLocationWhenInUseUsageDescription) {
+      cfg.modResults.NSLocationWhenInUseUsageDescription = customMessage || LOCATION_USAGE;
+    }
+    return cfg;
+  });
+}
+
 const AID_KEY = 'com.apple.developer.nfc.readersession.iso7816.select-identifiers';
 const FORMATS_KEY = 'com.apple.developer.nfc.readersession.formats';
 
@@ -112,24 +132,84 @@ function withIosNfc(config, customMessage) {
   });
 }
 
-function withAndroidPermissions(config, { nfc }) {
+/**
+ * The Android permission list for a given set of opt-ins. Pure and exported
+ * so the tests can pin what `location: 'always'` declares — a permission
+ * that changes review posture must never arrive by accident.
+ */
+function androidPermissionsFor({ nfc, location, backgroundLocation }) {
+  return [
+    'android.permission.CAMERA',
+    'android.permission.INTERNET',
+    ...(nfc ? ['android.permission.NFC'] : []),
+    // Foreground location, for the address-collection step's one-shot fix.
+    ...(location
+      ? ['android.permission.ACCESS_COARSE_LOCATION', 'android.permission.ACCESS_FINE_LOCATION']
+      : []),
+    // The always-on presence tier (OkHi model, opt-in): OS geofencing needs
+    // the background grant, and Google Play reviews any app that declares
+    // it — which is why this is `location: 'always'` only, never a default.
+    // The foreground-service pair rides the same opt-in: FOREGROUND_SERVICE
+    // is a normal permission, and FOREGROUND_SERVICE_LOCATION (API 34+) is
+    // what lets expo-location's service declare the `location` type; Play
+    // reviews it under the same location declaration.
+    ...(backgroundLocation
+      ? [
+          'android.permission.ACCESS_BACKGROUND_LOCATION',
+          'android.permission.FOREGROUND_SERVICE',
+          'android.permission.FOREGROUND_SERVICE_LOCATION',
+        ]
+      : []),
+  ];
+}
+
+function withAndroidPermissions(config, opts) {
   return withAndroidManifest(config, (cfg) => {
-    AndroidConfig.Permissions.ensurePermissions(cfg.modResults, [
-      'android.permission.CAMERA',
-      'android.permission.INTERNET',
-      ...(nfc ? ['android.permission.NFC'] : []),
-    ]);
+    AndroidConfig.Permissions.ensurePermissions(cfg.modResults, androidPermissionsFor(opts));
+    return cfg;
+  });
+}
+
+/** iOS side of the always-on tier: the Always usage string plus the location
+ *  background mode, without which a geofence wake is refused. */
+function withIosBackgroundLocation(config, customMessage) {
+  return withInfoPlist(config, (cfg) => {
+    if (!cfg.modResults.NSLocationAlwaysAndWhenInUseUsageDescription) {
+      cfg.modResults.NSLocationAlwaysAndWhenInUseUsageDescription =
+        customMessage || LOCATION_USAGE;
+    }
+    const modes = Array.isArray(cfg.modResults.UIBackgroundModes)
+      ? cfg.modResults.UIBackgroundModes
+      : [];
+    if (!modes.includes('location')) modes.push('location');
+    cfg.modResults.UIBackgroundModes = modes;
     return cfg;
   });
 }
 
 /**
  * @param {object} config
- * @param {{ cameraPermission?: string, nfc?: boolean, nfcPermission?: string }} [props]
+ * @param {{ cameraPermission?: string, nfc?: boolean, nfcPermission?: string,
+ *           location?: boolean | 'always', locationPermission?: string }} [props]
  */
 function withMyazaKyc(config, props = {}) {
+  const location = props.location !== false;
+  // `location: 'always'` opts into the background presence tier. Explicit on
+  // purpose: it changes the app's Play/App Store review posture, so it must
+  // never arrive as a side effect of a default.
+  const backgroundLocation = props.location === 'always';
   config = withIosCameraUsage(config, props.cameraPermission);
-  config = withAndroidPermissions(config, { nfc: props.nfc === true });
+  config = withAndroidPermissions(config, {
+    nfc: props.nfc === true,
+    location,
+    backgroundLocation,
+  });
+  if (location) {
+    config = withIosLocationUsage(config, props.locationPermission);
+  }
+  if (backgroundLocation) {
+    config = withIosBackgroundLocation(config, props.locationPermission);
+  }
   if (props.nfc === true) {
     config = withIosNfc(config, props.nfcPermission);
   }
@@ -141,4 +221,5 @@ module.exports = createRunOncePlugin(withMyazaKyc, pkg.name, pkg.version);
 // consumers' app.json entries are unaffected.
 module.exports.applyNfcInfoPlist = applyNfcInfoPlist;
 module.exports.applyNfcEntitlements = applyNfcEntitlements;
+module.exports.androidPermissionsFor = androidPermissionsFor;
 module.exports.EMRTD_AID = EMRTD_AID;

package/ios/HybridMyazaFaceDetector.swift

@@ -28,6 +28,14 @@ import NitroModules
 // ---------------------------------------------------------------------------
 
 final class HybridMyazaFaceDetector: HybridMyazaFaceDetectorSpec {
+  // Apple Vision ships with the OS — there is no model to fetch, no Play
+  // Services equivalent, and no window in which detection is unavailable. These
+  // exist only because Android fetches ML Kit's models on demand; iOS answers
+  // "ready" unconditionally so the shared TS flow needs no platform branch.
+  func isModelReady() throws -> Bool { true }
+
+  func prepareModel() throws -> Promise<Bool> { Promise.resolved(withResult: true) }
+
   func detectFace(frame: any HybridFrameSpec) throws -> FaceResult {
     guard
       let nativeFrame = frame as? NativeFrame,
@@ -295,8 +303,13 @@ final class HybridMyazaFaceDetector: HybridMyazaFaceDetectorSpec {
     return min(max(v, 0.0), 1.0)
   }
 
-  /// Smile from outer-lip width relative to the face. Input band (0.40→0.50):
-  /// a neutral mouth sits near 0, a clear smile lands well above the threshold.
+  /// Smile from outer-lip width relative to the face box. Input band
+  /// (0.36→0.46): the shared detector passes above 0.5, so the pass line sits
+  /// at a lip width of 0.41 of the box. It was 0.40→0.50 (pass at 0.45), which
+  /// on device needed a full grin — a modest, natural smile never crossed it.
+  /// ML Kit on Android returns a classifier probability instead, so this band
+  /// is the iOS half of one shared threshold: tune it here, not in
+  /// detectSmile, or Android loosens with it.
   private static func smileProbability(_ landmarks: VNFaceLandmarks2D?) -> Double {
     guard let pts = landmarks?.outerLips?.normalizedPoints, pts.count >= 4 else {
       return 0.0
@@ -307,7 +320,7 @@ final class HybridMyazaFaceDetector: HybridMyazaFaceDetectorSpec {
       minX = min(minX, Double(p.x)); maxX = max(maxX, Double(p.x))
     }
     let width = maxX - minX
-    let score = (width - 0.40) / (0.50 - 0.40)
+    let score = (width - 0.36) / (0.46 - 0.36)
     return min(max(score, 0.0), 1.0)
   }
 

package/nitrogen/generated/android/c++/JHybridMyazaFaceDetectorSpec.cpp

@@ -14,6 +14,8 @@ namespace margelo::nitro::camera { class HybridFrameSpec; }
 
 #include "FaceResult.hpp"
 #include "JFaceResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
 #include <memory>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <VisionCamera/JHybridFrameSpec.hpp>
@@ -56,5 +58,26 @@ namespace margelo::nitro::myazakyc {
     auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
     return __result->toCpp();
   }
+  bool JHybridMyazaFaceDetectorSpec::isModelReady() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isModelReady");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::shared_ptr<Promise<bool>> JHybridMyazaFaceDetectorSpec::prepareModel() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("prepareModel");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::myazakyc

package/nitrogen/generated/android/c++/JHybridMyazaFaceDetectorSpec.hpp

@@ -55,6 +55,8 @@ namespace margelo::nitro::myazakyc {
   public:
     // Methods
     FaceResult detectFace(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
+    bool isModelReady() override;
+    std::shared_ptr<Promise<bool>> prepareModel() override;
 
   private:
     jni::global_ref<JHybridMyazaFaceDetectorSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/myazakyc/HybridMyazaFaceDetectorSpec.kt

@@ -11,6 +11,7 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.camera.HybridFrameSpec
+import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -32,6 +33,14 @@ abstract class HybridMyazaFaceDetectorSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun detectFace(frame: com.margelo.nitro.camera.HybridFrameSpec): FaceResult
+  
+  @DoNotStrip
+  @Keep
+  abstract fun isModelReady(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun prepareModel(): Promise<Boolean>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/ios/KycSdkReactNative-Swift-Cxx-Bridge.cpp

@@ -84,6 +84,14 @@ namespace margelo::nitro::myazakyc::bridge::swift {
     return margelo::nitro::camera::bridge::swift::get_std__shared_ptr_HybridFrameSpec_(cppType);
   }
   
+  // pragma MARK: std::function<void(bool /* result */)>
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = KycSdkReactNative::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridMyazaFaceDetectorSpec>
   std::shared_ptr<HybridMyazaFaceDetectorSpec> create_std__shared_ptr_HybridMyazaFaceDetectorSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     KycSdkReactNative::HybridMyazaFaceDetectorSpec_cxx swiftPart = KycSdkReactNative::HybridMyazaFaceDetectorSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/KycSdkReactNative-Swift-Cxx-Bridge.hpp

@@ -303,6 +303,40 @@ namespace margelo::nitro::myazakyc::bridge::swift {
   using std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>;
   inline std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ weakify_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
+  }
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(bool /* result */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
+    inline void call(bool result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridMyazaFaceDetectorSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridMyazaFaceDetectorSpec>`.
@@ -324,6 +358,15 @@ namespace margelo::nitro::myazakyc::bridge::swift {
     return Result<FaceResult>::withError(error);
   }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<HybridMyazaRectDetectorSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridMyazaRectDetectorSpec>`.