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

package/android/src/main/cpp/JsiDdn.cpp

@@ -0,0 +1,50 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#include "JsiDdn.h"
+
+namespace jsiConversion::ddn {
+void jDetectedQuadResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem) {
+    env->PushLocalFrame(4);
+    jclass clsItem = env->FindClass("com/dynamsoft/ddn/DetectedQuadResultItem");
+    jmethodID me_getLocation =env->GetMethodID(clsItem, "getLocation", "()Lcom/dynamsoft/core/basic_structures/Quadrilateral;");
+    jmethodID me_getConfidenceAsDocumentBoundary =env->GetMethodID(clsItem, "getConfidenceAsDocumentBoundary", "()I");
+    jmethodID me_getCrossVerificationStatus = env->GetMethodID(clsItem, "getCrossVerificationStatus", "()I");
+    Object jsQuad(rt);
+    jsiConversion::core::jQuadToJsObject(rt, env, env->CallObjectMethod(jItem, me_getLocation), jsQuad);
+    jsItem.setProperty(rt, "location", jsQuad);
+    jsItem.setProperty(rt, "ConfidenceAsDocumentBoundary", env->CallIntMethod(jItem, me_getConfidenceAsDocumentBoundary));
+    jsItem.setProperty(rt, "crossVerificationStatus", env->CallIntMethod(jItem, me_getCrossVerificationStatus));
+    env->PopLocalFrame(nullptr);
+}
+void jDeskewedImageResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem) {
+    env->PushLocalFrame(4);
+    jclass clsItem = env->FindClass("com/dynamsoft/ddn/DeskewedImageResultItem");
+    jmethodID me_getSourceDeskewQuad = env->GetMethodID(clsItem, "getSourceDeskewQuad", "()Lcom/dynamsoft/core/basic_structures/Quadrilateral;");
+    jmethodID me_getImageData = env->GetMethodID(clsItem, "getImageData", "()Lcom/dynamsoft/core/basic_structures/ImageData;");
+    jmethodID me_getCrossVerificationStatus = env->GetMethodID(clsItem, "getCrossVerificationStatus", "()I");
+    Object jsQuad(rt);
+    jsiConversion::core::jQuadToJsObject(rt, env, env->CallObjectMethod(jItem, me_getSourceDeskewQuad), jsQuad);
+    jsItem.setProperty(rt, "sourceDeskewQuad", jsQuad);
+    jobject jImageData = env->CallObjectMethod(jItem, me_getImageData);
+    ImageDataHostObject imgHostObject;
+    jsiConversion::core::getHOFromJImageData(env, jImageData, imgHostObject);
+    auto jsImageData = Object::createFromHostObject(rt, std::make_shared<ImageDataHostObject>(imgHostObject));
+    jsItem.setProperty(rt, "imageData", std::move(jsImageData));
+    jsItem.setProperty(rt, "crossVerificationStatus", env->CallIntMethod(jItem, me_getCrossVerificationStatus));
+    env->PopLocalFrame(nullptr);
+}
+
+void jEnhancedImageResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem) {
+    env->PushLocalFrame(4);
+    jclass clsItem = env->FindClass("com/dynamsoft/ddn/EnhancedImageResultItem");
+    jmethodID me_getImageData = env->GetMethodID(clsItem, "getImageData", "()Lcom/dynamsoft/core/basic_structures/ImageData;");
+    jobject jImageData = env->CallObjectMethod(jItem, me_getImageData);
+    ImageDataHostObject imgHostObject;
+    jsiConversion::core::getHOFromJImageData(env, jImageData, imgHostObject);
+    auto jsImageData = Object::createFromHostObject(rt, std::make_shared<ImageDataHostObject>(imgHostObject));
+    jsItem.setProperty(rt, "imageData", std::move(jsImageData));
+    env->PopLocalFrame(nullptr);
+}
+}//namespace jsiConversion::ddn

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

@@ -0,0 +1,28 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DDN_JSIDDN_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DDN_JSIDDN_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::ddn {
+void jDetectedQuadResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem);
+void jDeskewedImageResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem);
+void jEnhancedImageResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem);
+}
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DDN_JSIDDN_H_

package/android/src/main/cpp/JsiDlr.cpp

