@myazahq/kyc-sdk-react-native 2.0.1 → 2.1.0

package/ios/HybridMyazaTextRecognizer.swift

@@ -0,0 +1,111 @@
+import Foundation
+import Vision
+import CoreImage
+import CoreMedia
+import CoreVideo
+import VisionCamera
+import NitroModules
+
+// ---------------------------------------------------------------------------
+// HybridMyazaTextRecognizer — the iOS half of on-device text recognition,
+// implementing the nitrogen-generated `HybridMyazaTextRecognizerSpec` from
+// src/specs/MyazaTextRecognizer.nitro.ts. The Android half is
+// HybridMyazaTextRecognizer.kt (Google ML Kit).
+//
+// 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.
+//
+// Two choices matter for MRZ specifically:
+//
+//   • `.accurate` recognition, not `.fast`. OCR-B at a glancing angle is
+//     exactly where fast mode invents characters, and one wrong character
+//     fails a check digit — costing a frame at best, and a wrong document
+//     number at worst.
+//   • Language correction OFF. It is trained on prose and would happily
+//     "correct" a passport's filler runs and surname into English words.
+// ---------------------------------------------------------------------------
+
+final class HybridMyazaTextRecognizer: HybridMyazaTextRecognizerSpec {
+
+  func recognizeText(frame: any HybridFrameSpec, bottomFraction: Double) throws -> TextResult {
+    guard
+      let nativeFrame = frame as? NativeFrame,
+      let sampleBuffer = nativeFrame.sampleBuffer,
+      let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer)
+    else {
+      return TextResult(lines: [])
+    }
+
+    let request = VNRecognizeTextRequest()
+    request.recognitionLevel = .accurate
+    request.usesLanguageCorrection = false
+    // The MRZ alphabet. Vision has no charset restriction, but naming Latin
+    // keeps it from trying scripts the document does not use.
+    request.recognitionLanguages = ["en-US"]
+
+    // Restrict recognition to the bottom slice, where the MRZ sits. Vision's
+    // regionOfInterest is in normalised, BOTTOM-LEFT-origin coordinates, so the
+    // bottom fraction of the image starts at y = 0.
+    let fraction = min(1.0, max(0.05, bottomFraction))
+    if fraction < 1.0 {
+      request.regionOfInterest = CGRect(x: 0, y: 0, width: 1, height: fraction)
+    }
+
+    // The camera delivers the buffer rotated 90° relative to how the document
+    // is held; `.right` puts the text upright for the recogniser. Reading it
+    // sideways does not fail loudly — it returns confident nonsense.
+    let handler = VNImageRequestHandler(
+      cvPixelBuffer: pixelBuffer, orientation: .right, options: [:]
+    )
+
+    do {
+      try handler.perform([request])
+    } catch {
+      return TextResult(lines: [])
+    }
+
+    guard let observations = request.results else { return TextResult(lines: []) }
+
+    // Top to bottom. Vision's y grows upward, so descending y IS reading order,
+    // and the MRZ's two lines have to arrive adjacent and in order for the
+    // extractor's grouping to work.
+    let ordered = observations.sorted { $0.boundingBox.midY > $1.boundingBox.midY }
+    let lines = ordered.compactMap { $0.topCandidates(1).first?.string }
+
+    return TextResult(lines: lines)
+  }
+
+  func recognizeTextInImage(uri: String, bottomFraction: Double) throws -> Promise<TextResult> {
+    Promise.async {
+      // A local file path, with or without the scheme — both forms reach here
+      // depending on which picker produced it.
+      let path = uri.hasPrefix("file://") ? String(uri.dropFirst(7)) : uri
+      guard let image = CIImage(contentsOf: URL(fileURLWithPath: path)) else {
+        return TextResult(lines: [])
+      }
+
+      let request = VNRecognizeTextRequest()
+      request.recognitionLevel = .accurate
+      request.usesLanguageCorrection = false
+
+      let fraction = min(1.0, max(0.05, bottomFraction))
+      if fraction < 1.0 {
+        request.regionOfInterest = CGRect(x: 0, y: 0, width: 1, height: fraction)
+      }
+
+      // A still from the photo library or camera roll is already upright, so no
+      // orientation correction here — unlike the live frame, which arrives
+      // rotated by the camera pipeline.
+      let handler = VNImageRequestHandler(ciImage: image, options: [:])
+      do {
+        try handler.perform([request])
+      } catch {
+        return TextResult(lines: [])
+      }
+
+      let ordered = (request.results ?? []).sorted { $0.boundingBox.midY > $1.boundingBox.midY }
+      return TextResult(lines: ordered.compactMap { $0.topCandidates(1).first?.string })
+    }
+  }
+}

