dynamsoft-capture-vision-react-native 1.1.16 → 2.4.2000-alpha.1

package/android/src/main/cpp/core/JsiCore.cpp

@@ -0,0 +1,284 @@
+//
+// Created by Allen on 24/08/26.
+//
+
+#include "JsiCore.h"
+
+JavaVM *gJvm = nullptr;
+
+jint JNI_OnLoad(JavaVM *vm, void *reserved) {
+    gJvm = vm;
+    JNIEnv *env = nullptr;
+    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
+        return -1;
+    }
+    return JNI_VERSION_1_6;
+}
+
+namespace jsiConversion::core {
+
+void jPointToJsObject(Runtime &rt, JNIEnv *env, jobject jPoint, Object &jsPoint) {
+    if (!jPoint) {
+        return;
+    }
+    jclass jclsPoint = env->FindClass("android/graphics/Point");
+    jfieldID x = env->GetFieldID(jclsPoint, "x", "I");
+    jfieldID y = env->GetFieldID(jclsPoint, "y", "I");
+    jsPoint.setProperty(rt, "x", env->GetIntField(jPoint, x));
+    jsPoint.setProperty(rt, "y", env->GetIntField(jPoint, y));
+    env->DeleteLocalRef(jclsPoint);
+}
+
+void jQuadToJsObject(Runtime &rt, JNIEnv *env, jobject jQuad, Object &jsQuad) {
+    if (!jQuad) {
+        return;
+    }
+    jclass jclsQuad = env->FindClass("com/dynamsoft/core/basic_structures/Quadrilateral");
+    jfieldID points = env->GetFieldID(jclsQuad, "points", "[Landroid/graphics/Point;");
+    auto jPoints = (jobjectArray) env->GetObjectField(jQuad, points);
+    if (!jPoints) {
+        jsQuad.setProperty(rt, "points", Value::undefined());
+    }
+    int count = env->GetArrayLength(jPoints);
+    Array pointArr(rt, count);
+    for (int i = 0; i < count; ++i) {
+        Object jsPoint(rt);
+        jobject jPoint = env->GetObjectArrayElement(jPoints, i);
+        jPointToJsObject(rt, env, jPoint, jsPoint);
+        pointArr.setValueAtIndex(rt, i, std::move(jsPoint));
+        env->DeleteLocalRef(jPoint);
+    }
+    jsQuad.setProperty(rt, "points", std::move(pointArr));
+    env->DeleteLocalRef(jclsQuad);
+}
+
+void jCapturedItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, int &outType, Object &jsItem) {
+    if (jItem == nullptr) {
+        return;
+    }
+    jclass clsCapturedResultItem = env->FindClass("com/dynamsoft/core/basic_structures/CapturedResultItem");
+    jmethodID getType = env->GetMethodID(clsCapturedResultItem, "getType", "()I");
+    jmethodID getTaskName = env->GetMethodID(clsCapturedResultItem, "getTaskName", "()Ljava/lang/String;");
+    jmethodID getTargetROIDefName = env->GetMethodID(clsCapturedResultItem, "getTargetROIDefName", "()Ljava/lang/String;");
+
+    outType = env->CallIntMethod(jItem, getType);
+    jsItem.setProperty(rt, "type", outType);
+    auto jTaskName = (jstring) env->CallObjectMethod(jItem, getTaskName);
+    auto jTargetROIDefName = (jstring) env->CallObjectMethod(jItem, getTargetROIDefName);
+    auto pTaskName = jTaskName ? env->GetStringUTFChars(jTaskName, nullptr) : "";
+    auto pTargetROIDefName = jTargetROIDefName ? env->GetStringUTFChars(jTargetROIDefName, nullptr) : "";
+    jsItem.setProperty(rt, "taskName", pTaskName);
+    jsItem.setProperty(rt, "targetROIDefName", pTargetROIDefName);
+    if (jTaskName) {
+        env->ReleaseStringUTFChars(jTaskName, pTaskName);
+        env->ReleaseStringUTFChars(jTargetROIDefName, pTargetROIDefName);
+    }
+    env->DeleteLocalRef(clsCapturedResultItem);
+
+}
+
+void jCapturedItemArrayToJsArray(Runtime &rt, JNIEnv *env, jobjectArray jItemArray, int *&outTypes, Array &jsItemArray) {
+    if (jItemArray == nullptr) {
+        return;
+    }
+    int count = env->GetArrayLength(jItemArray);
+    if (jsItemArray.size(rt) != count) {
+        jsItemArray = Array(rt, count);
+    }
+    outTypes = new int[count];
+    int outType = 0;
+    for (int i = 0; i < count; ++i) {
+        Object jsItem = Object(rt);
+        jobject jItem = env->GetObjectArrayElement(jItemArray, i);
+        jCapturedItemToJsObject(rt, env, jItem, outType, jsItem);
+        outTypes[i] = outType;
+        jsItemArray.setValueAtIndex(rt, i, std::move(jsItem));
+        env->DeleteLocalRef(jItem);
+    }
+}
+
+jobject getJImageDataFromHO(JNIEnv *env, const ImageDataHostObject &imageDataHO) {
+    jbyteArray jByteArr = nullptr;
+    if (imageDataHO.buffer != nullptr) {
+        jByteArr = env->NewByteArray((int) imageDataHO.bufferSize);
+        env->SetByteArrayRegion(jByteArr, 0, (int) imageDataHO.bufferSize, (jbyte *) imageDataHO.buffer);
+    }
+    env->PushLocalFrame(4);
+    jclass jclsImageData = env->FindClass("com/dynamsoft/core/basic_structures/ImageData");
+    jmethodID initImageData = env->GetMethodID(jclsImageData, "<init>", "([BIIIIILcom/dynamsoft/core/basic_structures/ImageTag;)V");
+    return env->PopLocalFrame(
+            env->NewObject(jclsImageData, initImageData,
+                           jByteArr, imageDataHO.width, imageDataHO.height, imageDataHO.stride,
+                           imageDataHO.format, imageDataHO.orientation, (jobject)nullptr)
+    );
+}
+
+void getHOFromJImageData(JNIEnv *env, jobject jImageData, ImageDataHostObject &imageHO) {
+    if (jImageData == nullptr) {
+        return;
+    }
+    env->PushLocalFrame(8);
+    jclass jclsImageData = env->FindClass("com/dynamsoft/core/basic_structures/ImageData");
+    jfieldID bytes = env->GetFieldID(jclsImageData, "bytes", "[B");
+    jfieldID width = env->GetFieldID(jclsImageData, "width", "I");
+    jfieldID height = env->GetFieldID(jclsImageData, "height", "I");
+    jfieldID stride = env->GetFieldID(jclsImageData, "stride", "I");
+    jfieldID orientation = env->GetFieldID(jclsImageData, "orientation", "I");
+    jfieldID format = env->GetFieldID(jclsImageData, "format", "I");
+
+    auto jbytes = (jbyteArray) env->GetObjectField(jImageData, bytes);
+    int bytesLength = 0;
+    if (jbytes != nullptr) {
+        bytesLength = env->GetArrayLength(jbytes);
+
+        //Don't delete this buffer.
+        //Put the responsibility of release to the user(Js-End).
+        imageHO.buffer = (uint8_t *)malloc(bytesLength * sizeof(uint8_t));
+        env->GetByteArrayRegion(jbytes, 0, bytesLength, (jbyte*)imageHO.buffer);
+    }
+    imageHO.bufferSize = bytesLength;
+    imageHO.width = (int) env->GetIntField(jImageData, width);
+    imageHO.height = (int) env->GetIntField(jImageData, height);
+    imageHO.stride = (int) env->GetIntField(jImageData, stride);
+    imageHO.format = (int) env->GetIntField(jImageData, format);
+    imageHO.orientation = (int) env->GetIntField(jImageData, orientation);
+    env->PopLocalFrame(nullptr);
+}
+
+} // namespace jsiConversion::core
+
+
+Value imageDataHOToBase64(ImageDataHostObject &imageDataHO, Runtime &rt) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+
+    auto cls = env->FindClass("com/dynamsoft/reactnative/basicutils/ImageUtilKt");
+    auto imageData2base64 = env->GetStaticMethodID(cls, "imageData2base64", "(Lcom/dynamsoft/core/basic_structures/ImageData;)Ljava/lang/String;");
+
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jBase64 = (jstring) env->CallStaticObjectMethod(cls, imageData2base64, jImageData);
+    auto pBase64 = jBase64 ? env->GetStringUTFChars(jBase64, nullptr) : "";
+    env->DeleteLocalRef(cls);
+    env->DeleteLocalRef(jImageData);
+    if (jBase64 != nullptr)
+        env->ReleaseStringUTFChars(jBase64, pBase64);
+    if (needDetach)
+        gJvm->DetachCurrentThread();
+    return String::createFromUtf8(rt, string(pBase64));
+}
+
+void addImageToBuffer(ImageDataHostObject &imageDataHO, string &nativeIsaId) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+
+    env->PushLocalFrame(4);
+    jclass clsIsaModuleImpl = env->FindClass("com/dynamsoft/reactnativelib/core/ImageSourceAdapterModuleImpl");
+    jmethodID getISA =env->GetStaticMethodID(clsIsaModuleImpl, "getISA", "(Ljava/lang/String;)Lcom/dynamsoft/core/basic_structures/ImageSourceAdapter;");
+    jobject jISA = env->CallStaticObjectMethod(clsIsaModuleImpl, getISA, env->NewStringUTF(nativeIsaId.c_str()));
+
+    if(!env->IsSameObject(jISA, nullptr)) {
+        auto clsISA = env->FindClass("com/dynamsoft/core/basic_structures/ImageSourceAdapter");
+        auto addImageToBuffer = env->GetMethodID(clsISA, "addImageToBuffer", "(Lcom/dynamsoft/core/basic_structures/ImageData;)V");
+        env->CallVoidMethod(jISA, addImageToBuffer, jsiConversion::core::getJImageDataFromHO(env, imageDataHO));
+    }
+    env->PopLocalFrame(nullptr);
+
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+}
+
+ImageDataHostObject getImage(string &nativeIsaId) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+
+    env->PushLocalFrame(4);
+    jclass clsIsaModuleImpl = env->FindClass("com/dynamsoft/reactnativelib/core/ImageSourceAdapterModuleImpl");
+    jmethodID getISA =env->GetStaticMethodID(clsIsaModuleImpl, "getISA", "(Ljava/lang/String;)Lcom/dynamsoft/core/basic_structures/ImageSourceAdapter;");
+    jobject jISA = env->CallStaticObjectMethod(clsIsaModuleImpl, getISA, env->NewStringUTF(nativeIsaId.c_str()));
+
+    ImageDataHostObject imageHO;
+    if(!env->IsSameObject(jISA, nullptr)) {
+        auto clsISA = env->FindClass("com/dynamsoft/core/basic_structures/ImageSourceAdapter");
+        auto getImage = env->GetMethodID(clsISA, "getImage", "()Lcom/dynamsoft/core/basic_structures/ImageData;");
+        auto jImageData = env->CallObjectMethod(jISA, getImage);
+        jsiConversion::core::getHOFromJImageData(env, jImageData, imageHO);
+    }
+    env->PopLocalFrame(nullptr);
+
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHO;
+}
+
+#include "../android_log.h"
+#define JSI_FUNC [](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value
+
+namespace jsi_install {
+void install_imageDataToBase64(Runtime &jsiRuntime) {
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, "imageDataToBase64")) {
+        auto nameId = PropNameID::forAscii(jsiRuntime, "imageDataToBase64");
+        auto imageDataToBase64Func = Function::createFromHostFunction(jsiRuntime, nameId, 1, JSI_FUNC {
+                auto obj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(obj));
+                return imageDataHOToBase64(imageDataHostObject, runtime);
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, imageDataToBase64Func);
+    }
+}
+namespace isa {
+void install_addImageToBuffer(Runtime &jsiRuntime) {
+    if(!jsiRuntime.global().hasProperty(jsiRuntime, "isaAddImageToBuffer")) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "isaAddImageToBuffer");
+        auto func = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
+                string nativeId = arguments[0].asString(runtime).utf8(runtime);
+                ImageDataHostObject imageDataHO = ImageDataHostObject::getHOFromObject(runtime, arguments[1].asObject(runtime));
+                addImageToBuffer(imageDataHO, nativeId);
+                return Value::undefined();
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameID, func);
+    }
+}
+void install_getImageData(Runtime &jsiRuntime) {
+    if(!jsiRuntime.global().hasProperty(jsiRuntime, "isaGetImageData")) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "isaGetImageData");
+        auto func = Function::createFromHostFunction(jsiRuntime, nameID, 1, JSI_FUNC {
+                string nativeId = arguments[0].asString(runtime).utf8(runtime);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(getImage(nativeId)));
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameID, func);
+    }
+}
+} // namespace isa
+} // namespace jsi_install
+
+void install_coreMethods(Runtime &jsiRuntime) {
+    jsi_install::install_imageDataToBase64(jsiRuntime);
+    jsi_install::isa::install_addImageToBuffer(jsiRuntime);
+    jsi_install::isa::install_getImageData(jsiRuntime);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_dynamsoft_reactnativelib_core_ImageSourceAdapterModuleImpl_nativeInstall(JNIEnv *env, jclass clz, jlong jsiPtr) {
+    auto runtime = reinterpret_cast<Runtime *>(jsiPtr);
+    if (runtime) {
+        install_coreMethods(*runtime);
+    }
+}

package/android/src/main/cpp/core/JsiCore.h

@@ -0,0 +1,51 @@
+//
+// Created by Allen on 24/08/26.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CORE_JSICORE_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CORE_JSICORE_H_
+
+#include "jsi/jsi.h"
+#include "ImageDataHostObject.h"
+#include <jni.h>
+#include <string>
+using namespace facebook::jsi;
+using namespace std;
+
+using namespace facebook::jsi;
+
+
+extern JavaVM *gJvm;
+
+
+
+
+
+namespace jsiConversion::core {
+
+void jPointToJsObject(Runtime &rt, JNIEnv *env, jobject jPoint, Object &jsPoint);
+void jQuadToJsObject(Runtime &rt, JNIEnv *env, jobject jQuad, Object &jsQuad);
+void jCapturedItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, int &outType, Object &jsItem);
+void jCapturedItemArrayToJsArray(Runtime &rt, JNIEnv *env, jobjectArray jItemArray, int *&outTypes, Array &jsItemArray);
+
+// ImageData: java object <--> jsi HostObject
+jobject getJImageDataFromHO(JNIEnv *env, const ImageDataHostObject &imageDataHO);
+void getHOFromJImageData(JNIEnv *env, jobject jImageData, ImageDataHostObject &imageHO);
+} // namespace jsiConversion::core
+
+
+
+Value imageDataHOToBase64(ImageDataHostObject &imageDataHO, Runtime &rt);
+
+void addImageToBuffer(ImageDataHostObject &imageDataHO, string &nativeIsaId);
+ImageDataHostObject getImage(string &nativeIsaId);
+
+namespace jsi_install {
+void install_imageDataToBase64(Runtime &jsiRuntime);
+namespace isa {
+void install_addImageToBuffer(Runtime &jsiRuntime);
+void install_getImageData(Runtime &jsiRuntime);
+} // namespace isa
+} // namespace jsi_install
+
+#endif // REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CORE_JSICORE_H_