@@ -0,0 +1,51 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#include "JsiDlr.h"
+
+namespace jsiConversion::dlr {
+void jTextLineResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem) {
+    env->PushLocalFrame(8);
+    jclass clsItem = env->FindClass("com/dynamsoft/dlr/TextLineResultItem");
+    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));
+
+    SET_STRING_PROPERTY_BY_METHOD(clsItem, jItem, jsItem, text, getText)
+    SET_STRING_PROPERTY_BY_METHOD(clsItem, jItem, jsItem, specificationName, getSpecificationName)
+
+    jmethodID getCharacterResults = env->GetMethodID(clsItem, "getCharacterResults", "()[Lcom/dynamsoft/dlr/CharacterResult;");
+    auto jCharacterResults = (jobjectArray) env->CallObjectMethod(jItem, getCharacterResults);
+    int count = jCharacterResults ? env->GetArrayLength(jCharacterResults) : 0;
+    Array jsCharacterResultArray = Array(rt, count);
+    for (int i = 0; i < count; ++i) {
+        Object jsCharacterResult(rt);
+        auto jCharRes = env->GetObjectArrayElement(jCharacterResults, i);
+        jCharacterResultToJsObject(rt, env, jCharRes, jsCharacterResult);
+        env->DeleteLocalRef(jCharRes);
+        jsCharacterResultArray.setValueAtIndex(rt, i, jsCharacterResult);
+    }
+    env->PopLocalFrame(nullptr);
+}
+void jCharacterResultToJsObject(Runtime &rt, JNIEnv *env, jobject jCharRes, Object &jsCharRes) {
+    jclass clsResult = env->FindClass("com/dynamsoft/dlr/CharacterResult");
+    jfieldID characterH = env->GetFieldID(clsResult, "characterH", "C");
+    jfieldID characterM = env->GetFieldID(clsResult, "characterM", "C");
+    jfieldID characterL = env->GetFieldID(clsResult, "characterL", "C");
+    jsCharRes.setProperty(rt, "characterH", std::to_string(env->GetCharField(jCharRes, characterH)));
+    jsCharRes.setProperty(rt, "characterM", std::to_string(env->GetCharField(jCharRes, characterM)));
+    jsCharRes.setProperty(rt, "characterL", std::to_string(env->GetCharField(jCharRes, characterL)));
+
+    jfieldID characterHConfidence = env->GetFieldID(clsResult, "characterHConfidence", "I");
+    jfieldID characterMConfidence = env->GetFieldID(clsResult, "characterMConfidence", "I");
+    jfieldID characterLConfidence = env->GetFieldID(clsResult, "characterLConfidence", "I");
+    jsCharRes.setProperty(rt, "characterHConfidence", env->GetIntField(jCharRes, characterHConfidence));
+    jsCharRes.setProperty(rt, "characterMConfidence", env->GetIntField(jCharRes, characterMConfidence));
+    jsCharRes.setProperty(rt, "characterLConfidence", env->GetIntField(jCharRes, characterLConfidence));
+}
+}//namespace jsiConversion::dlr

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

@@ -0,0 +1,26 @@
+//
+// Created by Allen on 24/08/28.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DLR_JSIDLR_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DLR_JSIDLR_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::dlr {
+void jTextLineResultItemToJsObject(Runtime &rt, JNIEnv *env, jobject jItem, Object &jsItem);
+void jCharacterResultToJsObject(Runtime &rt, JNIEnv *env, jobject jCharRes, Object &jsCharRes);
+}
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_DLR_JSIDLR_H_

package/android/src/main/cpp/JsiUtility.cpp