package/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/nitrogen/generated/android/KycSdkReactNative+autolinking.cmake

@@ -0,0 +1,87 @@
+#
+# KycSdkReactNative+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/KycSdkReactNative+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_KYCSDKREACTNATIVE_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  KycSdkReactNative PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/KycSdkReactNativeOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridMyazaEmrtdSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMyazaFaceDetectorSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMyazaRectDetectorSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridMyazaTextRecognizerSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridMyazaEmrtdSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridMyazaFaceDetectorSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridMyazaRectDetectorSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridMyazaTextRecognizerSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  KycSdkReactNative PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        KycSdkReactNative
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        KycSdkReactNative
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        KycSdkReactNative
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/KycSdkReactNative+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// KycSdkReactNative+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/KycSdkReactNative+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 KycSdkReactNative is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/KycSdkReactNativeOnLoad.cpp

@@ -0,0 +1,102 @@
+///
+/// KycSdkReactNativeOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_KYCSDKREACTNATIVE_WITH_GENERATED_CMAKE_PROJECT
+#error KycSdkReactNativeOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "KycSdkReactNativeOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridMyazaEmrtdSpec.hpp"
+#include "JHybridMyazaFaceDetectorSpec.hpp"
+#include "JHybridMyazaRectDetectorSpec.hpp"
+#include "JHybridMyazaTextRecognizerSpec.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::myazakyc {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::myazakyc::registerAllNatives();
+  });
+}
+
+struct JHybridMyazaFaceDetectorSpecImpl: public jni::JavaClass<JHybridMyazaFaceDetectorSpecImpl, JHybridMyazaFaceDetectorSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/HybridMyazaFaceDetector;";
+  static std::shared_ptr<JHybridMyazaFaceDetectorSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridMyazaFaceDetectorSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMyazaFaceDetectorSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMyazaFaceDetectorSpec();
+  }
+};
+struct JHybridMyazaTextRecognizerSpecImpl: public jni::JavaClass<JHybridMyazaTextRecognizerSpecImpl, JHybridMyazaTextRecognizerSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/HybridMyazaTextRecognizer;";
+  static std::shared_ptr<JHybridMyazaTextRecognizerSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridMyazaTextRecognizerSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMyazaTextRecognizerSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMyazaTextRecognizerSpec();
+  }
+};
+struct JHybridMyazaEmrtdSpecImpl: public jni::JavaClass<JHybridMyazaEmrtdSpecImpl, JHybridMyazaEmrtdSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/HybridMyazaEmrtd;";
+  static std::shared_ptr<JHybridMyazaEmrtdSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridMyazaEmrtdSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMyazaEmrtdSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMyazaEmrtdSpec();
+  }
+};
+struct JHybridMyazaRectDetectorSpecImpl: public jni::JavaClass<JHybridMyazaRectDetectorSpecImpl, JHybridMyazaRectDetectorSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/HybridMyazaRectDetector;";
+  static std::shared_ptr<JHybridMyazaRectDetectorSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridMyazaRectDetectorSpecImpl::javaobject()>();
+    jni::local_ref<JHybridMyazaRectDetectorSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridMyazaRectDetectorSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::myazakyc;
+
+  // Register native JNI methods
+  margelo::nitro::myazakyc::JHybridMyazaEmrtdSpec::CxxPart::registerNatives();
+  margelo::nitro::myazakyc::JHybridMyazaFaceDetectorSpec::CxxPart::registerNatives();
+  margelo::nitro::myazakyc::JHybridMyazaRectDetectorSpec::CxxPart::registerNatives();
+  margelo::nitro::myazakyc::JHybridMyazaTextRecognizerSpec::CxxPart::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MyazaFaceDetector",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMyazaFaceDetectorSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MyazaTextRecognizer",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMyazaTextRecognizerSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MyazaEmrtd",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMyazaEmrtdSpecImpl::create();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MyazaRectDetector",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridMyazaRectDetectorSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::myazakyc