package/android/src/main/cpp/cvr/JsiCvr.cpp

@@ -0,0 +1,263 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#include "JsiCvr.h"
+#include "../core/ImageDataHostObject.h"
+#include "../core/JsiCore.h"
+#include <jni.h>
+#define JSI_FUNC [](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value
+
+jobject jCvrModule;
+
+void install_cvrMethods(Runtime &runtime) {
+    jsi_install::cvr::install_captureImageData(runtime);
+    jsi_install::cvr::install_cvr_getOriginalImage(runtime);
+    jsi_install::cvr::install_getCurrentNormalizedImages(runtime);
+    jsi_install::cvr::install_captureFile(runtime);
+    jsi_install::cvr::install_captureFileBytes(runtime);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_dynamsoft_reactnativelib_cvr_CaptureVisionRouterModuleImpl_nativeInstall(JNIEnv *env, jobject thiz, jlong jsiPtr) {
+    if (!env->IsSameObject(jCvrModule, thiz)) {
+        jCvrModule = env->NewWeakGlobalRef(thiz);
+    }
+    auto runtime = reinterpret_cast<Runtime *>(jsiPtr);
+    if (runtime) {
+        install_cvrMethods(*runtime);
+    }
+}
+
+namespace jsiConversion::cvr {
+void jCapturedResultToJsiObject(Runtime &rt, JNIEnv *env, jobject jCapturedResult, Object &jsCapturedResult) {
+    env->PushLocalFrame(8);
+    jclass jclsCapturedResult = env->FindClass("com/dynamsoft/cvr/CapturedResult");
+    SET_STRING_PROPERTY_BY_FIELD(jclsCapturedResult, jCapturedResult, jsCapturedResult, originalImageHashId)
+    SET_STRING_PROPERTY_BY_FIELD(jclsCapturedResult, jCapturedResult, jsCapturedResult, errorMessage)
+
+    jfieldID errorCode = env->GetFieldID(jclsCapturedResult, "errorCode", "I");
+    jsCapturedResult.setProperty(rt, "errorCode", env->GetIntField(jCapturedResult, errorCode));
+
+    jfieldID items = env->GetFieldID(jclsCapturedResult, "items", "[Lcom/dynamsoft/core/basic_structures/CapturedResultItem;");
+    jobjectArray jItems = (jobjectArray) env->GetObjectField(jCapturedResult, items);
+    Array jsItemArray(rt, 0);
+    int *types;
+
+    jsiConversion::core::jCapturedItemArrayToJsArray(rt, env, jItems, types, jsItemArray);
+    for (int i = 0; i < jsItemArray.size(rt); ++i) {
+        Object jsItem = jsItemArray.getValueAtIndex(rt, i).asObject(rt);
+        jobject jItem = env->GetObjectArrayElement(jItems, i);
+        int type = types[i];
+        if (type == CRIT_BARCODE) {
+            jsiConversion::dbr::jBarcodeResultItemToJsObject(rt, env, jItem, jsItem);
+        } else if (type == CRIT_TEXT_LINE) {
+            jsiConversion::dlr::jTextLineResultItemToJsObject(rt, env, jItem, jsItem);
+        } else if (type == CRIT_DETECTED_QUAD) {
+            jsiConversion::ddn::jDetectedQuadResultItemToJsObject(rt, env, jItem, jsItem);
+        } else if (type == CRIT_NORMALIZED_IMAGE) {
+            jsiConversion::ddn::jNormalizedImageResultItemToJsObject(rt, env, jItem, jsItem);
+        } else if (type == CRIT_PARSED_RESULT) {
+            jsiConversion::dcp::jParsedResultItemToJsObject(rt, env, jItem, jsItem);
+        }
+        env->DeleteLocalRef(jItem);
+    }
+    delete types;
+    jsCapturedResult.setProperty(rt, "items", jsItemArray);
+    env->PopLocalFrame(nullptr);
+}
+}//namespace jsiConversion::cvr
+
+namespace jsi_install::cvr {
+void install_captureImageData(Runtime &jsiRuntime) {
+    auto nameId = PropNameID::forAscii(jsiRuntime, "captureImageData");
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+        auto captureImageDataFunc = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+            auto obj = arguments[0].asObject(runtime);
+            auto imgHO = ImageDataHostObject::getHOFromObject(runtime, std::move(obj));
+            Object jsCapturedResult = captureImageDataHO(imgHO, runtime, arguments[1].asString(runtime).utf8(runtime));
+            return jsCapturedResult;
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(captureImageDataFunc));
+    }
+}
+void install_captureFile(Runtime &jsiRuntime) {
+    auto nameId = PropNameID::forAscii(jsiRuntime, "captureFile");
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+        auto captureFileFunc = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+            auto filePath = arguments[0].asString(runtime);
+            Object jsCapturedResult = captureFile(filePath.utf8(runtime), runtime, arguments[1].asString(runtime).utf8(runtime));
+            return jsCapturedResult;
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(captureFileFunc));
+    }
+}
+void install_captureFileBytes(Runtime &jsiRuntime) {
+    auto nameId = PropNameID::forAscii(jsiRuntime, "captureFileBytes");
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+        auto captureFileBytesFunc = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+            ArrayBuffer fileBytes = arguments[0].asObject(runtime).getArrayBuffer(runtime);
+            Object jsCapturedResult = captureFileBytes(fileBytes, runtime, arguments[1].asString(runtime).utf8(runtime));
+            return jsCapturedResult;
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(captureFileBytesFunc));
+    }
+}
+void install_getCurrentNormalizedImages(Runtime &jsiRuntime) {
+    auto nameId = PropNameID::forAscii(jsiRuntime, "getCurrentNormalizedImages");
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+        auto getCurrentNormalizedImagesFunc = Function::createFromHostFunction(jsiRuntime, nameId, 0, JSI_FUNC {
+            Array images = getCurrentNormalizedImages(runtime);
+            return images;
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(getCurrentNormalizedImagesFunc));
+    }
+}
+void install_cvr_getOriginalImage(Runtime &jsiRuntime) {
+    auto nameId = PropNameID::forAscii(jsiRuntime, "cvr_getOriginalImage");
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+        auto cvr_getOriginalImageFunc = Function::createFromHostFunction(jsiRuntime, nameId, 1, JSI_FUNC {
+            string hashId = arguments[0].asString(runtime).utf8(runtime);
+            if (hashId.empty()) {
+                return {};
+            }
+            ImageDataHostObject imgHO = getOriginalImage(runtime, hashId);
+            if(imgHO.width == 0 && imgHO.height == 0) {
+                return {};
+            } else {
+                return Object::createFromHostObject(runtime, make_shared<ImageDataHostObject>(imgHO));
+            }
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(cvr_getOriginalImageFunc));
+    }
+}
+}//namespace jsi_install::cvr
+
+
+Object captureImageDataHO(ImageDataHostObject &imageDataHO, Runtime &rt, string templateName) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    auto clzCvrModule = env->GetObjectClass(jCvrModule);
+    auto captureMeth = env->GetMethodID(clzCvrModule, "captureImageDataCalledInJSI",
+                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;Ljava/lang/String;)Lcom/dynamsoft/cvr/CapturedResult;");
+    auto imageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jResult = env->CallObjectMethod(jCvrModule, captureMeth, imageData, env->NewStringUTF(templateName.c_str()));
+    Object jsResult(rt);
+    jsiConversion::cvr::jCapturedResultToJsiObject(rt, env, jResult, jsResult);
+    env->DeleteLocalRef(clzCvrModule);
+    env->DeleteLocalRef(imageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return jsResult;
+}
+
+Object captureFile(string filePath, Runtime &rt, string templateName) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    auto clzCvrModule = env->GetObjectClass(jCvrModule);
+    auto captureMeth = env->GetMethodID(clzCvrModule, "captureFileCalledInJSI",
+                                        "(Ljava/lang/String;Ljava/lang/String;)Lcom/dynamsoft/cvr/CapturedResult;");
+    auto jResult = env->CallObjectMethod(jCvrModule, captureMeth, env->NewStringUTF(filePath.c_str()), env->NewStringUTF(templateName.c_str()));
+    Object jsResult(rt);
+    jsiConversion::cvr::jCapturedResultToJsiObject(rt, env, jResult, jsResult);
+    env->DeleteLocalRef(clzCvrModule);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return jsResult;
+}
+Object captureFileBytes(ArrayBuffer &fileBytes, Runtime &rt, string templateName) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    auto clzCvrModule = env->GetObjectClass(jCvrModule);
+    auto captureMeth = env->GetMethodID(clzCvrModule, "captureFileBytesCalledInJSI",
+                                        "([BLjava/lang/String;)Lcom/dynamsoft/cvr/CapturedResult;");
+    auto pBytes = (jbyte *) fileBytes.data(rt);
+    int len = fileBytes.length(rt);
+    jbyteArray jBytes = env->NewByteArray(len);
+    env->SetByteArrayRegion(jBytes, 0, len, (jbyte *) pBytes);
+    auto jResult = env->CallObjectMethod(jCvrModule, captureMeth, jBytes, env->NewStringUTF(templateName.c_str()));
+    Object jsResult(rt);
+    jsiConversion::cvr::jCapturedResultToJsiObject(rt, env, jResult, jsResult);
+    env->DeleteLocalRef(clzCvrModule);
+    env->DeleteLocalRef(jBytes);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return jsResult;
+}
+
+Array getCurrentNormalizedImages(Runtime &runtime) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    auto clzCvrModule = env->GetObjectClass(jCvrModule);
+    auto fiCurrentImages = env->GetFieldID(clzCvrModule, "currentNormalizedImages", "[Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jCurrentImages = (jobjectArray) env->GetObjectField(jCvrModule, fiCurrentImages);
+    int count = jCurrentImages ? env->GetArrayLength(jCurrentImages) : 0;
+    Array array(runtime, count);
+    for (int i = 0; i < count; ++i) {
+        auto imageData = env->GetObjectArrayElement(jCurrentImages, i);
+        ImageDataHostObject imgHO;
+        jsiConversion::core::getHOFromJImageData(env, imageData, imgHO);
+        auto obj = Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imgHO));
+        array.setValueAtIndex(runtime, i, obj);
+        env->DeleteLocalRef(imageData);
+    }
+    env->DeleteLocalRef(clzCvrModule);
+    if (jCurrentImages) {
+        env->DeleteLocalRef(jCurrentImages);
+    }
+    jCurrentImages = nullptr;
+    env->SetObjectField(jCvrModule, fiCurrentImages, jCurrentImages);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return array;
+}
+
+ImageDataHostObject getOriginalImage(Runtime &runtime, string imageHashId) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    auto clzCvrModule = env->GetObjectClass(jCvrModule);
+    auto getOriginalImageCalledInJSI =
+            env->GetMethodID(clzCvrModule, "getOriginalImageCalledInJSI", "(Ljava/lang/String;)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = env->CallObjectMethod(jCvrModule, getOriginalImageCalledInJSI, env->NewStringUTF(imageHashId.c_str()));
+    ImageDataHostObject imgHO;
+    if (jImageData != nullptr) {
+        jsiConversion::core::getHOFromJImageData(env, jImageData, imgHO);
+        env->DeleteLocalRef(jImageData);
+    }
+    env->DeleteLocalRef(clzCvrModule);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imgHO;
+}
+