@@ -0,0 +1,196 @@
+//
+// Created by Allen on 24/09/23.
+//
+
+#include "JsiUtility.h"
+jobject jImageManagerModule = nullptr;
+jclass jclzQuad = nullptr;
+jclass jclzPoint = nullptr;
+
+jobject jsPointToJobject(Runtime &rt, JNIEnv *env, Object jsPoint) {
+    if(jsPoint.hasProperty(rt,"x") && jsPoint.hasProperty(rt,"y")) {
+        int x = jsPoint.getProperty(rt,"x").asNumber();
+        int y = jsPoint.getProperty(rt,"y").asNumber();
+        jmethodID init = env->GetMethodID(jclzPoint, "<init>", "(II)V");
+        jobject jPoint = env->NewObject(jclzPoint, init, x, y);
+        return jPoint;
+    }
+    return nullptr;
+}
+
+jobject jsQuadToJobject(Runtime &rt, JNIEnv *env, Object &jsQuad) {
+    if(jsQuad.hasProperty(rt,"points")) {
+        auto jsPoints = jsQuad.getProperty(rt,"points").asObject(rt).asArray(rt);
+        int count = jsPoints.length(rt);
+        auto jPoints = env->NewObjectArray(count, jclzPoint, nullptr);
+        for (int i = 0; i < count; ++i) {
+            auto jPoint = jsPointToJobject(rt, env, jsPoints.getValueAtIndex(rt, i).asObject(rt));
+            env->SetObjectArrayElement(jPoints, i, jPoint);
+            env->DeleteLocalRef(jPoint);
+        }
+        auto initQuad = env->GetMethodID(jclzQuad, "<init>", "()V");
+        auto fieldId_points = env->GetFieldID(jclzQuad, "points", "[Landroid/graphics/Point;");
+        auto jQuad = env->NewObject(jclzQuad, initQuad);
+        env->SetObjectField(jQuad, fieldId_points, jPoints);
+        return jQuad;
+    }
+    return nullptr;
+}
+
+jobjectArray jsQuadArrayToJobjectArray(Runtime &rt, JNIEnv *env, Array &jsQuads) {
+    int count = jsQuads.length(rt);
+    jobjectArray jQuads = env->NewObjectArray(count, jclzQuad, nullptr);
+    for (int i = 0; i < count; ++i) {
+        auto jsQuad = jsQuads.getValueAtIndex(rt, i).asObject(rt);
+        auto jQuad = jsQuadToJobject(rt, env, jsQuad);
+        env->SetObjectArrayElement(jQuads, i, jQuad);
+        env->DeleteLocalRef(jQuad);
+    }
+    return jQuads;
+}
+
+void saveImageDataHOToFile(Runtime &rt, ImageDataHostObject &imageDataHO, string filePath, bool overWrite) {
+    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;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "saveToFileCalledInJsi", "(Lcom/dynamsoft/core/basic_structures/ImageData;Ljava/lang/String;Z)V");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    env->CallVoidMethod(jImageManagerModule, methodId, jImageData, env->NewStringUTF(filePath.c_str()), overWrite);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+}
+
+ImageDataHostObject drawOnImage(Runtime &rt, ImageDataHostObject &imageDataHO, Array &jsQuads, int color, int thickness) {
+    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;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "drawOnImageCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;[Lcom/dynamsoft/core/basic_structures/Quadrilateral;II)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jQuads = jsQuadArrayToJobjectArray(rt, env, jsQuads);
+    auto jImageDataAfterDraw = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jQuads, color, thickness);
+    ImageDataHostObject imageHOAfterDraw;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterDraw, imageHOAfterDraw);
+    env->DeleteLocalRef(jQuads);
+    env->DeleteLocalRef(jImageDataAfterDraw);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterDraw;
+}
+
+ImageDataHostObject cropImage(Runtime &rt, ImageDataHostObject &imageDataHO, Object &jsQuad) {
+    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;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "cropImageCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;Lcom/dynamsoft/core/basic_structures/Quadrilateral;)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jQuad = jsQuadToJobject(rt, env, jsQuad);
+    auto jImageDataAfterCrop = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jQuad);
+    ImageDataHostObject imageHOAfterCrop;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterCrop, imageHOAfterCrop);
+    env->DeleteLocalRef(jQuad);
+    env->DeleteLocalRef(jImageDataAfterCrop);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterCrop;
+}
+
+
+#define JSI_FUNC [](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value
+
+namespace jsi_install::utility {
+void install_imageManager_saveToFile(Runtime &jsiRuntime) {
+    auto nameID = PropNameID::forAscii(jsiRuntime, "imageManager_saveToFile");
+    if(!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+        auto saveToFileFcn = Function::createFromHostFunction(jsiRuntime, nameID, 3, JSI_FUNC {
+            auto imageDataObj = arguments[0].asObject(runtime);
+            auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+            auto filePath = arguments[1].asString(runtime).utf8(runtime);
+            bool overWrite = arguments[2].asBool();
+            saveImageDataHOToFile(runtime, imageDataHostObject, filePath, overWrite);
+            return {};
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(saveToFileFcn));
+    }
+}
+void install_imageManager_drawOnImage(Runtime &jsiRuntime){
+    auto nameID = PropNameID::forAscii(jsiRuntime, "imageManager_drawOnImage");
+    if(!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+        auto drawOnImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 4, JSI_FUNC {
+            auto imageDataObj = arguments[0].asObject(runtime);
+            auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+            auto jsQuads = arguments[1].asObject(runtime).asArray(runtime);
+            auto color = arguments[2].asNumber();
+            auto thickness = arguments[3].asNumber();
+            ImageDataHostObject imageHOAfterDraw = drawOnImage(runtime, imageDataHostObject, jsQuads, (int) color, (int) thickness);
+            return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterDraw));
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(drawOnImageFcn));
+    }
+}
+
+void install_imageManager_cropImage(Runtime &jsiRuntime){
+    auto nameID = PropNameID::forAscii(jsiRuntime, "imageManager_cropImage");
+    if(!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+        auto cropImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 4, JSI_FUNC {
+            auto imageDataObj = arguments[0].asObject(runtime);
+            auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+            auto jsQuads = arguments[1].asObject(runtime);
+            ImageDataHostObject imageHOAfterCrop = cropImage(runtime, imageDataHostObject, jsQuads);
+            if(imageHOAfterCrop.buffer == nullptr) {
+                return Value::undefined();
+            }
+            return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
+        });
+        jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropImageFcn));
+    }
+}
+}//namespace jsi_install::dce
+
+void install_imageManager_methods(Runtime &jsiRuntime) {
+    jsi_install::utility::install_imageManager_saveToFile(jsiRuntime);
+    jsi_install::utility::install_imageManager_drawOnImage(jsiRuntime);
+    jsi_install::utility::install_imageManager_cropImage(jsiRuntime);
+}
+
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_dynamsoft_reactnativelib_utility_ImageManagerModuleImpl_nativeInstall(JNIEnv *env, jobject thiz, jlong jsiPtr) {
+    if (!env->IsSameObject(jImageManagerModule, thiz)) {
+        jImageManagerModule = env->NewWeakGlobalRef(thiz);
+    }
+    if(jclzQuad == nullptr) {
+        jclzQuad = (jclass) env->NewWeakGlobalRef(env->FindClass("com/dynamsoft/core/basic_structures/Quadrilateral"));
+    }
+    if(jclzPoint == nullptr) {
+        jclzPoint = (jclass) env->NewWeakGlobalRef(env->FindClass("android/graphics/Point"));
+    }
+    auto rt = reinterpret_cast<Runtime *>(jsiPtr);
+    install_imageManager_methods(*rt);
+}

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

