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

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/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/cvr/CaptureVisionRouterModuleImpl.kt

@@ -63,6 +63,8 @@ class CaptureVisionRouterModuleImpl(private val reactContext: ReactApplicationCo
             },
             onProcessedDocumentResultReceived_Event to object : CapturedResultReceiver {
                 override fun onProcessedDocumentResultReceived(result: ProcessedDocumentResult) {
+                    currentDeskewedImages = result.deskewedImageResultItems.map { (it as DeskewedImageResultItem).imageData }.toTypedArray()
+                    currentEnhancedImages = result.enhancedImageResultItems.map { (it as EnhancedImageResultItem).imageData }.toTypedArray()
                     emitResultAndWaitForResponse(onProcessedDocumentResultReceived_Event, result.toWritableMap())
                 }
             },

package/android/src/main/java/com/dynamsoft/reactnativelib/dce/CameraEnhancerModuleImpl.kt

@@ -2,16 +2,19 @@ package com.dynamsoft.reactnativelib.dce
 
 import android.graphics.PointF
 import android.util.Log
+import android.util.Size
 import androidx.lifecycle.Lifecycle
 import com.dynamsoft.dce.CameraEnhancer
 import com.dynamsoft.dce.CameraView
 import com.dynamsoft.dce.EnumCameraPosition
 import com.dynamsoft.dce.EnumFocusMode
+import com.dynamsoft.dce.EnumResolution
 import com.dynamsoft.dce.Feedback
 import com.dynamsoft.dce.utils.PermissionUtil
 import com.dynamsoft.reactnativelib.core.ImageSourceAdapterModuleImpl.Companion.mapISA
 import com.dynamsoft.reactnativelib.utils.toScanRegion
 import com.dynamsoft.reactnativelib.utils.toWritableMap
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -158,6 +161,24 @@ class CameraEnhancerModuleImpl(private val reactContext: ReactApplicationContext
         camera.turnOffTorch()
     }
 