package/nitrogen/generated/android/KycSdkReactNativeOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// KycSdkReactNativeOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::myazakyc {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of KycSdkReactNative, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all KycSdkReactNative HybridObjects
+   *     margelo::nitro::myazakyc::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::myazakyc

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

@@ -0,0 +1,81 @@
+///
+/// JDetectedRect.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DetectedRect.hpp"
+
+
+
+namespace margelo::nitro::myazakyc {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DetectedRect" and the the Kotlin data class "DetectedRect".
+   */
+  struct JDetectedRect final: public jni::JavaClass<JDetectedRect> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/DetectedRect;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DetectedRect by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DetectedRect toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldFound = clazz->getField<jboolean>("found");
+      jboolean found = this->getFieldValue(fieldFound);
+      static const auto fieldX = clazz->getField<double>("x");
+      double x = this->getFieldValue(fieldX);
+      static const auto fieldY = clazz->getField<double>("y");
+      double y = this->getFieldValue(fieldY);
+      static const auto fieldWidth = clazz->getField<double>("width");
+      double width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<double>("height");
+      double height = this->getFieldValue(fieldHeight);
+      static const auto fieldAspect = clazz->getField<double>("aspect");
+      double aspect = this->getFieldValue(fieldAspect);
+      static const auto fieldConfidence = clazz->getField<double>("confidence");
+      double confidence = this->getFieldValue(fieldConfidence);
+      return DetectedRect(
+        static_cast<bool>(found),
+        x,
+        y,
+        width,
+        height,
+        aspect,
+        confidence
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDetectedRect::javaobject> fromCpp(const DetectedRect& value) {
+      using JSignature = JDetectedRect(jboolean, double, double, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.found,
+        value.x,
+        value.y,
+        value.width,
+        value.height,
+        value.aspect,
+        value.confidence
+      );
+    }
+  };
+
+} // namespace margelo::nitro::myazakyc

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

@@ -0,0 +1,61 @@
+///
+/// JEmrtdApduResponse.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "EmrtdApduResponse.hpp"
+
+#include <string>
+
+namespace margelo::nitro::myazakyc {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "EmrtdApduResponse" and the the Kotlin data class "EmrtdApduResponse".
+   */
+  struct JEmrtdApduResponse final: public jni::JavaClass<JEmrtdApduResponse> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/EmrtdApduResponse;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct EmrtdApduResponse by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    EmrtdApduResponse toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldData = clazz->getField<jni::JString>("data");
+      jni::local_ref<jni::JString> data = this->getFieldValue(fieldData);
+      static const auto fieldStatusWord = clazz->getField<double>("statusWord");
+      double statusWord = this->getFieldValue(fieldStatusWord);
+      return EmrtdApduResponse(
+        data->toStdString(),
+        statusWord
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JEmrtdApduResponse::javaobject> fromCpp(const EmrtdApduResponse& value) {
+      using JSignature = JEmrtdApduResponse(jni::alias_ref<jni::JString>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.data),
+        value.statusWord
+      );
+    }
+  };
+
+} // namespace margelo::nitro::myazakyc

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