@@ -0,0 +1,16 @@
+//
+// Created by Allen on 24/09/23.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_UTILITY_JSIUTILITY_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_UTILITY_JSIUTILITY_H_
+#include "JsiCore.h"
+
+
+namespace jsi_install::utility {
+void install_imageManager_saveToFile(Runtime &jsiRuntime);
+void install_imageManager_drawOnImage(Runtime &jsiRuntime);
+void install_imageManager_cropImage(Runtime &jsiRuntime);
+}//namespace jsi_install::dce
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_UTILITY_JSIUTILITY_H_

package/android/src/main/cpp/RawBuffer.cpp

@@ -0,0 +1,24 @@
+//
+// Created by Allen on 24/08/26.
+//
+
+
+#include "RawBuffer.h"
+
+MutableRawBuffer::MutableRawBuffer(uint8_t* data, size_t size, bool freeOnDealloc)
+        : _data(data), _size(size), _freeOnDealloc(freeOnDealloc) {}
+
+MutableRawBuffer::~MutableRawBuffer() {
+    if (_freeOnDealloc && _data != nullptr) {
+        free(_data);
+        _data = nullptr;
+    }
+}
+
+size_t MutableRawBuffer::size() const {
+    return _size;
+}
+
+uint8_t* MutableRawBuffer::data() {
+    return _data;
+}

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

