dynamsoft-capture-vision-react-native 2.6.1016 → 3.0.5100

package/android/src/main/cpp/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 "ImgHO.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/JsiCvr.cpp

@@ -0,0 +1,327 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#include "JsiCvr.h"
+#include "ImgHO.h"
+#include "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_getCurrentDeskewedImages(runtime);
+    jsi_install::cvr::install_getCurrentEnhancedImages(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 fiMatrix = env->GetFieldID(jclsCapturedResult, "rotationTransformMatrix", "Landroid/graphics/Matrix;");
+    jobject jMatrix = env->GetObjectField(jCapturedResult, fiMatrix);
+    if(jMatrix) {
+        jclass clsMatrix = env->GetObjectClass(jMatrix);
+        jmethodID getValues = env->GetMethodID(clsMatrix, "getValues", "([F)V");
+        jfloatArray jValues = env->NewFloatArray(9);
+        env->CallVoidMethod(jMatrix, getValues, jValues);
+        float cValues[9];
+        env->GetFloatArrayRegion(jValues, 0, 9, cValues);
+        Array jsMatrix(rt, 9);
+        for (int i = 0; i < 9; ++i) {
+            jsMatrix.setValueAtIndex(rt, i, cValues[i]);
+        }
+        env->DeleteLocalRef(clsMatrix);
+        env->DeleteLocalRef(jValues);
+        jsCapturedResult.setProperty(rt, "rotationTransformMatrix", jsMatrix);
+    }
+
+    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_DESKEWED_IMAGE) {
+            jsiConversion::ddn::jDeskewedImageResultItemToJsObject(rt, env, jItem, jsItem);
+        } else if (type == CRIT_PARSED_RESULT) {
+            jsiConversion::dcp::jParsedResultItemToJsObject(rt, env, jItem, jsItem);
+        } else if(type == CRIT_ENHANCED_IMAGE) {
+            jsiConversion::ddn::jEnhancedImageResultItemToJsObject(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_getCurrentDeskewedImages(Runtime &jsiRuntime) {
+    auto nameId = PropNameID::forAscii(jsiRuntime, "getCurrentDeskewedImages");
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+        auto getCurrentDeskewedImagesFunc = Function::createFromHostFunction(jsiRuntime, nameId, 0, JSI_FUNC {
+            Array images = getCurrentDeskewedImages(runtime);
+            return images;
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(getCurrentDeskewedImagesFunc));
+    }
+}
+void install_getCurrentEnhancedImages(Runtime &jsiRuntime) {
+    auto nameId = PropNameID::forAscii(jsiRuntime, "getCurrentEnhancedImages");
+    if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+        auto getCurrentEnhancedImagesFunc = Function::createFromHostFunction(jsiRuntime, nameId, 0, JSI_FUNC {
+            Array images = getCurrentEnhancedImages(runtime);
+            return images;
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(getCurrentEnhancedImagesFunc));
+    }
+}
+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 getCurrentDeskewedImages(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, "currentDeskewedImages", "[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;
+}
+
+Array getCurrentEnhancedImages(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, "currentEnhancedImages", "[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/JsiCvr.h

@@ -0,0 +1,54 @@
+//
+// 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 "ImgHO.h"
+#include "JsiDbr.h"
+#include "JsiDlr.h"
+#include "JsiDdn.h"
+#include "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_DESKEWED_IMAGE = 1 << 4;
+int CRIT_PARSED_RESULT = 1 << 5;
+int CRIT_ENHANCED_IMAGE = 1 << 6;
+
+#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_getCurrentDeskewedImages(Runtime &jsiRuntime);
+    void install_getCurrentEnhancedImages(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 getCurrentDeskewedImages(Runtime &runtime);
+Array getCurrentEnhancedImages(Runtime &runtime);
+ImageDataHostObject getOriginalImage(Runtime &runtime, string imageHashId);
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CVR_JSICVR_H_

package/android/src/main/cpp/JsiDbr.cpp

@@ -0,0 +1,38 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#include "JsiDbr.h"
+namespace jsiConversion::dbr {
+void jBarcodeResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem) {
+    env->PushLocalFrame(10);
+    jclass clsItem = env->FindClass("com/dynamsoft/dbr/BarcodeResultItem");
+    jmethodID getFormat = env->GetMethodID(clsItem, "getFormat", "()J");
+    jsItem.setProperty(rt, "format", BigInt::fromInt64(rt, env->CallLongMethod(jItem, getFormat)));
+
+    SET_STRING_PROPERTY_BY_METHOD(clsItem, jItem, jsItem, formatString, getFormatString)
+    SET_STRING_PROPERTY_BY_METHOD(clsItem, jItem, jsItem, text, getText)
+
+    jmethodID getLocation = env->GetMethodID(clsItem, "getLocation", "()Lcom/dynamsoft/core/basic_structures/Quadrilateral;");
+    Object jsQuad(rt);
+    jsiConversion::core::jQuadToJsObject(rt, env, env->CallObjectMethod(jItem, getLocation), jsQuad);
+    jsItem.setProperty(rt, "location", jsQuad);
+
+    jmethodID getConfidence = env->GetMethodID(clsItem, "getConfidence", "()I");
+    jsItem.setProperty(rt, "confidence", env->CallIntMethod(jItem, getConfidence));
+
+    jmethodID getAngle = env->GetMethodID(clsItem, "getAngle", "()I");
+    jsItem.setProperty(rt, "angle", env->CallIntMethod(jItem, getAngle));
+
+    jmethodID getModuleSize = env->GetMethodID(clsItem, "getModuleSize", "()I");
+    jsItem.setProperty(rt, "moduleSize", env->CallIntMethod(jItem, getModuleSize));
+
+    jmethodID isMirrored = env->GetMethodID(clsItem, "isMirrored", "()Z");
+    jsItem.setProperty(rt, "isMirrored", (bool) env->CallBooleanMethod(jItem, isMirrored));
+
+    jmethodID isDPM = env->GetMethodID(clsItem, "isDPM", "()Z");
+    jsItem.setProperty(rt, "isDPM", (bool) env->CallBooleanMethod(jItem, isDPM));
+
+    env->PopLocalFrame(nullptr);
+}
+}//namespace jsiConversion::dbr

package/android/src/main/cpp/JsiDbr.h

@@ -0,0 +1,26 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DBR_JSIDBR_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DBR_JSIDBR_H_
+
+#include "jni.h"
+#include "jsi/jsi.h"
+#include "JsiCore.h"
+
+#define SET_STRING_PROPERTY_BY_METHOD(jClass, jObj, jsObj, propertyName, methodName) \
+jmethodID methodName =env->GetMethodID(jClass, #methodName, "()Ljava/lang/String;"); \
+jstring j##propertyName = (jstring) env->CallObjectMethod(jObj, methodName);            \
+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);    \
+
+using namespace std;
+using namespace facebook::jsi;
+
+namespace jsiConversion::dbr {
+void jBarcodeResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem);
+}
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DBR_JSIDBR_H_

package/android/src/main/cpp/JsiDce.cpp

@@ -0,0 +1,59 @@
+//
+// Created by Allen on 24/08/29.
+//
+
+#include "JsiDce.h"
+#define JSI_FUNC [](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value
+
+jobject jImageEditorViewModule = nullptr;
+
+
+void install_editorView_methods(Runtime &jsiRuntime) {
+    jsi_install::dce::install_editorView_setOriginalImage(jsiRuntime);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_dynamsoft_reactnativelib_dce_ImageEditorViewModuleImpl_nativeInstall(JNIEnv *env, jobject thiz, jlong jsiPtr) {
+    if (!env->IsSameObject(jImageEditorViewModule, thiz)) {
+        jImageEditorViewModule = env->NewWeakGlobalRef(thiz);
+    }
+    auto rt = reinterpret_cast<Runtime *>(jsiPtr);
+    install_editorView_methods(*rt);
+}
+
+
+namespace jsi_install::dce {
+void install_editorView_setOriginalImage(Runtime &jsiRuntime) {
+    auto nameID = PropNameID::forAscii(jsiRuntime, "editorView_setOriginalImage");
+    if(!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+        auto setOriginalImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
+            auto imageDataObj = arguments[1].asObject(runtime);
+            auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+            setOriginalImageDataHOToEditorView(runtime, imageDataHostObject, (int) arguments[0].asNumber());
+            return {};
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(setOriginalImageFcn));
+    }
+}
+}//namespace jsi_install::dce
+
+void setOriginalImageDataHOToEditorView(Runtime &rt, ImageDataHostObject &imageDataHO, int viewTag) {
+    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 clzImageEditorViewModule = env->GetObjectClass(jImageEditorViewModule);
+    auto setOriginalImageCalledInJSI =
+            env->GetMethodID(clzImageEditorViewModule, "setOriginalImageCalledInJSI", "(Lcom/dynamsoft/core/basic_structures/ImageData;I)V");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    env->CallVoidMethod(jImageEditorViewModule, setOriginalImageCalledInJSI, jImageData, viewTag);
+    env->DeleteLocalRef(clzImageEditorViewModule);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+}

package/android/src/main/cpp/JsiDce.h

@@ -0,0 +1,17 @@
+//
+// Created by Allen on 24/08/29.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DCE_JSIDCE_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DCE_JSIDCE_H_
+#include "JsiCore.h"
+
+
+
+namespace jsi_install::dce {
+    void install_editorView_setOriginalImage(Runtime &jsiRuntime);
+}//namespace jsi_install::dce
+
+void setOriginalImageDataHOToEditorView(Runtime &rt, ImageDataHostObject &imageDataHO, int viewTag);
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DCE_JSIDCE_H_

package/android/src/main/cpp/JsiDcp.cpp

@@ -0,0 +1,51 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#include "JsiDcp.h"
+
+namespace jsiConversion::dcp {
+void jParsedResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem) {
+    jclass clsItem = env->FindClass("com/dynamsoft/dcp/ParsedResultItem");
+
+    SET_STRING_PROPERTY_BY_METHOD(clsItem, jItem, jsItem, codeType, getCodeType)
+    SET_STRING_PROPERTY_BY_METHOD(clsItem, jItem, jsItem, jsonString, getJsonString)
+
+    auto getParsedFields = env->GetMethodID(clsItem, "getParsedFields", "()Ljava/util/HashMap;");
+    jobject j_parsedFields = env->CallObjectMethod(jItem, getParsedFields);
+
+    jclass clsHashMap = env->FindClass("java/util/HashMap");
+    jmethodID keySet = env->GetMethodID(clsHashMap, "keySet", "()Ljava/util/Set;");
+
+    jclass clsSet = env->FindClass("java/util/Set");
+    jmethodID toArray = env->GetMethodID(clsSet, "toArray", "()[Ljava/lang/Object;");
+
+    if (!j_parsedFields) {
+        return;
+    }
+    auto j_keySet = env->CallObjectMethod(j_parsedFields, keySet);
+    auto j_keyArray = (jobjectArray) env->CallObjectMethod(j_keySet, toArray);
+    int count = env->GetArrayLength(j_keyArray);
+    auto getFieldValue = env->GetMethodID(clsItem, "getFieldValue", "(Ljava/lang/String;)Ljava/lang/String;");
+    auto getFieldMappingStatus = env->GetMethodID(clsItem, "getFieldMappingStatus", "(Ljava/lang/String;)I");
+    auto getFieldValidationStatus = env->GetMethodID(clsItem, "getFieldValidationStatus", "(Ljava/lang/String;)I");
+
+    Object js_parsedFields(rt);
+    for (int i = 0; i < count; ++i) {
+        Object js_itemFiled(rt);
+        auto j_key = (jstring) env->GetObjectArrayElement(j_keyArray, i);
+        auto p_key = j_key?env->GetStringUTFChars(j_key, nullptr):"";
+        if(std::string(p_key).empty()) {
+            continue;
+        }
+        SET_STRING_PROPERTY_BY_METHOD2(jItem, js_itemFiled, value, getFieldValue, j_key)
+        js_itemFiled.setProperty(rt, "mappingStatus", env->CallIntMethod(jItem, getFieldMappingStatus, j_key));
+        js_itemFiled.setProperty(rt, "fieldValidationStatus", env->CallIntMethod(jItem, getFieldValidationStatus, j_key));
+        js_parsedFields.setProperty(rt, p_key, js_itemFiled);
+        if(j_key) {
+            env->ReleaseStringUTFChars(j_key, p_key);
+        }
+    }
+    jsItem.setProperty(rt, "parsedFields", js_parsedFields);
+}
+}//namespace jsiConversion::dcp

package/android/src/main/cpp/JsiDcp.h

@@ -0,0 +1,31 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DCP_JSIDCP_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DCP_JSIDCP_H_
+
+#define SET_STRING_PROPERTY_BY_METHOD(jClass, jObj, jsObj, propertyName, methodName) \
+jmethodID methodName =env->GetMethodID(jClass, #methodName, "()Ljava/lang/String;"); \
+jstring j##propertyName = (jstring) env->CallObjectMethod(jObj, methodName);            \
+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);    \
+
+
+#define SET_STRING_PROPERTY_BY_METHOD2(jObj, jsObj, propertyName, methodName, ...) \
+jstring j##propertyName = (jstring) env->CallObjectMethod(jObj, methodName,  __VA_ARGS__);  \
+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);    \
+
+
+#include "jni.h"
+#include "jsi/jsi.h"
+#include "JsiCore.h"
+
+namespace jsiConversion::dcp{
+void jParsedResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem);
+}
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DCP_JSIDCP_H_