package/android/src/main/cpp/cvr/JsiCvr.h

@@ -0,0 +1,51 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CVR_JSICVR_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CVR_JSICVR_H_
+
+#include "jsi/jsi.h"
+#include "string"
+#include "../core/ImageDataHostObject.h"
+#include "../dbr/JsiDbr.h"
+#include "../dlr/JsiDlr.h"
+#include "../ddn/JsiDdn.h"
+#include "../dcp/JsiDcp.h"
+#include "jni.h"
+
+using namespace facebook::jsi;
+using namespace std;
+
+int CRIT_BARCODE = 1 << 1;
+int CRIT_TEXT_LINE = 1 << 2;
+int CRIT_DETECTED_QUAD = 1 << 3;
+int CRIT_NORMALIZED_IMAGE = 1 << 4;
+int CRIT_PARSED_RESULT = 1 << 5;
+
+#define SET_STRING_PROPERTY_BY_FIELD(jClass, jObj, jsObj, propertyName) \
+jfieldID propertyName =env->GetFieldID(jClass, #propertyName, "Ljava/lang/String;"); \
+jstring j##propertyName = (jstring) env->GetObjectField(jObj, propertyName);            \
+const char* p##propertyName = j##propertyName?env->GetStringUTFChars(j##propertyName, nullptr):""; \
+jsObj.setProperty(rt, #propertyName, std::move(p##propertyName));                     \
+if(j##propertyName) env->ReleaseStringUTFChars(j##propertyName, p##propertyName);    \
+
+namespace jsiConversion::cvr {
+void jCapturedResultToJsiObject(Runtime &rt, JNIEnv *env, jobject jCapturedResult, Object &jsCapturedResult);
+}//namespace jsiConversion::cvr
+
+namespace jsi_install::cvr {
+    void install_captureImageData(Runtime &jsiRuntime);
+    void install_getCurrentNormalizedImages(Runtime &jsiRuntime);
+    void install_captureFile(Runtime &jsiRuntime);
+    void install_captureFileBytes(Runtime &jsiRuntime);
+    void install_cvr_getOriginalImage(Runtime &jsiRuntime);
+}//namespace jsi_install::cvr
+
+Object captureImageDataHO(ImageDataHostObject &imageDataHO, Runtime &rt, string templateName);
+Object captureFile(string filePath, Runtime &rt, string templateName);
+Object captureFileBytes(ArrayBuffer &fileBytes, Runtime &rt, string templateName);
+Array getCurrentNormalizedImages(Runtime &runtime);
+ImageDataHostObject getOriginalImage(Runtime &runtime, string imageHashId);
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CVR_JSICVR_H_