@@ -0,0 +1,24 @@
+//
+// Created by Allen on 24/08/26.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_MUTABLERAWBUFFER_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_MUTABLERAWBUFFER_H_
+
+
+#include <jsi/jsi.h>
+using namespace facebook::jsi;
+
+class MutableRawBuffer : public MutableBuffer {
+  public:
+    MutableRawBuffer(uint8_t* data, size_t size, bool freeOnDealloc);
+    ~MutableRawBuffer() override;
+
+    uint8_t* data() override;
+    [[nodiscard]] size_t size() const override;
+    uint8_t* _data;
+    size_t _size;
+    bool _freeOnDealloc;
+};
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_MUTABLERAWBUFFER_H_

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

@@ -0,0 +1,14 @@
+//
+// Created by Allen on 24/05/15.
+//
+
+#ifndef DYNAMSOFT_CORE_REACT_NATIVE_ANDROID_SRC_MAIN_CPP_ANDROID_LOG_H_
+#define DYNAMSOFT_CORE_REACT_NATIVE_ANDROID_SRC_MAIN_CPP_ANDROID_LOG_H_
+
+#include "android/log.h"
+#define LOG_TAG "Dynamsoft RN JNI"
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+#endif //DYNAMSOFT_CORE_REACT_NATIVE_ANDROID_SRC_MAIN_CPP_ANDROID_LOG_H_

package/android/src/{oldarch → main/java}/com/dynamsoft/reactnativelib/CVRModule.kt

@@ -81,13 +81,13 @@ class CVRModule(reactApplicationContext: ReactApplicationContext) : ReactContext
     }
 
     @ReactMethod