+
+    @ReactMethod
+    fun setResolution(resolution: Int) {
+        if(resolution == 4) {
+            camera.setResolution(EnumResolution.RESOLUTION_4K)
+        } else {
+            camera.setResolution(resolution)
+        }
+    }
+    @ReactMethod
+    fun getResolution(promise: Promise) {
+        val resolution = camera.getResolution() ?: Size(0,0)
+        promise.resolve(Arguments.createMap().apply {
+            putInt("width", resolution.width)
+            putInt("height", resolution.height)
+        })
+    }
+
     @ReactMethod
     fun beep() {
         Feedback.beep()

package/android/src/main/java/com/dynamsoft/reactnativelib/utility/ImageManagerModuleImpl.kt

@@ -35,10 +35,10 @@ class ImageManagerModuleImpl(private val reactContext: ReactApplicationContext)
     }
 
     fun cropImageCalledInJsi(imageData: ImageData, quad: Quadrilateral): ImageData? {
-        try {
-            return imageProcessor.cropImage(imageData, quad)
+        return try {
+            imageProcessor.cropAndDeskewImage(imageData, quad)
         } catch (e: UtilityException) {
-            return null;
+            null;
         }
     }
 

package/dynamsoft-capture-vision-react-native.podspec

@@ -17,7 +17,7 @@ Pod::Spec.new do |s|
   s.private_header_files = "ios/**/*.h"
   s.requires_arc = true
 
-  s.dependency "DynamsoftCaptureVisionBundle", ">= 3.0.3000", "< 4.0"
+  s.dependency "DynamsoftCaptureVisionBundle", ">= 3.0.5100", "< 4.0"
 
  install_modules_dependencies(s)
 end

package/ios/RNDynamsoftCameraViewManager.m

@@ -84,8 +84,7 @@ RCT_EXPORT_METHOD(setCameraView:(nonnull NSNumber *)tag) {
 }
 
 RCT_EXPORT_METHOD(selectCamera:(NSInteger)position) {
-    NSError *error;
-    [self.dce selectCameraWithPosition:position error:&error];
+    [self.dce selectCameraWithPosition:position completion:nil];
 }
 
 RCT_EXPORT_METHOD(getCameraPosition:(RCTPromiseResolveBlock)resolve
@@ -176,4 +175,8 @@ RCT_EXPORT_METHOD(vibrate) {
     [DSFeedback vibrate];
 }
 
+RCT_EXPORT_METHOD(setResolution:(NSInteger)resolution) {
+    [self.dce setResolution:resolution];
+}
+
 @end

package/ios/RNDynamsoftImageManager.mm

@@ -136,7 +136,7 @@ static void install(jsi::Runtime &jsiRuntime, RNDynamsoftImageManager *rnManager
             Object obj = arguments[1].getObject(runtime);
             DSQuadrilateral *quad = convertJSIValueToDSQuadrilateral(runtime, obj);
             NSError *error;
-            DSImageData *imageData = [rnManager.processor cropImage:data quad:quad error:&error];
+            DSImageData *imageData = [rnManager.processor cropAndDeskewImage:data quad:quad error:&error];
             ImageDataHostObject outImageData = [imageData hostObject];
             Object outObj = Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(outImageData));
             return outObj;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dynamsoft-capture-vision-react-native",
   "title": "Dynamsoft Capture Vision React Native",
-  "version": "3.0.3100",
+  "version": "3.0.5100",
   "description": "The Dynamsoft Capture Vision React Native SDK provides a wrapper for building barcode scanning, document scanning and MRZ scanning applications with React Native.",
   "homepage": "https://github.com/Dynamsoft/capture-vision-react-native-samples",
   "main": "src/index.tsx",

package/src/dce/CameraEnhancer.tsx

@@ -4,6 +4,7 @@ import {CameraView} from "./CameraView"
 import type {EnumCameraPosition} from "./EnumCameraPosition";
 import type {EnumFocusMode} from "./EnumFocusMode";
 import type {EnumEnhancedFeatures} from "./EnumEnhancedFeatures";
+import type {EnumResolution} from "./EnumResolution";
 
 // @ts-ignore Check whether __turboModuleProxy exists, it may not
 const isTurboModuleEnabled = global.__turboModuleProxy != null;
@@ -220,6 +221,14 @@ export class CameraEnhancer extends ImageSourceAdapter {
     DynamsoftCameraEnhancerModule.turnOffTorch()
   }
 
+  /**
+   * Set the resolution of the camera.
+   * @param resolution - One of the {@link EnumResolution}.
+   * */
+  setResolution(resolution: EnumResolution) {
+    DynamsoftCameraEnhancerModule.setResolution(resolution);
+  }
+
   destroy() {
     this.close()
     super.destroy();

package/src/dce/EnumResolution.tsx

@@ -0,0 +1,7 @@
+export enum EnumResolution {
+  RESOLUTION_AUTO = 0,
+  RESOLUTION_480P = 1,
+  RESOLUTION_720P = 2,
+  Resolution1080P = 3,
+  RESOLUTION_4K = 4,
+}

package/src/dce/NativeDynamsoftCameraViewModule.tsx

@@ -35,6 +35,10 @@ export interface Spec extends TurboModule {
 
     turnOffTorch(): void;
 
+    setResolution(resolution: number): void;
+
+    getResolution(): Promise<unknown>;
+
     beep(): void;
 
     vibrate(): void;

package/src/dce/index.tsx

@@ -8,5 +8,6 @@ export * from "./EnumFocusMode"
 export * from "./EnumTorchState"
 export * from "./FeedBack"
 export * from "./ImageEditorView"
+export * from "./EnumResolution"
 export type {CameraViewNativeProps} from "./DynamsoftCameraViewNativeComponent"
 export type {ImageEditorViewNativeProps} from "./DynamsoftImageEditorViewNativeComponent"