@@ -0,0 +1,61 @@
+///
+/// JEmrtdTagInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "EmrtdTagInfo.hpp"
+
+#include <string>
+
+namespace margelo::nitro::myazakyc {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "EmrtdTagInfo" and the the Kotlin data class "EmrtdTagInfo".
+   */
+  struct JEmrtdTagInfo final: public jni::JavaClass<JEmrtdTagInfo> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/EmrtdTagInfo;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct EmrtdTagInfo by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    EmrtdTagInfo toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldConnected = clazz->getField<jboolean>("connected");
+      jboolean connected = this->getFieldValue(fieldConnected);
+      static const auto fieldUid = clazz->getField<jni::JString>("uid");
+      jni::local_ref<jni::JString> uid = this->getFieldValue(fieldUid);
+      return EmrtdTagInfo(
+        static_cast<bool>(connected),
+        uid->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JEmrtdTagInfo::javaobject> fromCpp(const EmrtdTagInfo& value) {
+      using JSignature = JEmrtdTagInfo(jboolean, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.connected,
+        jni::make_jstring(value.uid)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::myazakyc

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

@@ -0,0 +1,113 @@
+///
+/// JFaceResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "FaceResult.hpp"
+
+
+
+namespace margelo::nitro::myazakyc {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "FaceResult" and the the Kotlin data class "FaceResult".
+   */
+  struct JFaceResult final: public jni::JavaClass<JFaceResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/myazakyc/FaceResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct FaceResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    FaceResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldHeadEulerAngleX = clazz->getField<double>("headEulerAngleX");
+      double headEulerAngleX = this->getFieldValue(fieldHeadEulerAngleX);
+      static const auto fieldHeadEulerAngleY = clazz->getField<double>("headEulerAngleY");
+      double headEulerAngleY = this->getFieldValue(fieldHeadEulerAngleY);
+      static const auto fieldHeadEulerAngleZ = clazz->getField<double>("headEulerAngleZ");
+      double headEulerAngleZ = this->getFieldValue(fieldHeadEulerAngleZ);
+      static const auto fieldSmilingProbability = clazz->getField<double>("smilingProbability");
+      double smilingProbability = this->getFieldValue(fieldSmilingProbability);
+      static const auto fieldLeftEyeOpenProbability = clazz->getField<double>("leftEyeOpenProbability");
+      double leftEyeOpenProbability = this->getFieldValue(fieldLeftEyeOpenProbability);
+      static const auto fieldRightEyeOpenProbability = clazz->getField<double>("rightEyeOpenProbability");
+      double rightEyeOpenProbability = this->getFieldValue(fieldRightEyeOpenProbability);
+      static const auto fieldFaceSizeRatio = clazz->getField<double>("faceSizeRatio");
+      double faceSizeRatio = this->getFieldValue(fieldFaceSizeRatio);
+      static const auto fieldFaceCount = clazz->getField<double>("faceCount");
+      double faceCount = this->getFieldValue(fieldFaceCount);
+      static const auto fieldBrightness = clazz->getField<double>("brightness");
+      double brightness = this->getFieldValue(fieldBrightness);
+      static const auto fieldFaceCenterX = clazz->getField<double>("faceCenterX");
+      double faceCenterX = this->getFieldValue(fieldFaceCenterX);
+      static const auto fieldFaceCenterY = clazz->getField<double>("faceCenterY");
+      double faceCenterY = this->getFieldValue(fieldFaceCenterY);
+      static const auto fieldTrackingId = clazz->getField<double>("trackingId");
+      double trackingId = this->getFieldValue(fieldTrackingId);
+      static const auto fieldFaceR = clazz->getField<double>("faceR");
+      double faceR = this->getFieldValue(fieldFaceR);
+      static const auto fieldFaceG = clazz->getField<double>("faceG");
+      double faceG = this->getFieldValue(fieldFaceG);
+      static const auto fieldFaceB = clazz->getField<double>("faceB");
+      double faceB = this->getFieldValue(fieldFaceB);
+      return FaceResult(
+        headEulerAngleX,
+        headEulerAngleY,
+        headEulerAngleZ,
+        smilingProbability,
+        leftEyeOpenProbability,
+        rightEyeOpenProbability,
+        faceSizeRatio,
+        faceCount,
+        brightness,
+        faceCenterX,
+        faceCenterY,
+        trackingId,
+        faceR,
+        faceG,
+        faceB
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JFaceResult::javaobject> fromCpp(const FaceResult& value) {
+      using JSignature = JFaceResult(double, double, double, double, double, double, double, double, double, double, double, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.headEulerAngleX,
+        value.headEulerAngleY,
+        value.headEulerAngleZ,
+        value.smilingProbability,
+        value.leftEyeOpenProbability,
+        value.rightEyeOpenProbability,
+        value.faceSizeRatio,
+        value.faceCount,
+        value.brightness,
+        value.faceCenterX,
+        value.faceCenterY,
+        value.trackingId,
+        value.faceR,
+        value.faceG,
+        value.faceB
+      );
+    }
+  };
+
+} // namespace margelo::nitro::myazakyc