-    fun outputSettings(templateName: String, promise: Promise) {
-        impl.outputSettings(templateName, promise)
+    fun outputSettings(templateName: String, includeDefaultValues: Boolean, promise: Promise) {
+        impl.outputSettings(templateName, includeDefaultValues, promise)
     }
 
     @ReactMethod
-    fun outputSettingsToFile(file: String, templateName: String, promise: Promise) {
-        impl.outputSettingsToFile(file, templateName, promise)
+    fun outputSettingsToFile(file: String, templateName: String, includeDefaultValues: Boolean, promise: Promise) {
+        impl.outputSettingsToFile(file, templateName, includeDefaultValues, promise)
     }
 
     @ReactMethod

package/android/src/{oldarch → main/java}/com/dynamsoft/reactnativelib/DCEModule.kt

@@ -99,6 +99,16 @@ class DCEModule(reactApplicationContext: ReactApplicationContext) : ReactContext
         impl.turnOffTorch()
     }
 
+    @ReactMethod
+    fun setResolution(resolution: Int) {
+        impl.setResolution(resolution)
+    }
+
+    @ReactMethod
+    fun getResolution(promise: Promise) {
+        impl.getResolution(promise)
+    }
+
     @ReactMethod
     fun beep() {
         impl.beep()

package/android/src/main/java/com/dynamsoft/reactnativelib/ReactNativeDcvPackage.kt

@@ -1,23 +1,12 @@
 // ReactNativeDcvPackage.java
 package com.dynamsoft.reactnativelib
 
-import com.dynamsoft.reactnativelib.core.ImageSourceAdapterModuleImpl
-import com.dynamsoft.reactnativelib.cvr.CaptureVisionRouterModuleImpl
-import com.dynamsoft.reactnativelib.dce.CameraEnhancerModuleImpl
-import com.dynamsoft.reactnativelib.dce.ImageEditorViewModuleImpl
-import com.dynamsoft.reactnativelib.license.LicenseModuleImpl
-import com.dynamsoft.reactnativelib.rtu.BarcodeScannerModuleImpl
-import com.dynamsoft.reactnativelib.rtu.MRZScannerModuleImpl
-import com.dynamsoft.reactnativelib.utility.ImageManagerModuleImpl
-import com.dynamsoft.reactnativelib.utility.MultiCrossFilterModuleImpl
-import com.facebook.react.TurboReactPackage
+import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.model.ReactModuleInfo
-import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
 
-class ReactNativeDcvPackage : TurboReactPackage() {
+class ReactNativeDcvPackage : ReactPackage {
     companion object {
         init {
             System.loadLibrary("rn_dys")
@@ -28,77 +17,16 @@ class ReactNativeDcvPackage : TurboReactPackage() {
         return listOf(CameraViewManager(), ImageEditorViewManager())
     }
 
-    override fun getModule(name: String, context: ReactApplicationContext): NativeModule? {
-        return when (name) {
-            CaptureVisionRouterModuleImpl.NAME -> CVRModule(context)
-            CameraEnhancerModuleImpl.NAME -> DCEModule(context)
-            ImageSourceAdapterModuleImpl.NAME -> ISAModule(context)
-            LicenseModuleImpl.NAME -> LicenseModule(context)
-            MultiCrossFilterModuleImpl.NAME -> MultiCrossFilterModule(context)
-            VersionsModule.NAME -> VersionsModule(context)
-            ImageEditorViewModuleImpl.NAME -> ImageEditorViewModule(context)
-            ImageManagerModuleImpl.NAME -> ImageManagerModule(context)
-            BarcodeScannerModuleImpl.NAME -> BarcodeScannerModule(context)
-            MRZScannerModuleImpl.NAME -> MRZScannerModule(context)
-            else -> null
-        }
-    }
-
-    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-        val isEnableNewArch = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-        return ReactModuleInfoProvider {
-            mapOf(
-                CaptureVisionRouterModuleImpl.NAME to ReactModuleInfo(
-                    CaptureVisionRouterModuleImpl.NAME,
-                    CaptureVisionRouterModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                CameraEnhancerModuleImpl.NAME to ReactModuleInfo(
-                    CameraEnhancerModuleImpl.NAME,
-                    CameraEnhancerModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                ImageSourceAdapterModuleImpl.NAME to ReactModuleInfo(
-                    ImageSourceAdapterModuleImpl.NAME,
-                    ImageSourceAdapterModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                LicenseModuleImpl.NAME to ReactModuleInfo(
-                    LicenseModuleImpl.NAME,
-                    LicenseModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                MultiCrossFilterModuleImpl.NAME to ReactModuleInfo(
-                    MultiCrossFilterModuleImpl.NAME,
-                    MultiCrossFilterModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                VersionsModule.NAME to ReactModuleInfo(
-                    VersionsModule.NAME,
-                    VersionsModule.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                ImageEditorViewModuleImpl.NAME to ReactModuleInfo(
-                    ImageEditorViewModuleImpl.NAME,
-                    ImageEditorViewModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                ImageManagerModuleImpl.NAME to ReactModuleInfo(
-                    ImageManagerModuleImpl.NAME,
-                    ImageManagerModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                BarcodeScannerModuleImpl.NAME to ReactModuleInfo(
-                    BarcodeScannerModuleImpl.NAME,
-                    BarcodeScannerModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                ),
-                MRZScannerModuleImpl.NAME to ReactModuleInfo(
-                    MRZScannerModuleImpl.NAME,
-                    MRZScannerModuleImpl.NAME,
-                    false, false, true, false, isEnableNewArch
-                )
-            )
-        }
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return mutableListOf(
+            CVRModule(reactContext),
+            DCEModule(reactContext),
+            ISAModule(reactContext),
+            LicenseModule(reactContext),
+            MultiCrossFilterModule(reactContext),
+            VersionsModule(reactContext),
+            ImageEditorViewModule(reactContext),
+            ImageManagerModule(reactContext),
+        )
     }
 }

package/android/src/{oldarch → main/java}/com/dynamsoft/reactnativelib/VersionsModule.kt

@@ -5,7 +5,7 @@ import com.dynamsoft.cvr.CaptureVisionRouterModule
 import com.dynamsoft.dbr.BarcodeReaderModule
 import com.dynamsoft.dce.CameraEnhancerModule
 import com.dynamsoft.dcp.CodeParserModule
-import com.dynamsoft.dcp.dedicator.CodePaserDedicatorModule
+import com.dynamsoft.dcp.dedicator.CodeParserDedicatorModule
 import com.dynamsoft.ddn.DocumentNormalizerModule
 import com.dynamsoft.dip.ImageProcessingModule
 import com.dynamsoft.dlr.LabelRecognizerModule
@@ -34,7 +34,7 @@ class VersionsModule(reactContext: ReactApplicationContext) : ReactContextBaseJa
             "dnn" to NeuralNetworkModule.getVersion(),
             "utility" to UtilityModule.getVersion(),
             "dcp" to CodeParserModule.getVersion(),
-            "dcpd" to CodePaserDedicatorModule.getVersion(),
+            "dcpd" to CodeParserDedicatorModule.getVersion(),
             "dip" to ImageProcessingModule.getVersion()
         )
     )