dynamsoft-capture-vision-react-native 3.4.1200 → 3.4.3000

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

@@ -1,604 +1,604 @@
-//
-// Created by Allen on 24/09/23.
-//
-
-#include "JsiUtility.h"
-#include "RawBuffer.h"
-
-jobject jImageManagerModule = nullptr;
-jclass jclzQuad = nullptr;
-jclass jclzPoint = nullptr;
-jclass jclzDSRect = nullptr;
-
-using namespace facebook::jsi;
-
-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;
-}
-
-jobject jsDsRectToJobject(Runtime &rt, JNIEnv *env, Object &jsDSRect) {
-    if (!jsDSRect.hasProperty(rt, "left") || !jsDSRect.hasProperty(rt, "top") || !jsDSRect.hasProperty(rt, "right") || !jsDSRect.hasProperty(rt, "bottom") ||
-        !jsDSRect.hasProperty(rt, "measuredInPercentage")) {
-        return nullptr;
-    }
-    float top = (float) jsDSRect.getProperty(rt, "top").asNumber();
-    float left = (float) jsDSRect.getProperty(rt, "left").asNumber();
-    float bottom = (float) jsDSRect.getProperty(rt, "bottom").asNumber();
-    float right = (float) jsDSRect.getProperty(rt, "right").asNumber();
-    bool measuredInPercentage = jsDSRect.getProperty(rt, "measuredInPercentage").asBool();
-    jmethodID init = env->GetMethodID(jclzDSRect, "<init>", "(FFFFZ)V");
-    jobject jDSRect = env->NewObject(jclzDSRect, init, left, top, right, bottom, measuredInPercentage);
-    return jDSRect;
-}
-
-
-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 readImageDataHOFromFile(Runtime &rt, string filePath) {
-    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, "readFromFileCalledInJsi", "(Ljava/lang/String;)Lcom/dynamsoft/core/basic_structures/ImageData;");
-    jstring jFilePath = env->NewStringUTF(filePath.c_str());
-    auto jImageData = env->CallObjectMethod(jImageManagerModule, methodId, jFilePath);
-    ImageDataHostObject imageHO;
-    jsiConversion::core::getHOFromJImageData(env, jImageData, imageHO);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jFilePath);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHO;
-}
-
-ImageDataHostObject readImageDataHOFromMemory(Runtime &rt, unsigned char *buffer, int bufferSize) {
-    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, "readFromMemoryCalledInJsi", "([B)Lcom/dynamsoft/core/basic_structures/ImageData;");
-    auto jBuffer = env->NewByteArray(bufferSize);
-    env->SetByteArrayRegion(jBuffer, 0, bufferSize, (jbyte *) buffer);
-    auto jImageData = env->CallObjectMethod(jImageManagerModule, methodId, jBuffer);
-    ImageDataHostObject imageHO;
-    jsiConversion::core::getHOFromJImageData(env, jImageData, imageHO);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jBuffer);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHO;
-}
-
-ArrayBuffer saveImageDataHOToMemory(Runtime &rt, ImageDataHostObject &imageDataHO, int fileFormat) {
-    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, "saveToMemoryCalledInJsi", "(Lcom/dynamsoft/core/basic_structures/ImageData;I)[B");
-    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jBuffer = (jbyteArray) env->CallObjectMethod(jImageManagerModule, methodId, jImageData, fileFormat);
-    auto pBuffer = (uint8_t *) env->GetByteArrayElements(jBuffer, nullptr);
-    int bufferSize = env->GetArrayLength(jBuffer);
-    auto mutableBuffer = std::make_shared<MutableRawBuffer>(pBuffer, bufferSize, false);
-    ArrayBuffer arrayBuffer(rt, mutableBuffer);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jImageData);
-    return arrayBuffer;
-}
-
-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 &jsDSRect) {
-    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/DSRect;)Lcom/dynamsoft/core/basic_structures/ImageData;");
-    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jDSRect = jsDsRectToJobject(rt, env, jsDSRect);
-    auto jImageDataAfterCrop = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jDSRect);
-    ImageDataHostObject imageHOAfterCrop;
-    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterCrop, imageHOAfterCrop);
-    env->DeleteLocalRef(jDSRect);
-    env->DeleteLocalRef(jImageDataAfterCrop);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHOAfterCrop;
-}
-
-ImageDataHostObject cropAndDeskewImage(Runtime &rt, ImageDataHostObject &imageDataHO, Object &jsQuad, int dstWidth, int dstHeight, int padding) {
-    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, "cropAndDeskewImageCalledInJsi",
-                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;Lcom/dynamsoft/core/basic_structures/Quadrilateral;III)Lcom/dynamsoft/core/basic_structures/ImageData;");
-    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jQuad = jsQuadToJobject(rt, env, jsQuad);
-    auto jImageDataAfterCropAndDeskew = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jQuad, dstWidth, dstHeight, padding);
-    ImageDataHostObject imageHOAfterCrop;
-    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterCropAndDeskew, imageHOAfterCrop);
-    env->DeleteLocalRef(jQuad);
-    env->DeleteLocalRef(jImageDataAfterCropAndDeskew);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHOAfterCrop;
-}
-
-
-const int type_adjust_brightness = 0;
-const int type_adjust_contrast = 1;
-const int type_filter = 2;
-
-ImageDataHostObject adjustOrFilter(Runtime &rt, ImageDataHostObject &imageDataHO, int value, int type) {
-    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;
-    switch (type) {
-        case type_adjust_brightness:
-            methodId = env->GetMethodID(clz, "adjustBrightnessCalledInJsi",
-                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
-            break;
-        case type_adjust_contrast:
-            methodId = env->GetMethodID(clz, "adjustContrastCalledInJsi",
-                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
-            break;
-        case type_filter:
-        default:
-            methodId = env->GetMethodID(clz, "filterImageCalledInJsi",
-                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
-            break;
-    }
-    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jImageDataAfter = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, value);
-    ImageDataHostObject imageHOAfter;
-    jsiConversion::core::getHOFromJImageData(env, jImageDataAfter, imageHOAfter);
-    env->DeleteLocalRef(jImageDataAfter);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHOAfter;
-}
-
-ImageDataHostObject convertToGray(Runtime &rt, ImageDataHostObject &imageDataHO, float r, float g, float b) {
-    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, "convertToGrayCalledInJsi",
-                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;FFF)Lcom/dynamsoft/core/basic_structures/ImageData;");
-    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, r, g, b);
-    ImageDataHostObject imageHOAfterConvert;
-    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
-    env->DeleteLocalRef(jImageDataAfterConvert);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHOAfterConvert;
-}
-
-ImageDataHostObject convertToBinaryGlobal(Runtime &rt, ImageDataHostObject &imageDataHO, int threshold, bool invert) {
-    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, "convertToBinaryGlobalCalledInJsi",
-                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;IZ)Lcom/dynamsoft/core/basic_structures/ImageData;");
-    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, threshold, invert);
-    ImageDataHostObject imageHOAfterConvert;
-    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
-    env->DeleteLocalRef(jImageDataAfterConvert);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHOAfterConvert;
-}
-
-ImageDataHostObject convertToBinaryLocal(Runtime &rt, ImageDataHostObject &imageDataHO, int blockSize, int compensation, bool invert) {
-    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, "convertToBinaryLocalCalledInJsi",
-                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;IIZ)Lcom/dynamsoft/core/basic_structures/ImageData;");
-    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, blockSize, compensation, invert);
-    ImageDataHostObject imageHOAfterConvert;
-    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
-    env->DeleteLocalRef(jImageDataAfterConvert);
-    env->DeleteLocalRef(clz);
-    env->DeleteLocalRef(jImageData);
-    if (needDetach) {
-        gJvm->DetachCurrentThread();
-    }
-    return imageHOAfterConvert;
-}
-
-
-#define JSI_FUNC [](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value
-
-namespace jsi_install::utility {
-    void install_imageIO_saveToFile(Runtime &jsiRuntime) {
-        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_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_imageIO_readFromFile(Runtime &jsiRuntime) {
-        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_readFromFile");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-            auto readFromFileFcn = Function::createFromHostFunction(jsiRuntime, nameID, 1, JSI_FUNC {
-                auto filePath = arguments[0].asString(runtime).utf8(runtime);
-                auto imageDataHostObject = readImageDataHOFromFile(runtime, filePath);
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageDataHostObject));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(readFromFileFcn));
-        }
-    }
-
-    void install_imageIO_readFromMemory(Runtime &jsiRuntime) {
-        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_readFromMemory");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-            auto readFromMemoryFcn = Function::createFromHostFunction(jsiRuntime, nameID, 1, JSI_FUNC {
-                auto buffer = arguments[0].asObject(runtime).getArrayBuffer(runtime);
-                auto pBuffer = (unsigned char *) buffer.data(runtime);
-                auto len = (int) buffer.length(runtime);
-                auto imageDataHostObject = readImageDataHOFromMemory(runtime, pBuffer, len);
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageDataHostObject));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(readFromMemoryFcn));
-        }
-    }
-
-    void install_imageIO_saveToMemory(Runtime &jsiRuntime) {
-        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_saveToMemory");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-            auto saveToMemoryFcn = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                int fileFormat = arguments[1].asNumber();
-                auto arrayBuffer = saveImageDataHOToMemory(runtime, imageDataHostObject, fileFormat);
-                return arrayBuffer;
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(saveToMemoryFcn));
-        }
-    }
-
-    void install_imageDrawer_drawOnImage(Runtime &jsiRuntime) {
-        auto nameID = PropNameID::forAscii(jsiRuntime, "imageDrawer_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_imageProcessor_cropImage(Runtime &jsiRuntime) {
-        auto nameID = PropNameID::forAscii(jsiRuntime, "imageProcessor_cropImage");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-            auto cropImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                auto jsDsRect = arguments[1].asObject(runtime);
-                ImageDataHostObject imageHOAfterCrop = cropImage(runtime, imageDataHostObject, jsDsRect);
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropImageFcn));
-        }
-    }
-
-    void install_imageProcessor_cropAndDeskewImage(Runtime &jsiRuntime) {
-        auto nameID = PropNameID::forAscii(jsiRuntime, "imageProcessor_cropAndDeskewImage");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-            auto cropAndDeskewImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 5, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                auto jsQuads = arguments[1].asObject(runtime);
-                int dstWidth = arguments[2].asNumber();
-                int dstHeight = arguments[3].asNumber();
-                int padding = arguments[4].asNumber();
-                ImageDataHostObject imageHOAfterCrop = cropAndDeskewImage(runtime, imageDataHostObject, jsQuads, dstWidth, dstHeight, padding);
-                if (imageHOAfterCrop.buffer == nullptr) {
-                    return Value::undefined();
-                }
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropAndDeskewImageFcn));
-        }
-    }
-
-    void install_imageProcessor_adjustBrightness(Runtime &jsiRuntime) {
-        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_adjustBrightness");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
-            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                auto value = arguments[1].asNumber();
-                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_adjust_brightness);
-                if (imageHOAfter.buffer == nullptr) {
-                    return Value::undefined();
-                }
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
-        }
-    }
-
-    void install_imageProcessor_adjustContrast(Runtime &jsiRuntime) {
-        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_adjustContrast");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
-            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                auto value = arguments[1].asNumber();
-                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_adjust_contrast);
-                if (imageHOAfter.buffer == nullptr) {
-                    return Value::undefined();
-                }
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
-        }
-    }
-
-    void install_imageProcessor_filterImage(Runtime &jsiRuntime) {
-        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_filterImage");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
-            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                auto value = arguments[1].asNumber();
-                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_filter);
-                if (imageHOAfter.buffer == nullptr) {
-                    return Value::undefined();
-                }
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
-        }
-    }
-
-    void install_imageProcessor_convertToGray(Runtime &jsiRuntime) {
-        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToGray");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
-            auto convertToGrayFcn = Function::createFromHostFunction(jsiRuntime, nameId, 4, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                float r = arguments[1].asNumber();
-                float g = arguments[2].asNumber();
-                float b = arguments[3].asNumber();
-                ImageDataHostObject grayImageHO = convertToGray(runtime, imageDataHostObject, r, g, b);
-                if (grayImageHO.buffer == nullptr) {
-                    return Value::undefined();
-                }
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(grayImageHO));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToGrayFcn));
-        }
-    }
-
-    void install_imageProcessor_convertToBinaryGlobal(Runtime &jsiRuntime) {
-        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToBinaryGlobal");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
-            auto convertToBinaryGlobalFcn = Function::createFromHostFunction(jsiRuntime, nameId, 3, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                int threshold = arguments[1].asNumber();
-                bool isInvert = arguments[2].asBool();
-                ImageDataHostObject binaryImageHO = convertToBinaryGlobal(runtime, imageDataHostObject, threshold, isInvert);
-                if (binaryImageHO.buffer == nullptr) {
-                    return Value::undefined();
-                }
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(binaryImageHO));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToBinaryGlobalFcn));
-        }
-    }
-
-    void install_imageProcessor_convertToBinaryLocal(Runtime &jsiRuntime) {
-        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToBinaryLocal");
-        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
-            auto convertToBinaryLocalFcn = Function::createFromHostFunction(jsiRuntime, nameId, 4, JSI_FUNC {
-                auto imageDataObj = arguments[0].asObject(runtime);
-                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-                int blockSize = arguments[1].asNumber();
-                int compensation = arguments[2].asNumber();
-                bool isInvert = arguments[3].asBool();
-                ImageDataHostObject binaryImageHO = convertToBinaryLocal(runtime, imageDataHostObject, blockSize, compensation, isInvert);
-                if (binaryImageHO.buffer == nullptr) {
-                    return Value::undefined();
-                }
-                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(binaryImageHO));
-            });
-            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToBinaryLocalFcn));
-        }
-    }
-} //namespace jsi_install::utility
-
-void install_imageManager_methods(Runtime &jsiRuntime) {
-    jsi_install::utility::install_imageIO_saveToFile(jsiRuntime);
-    jsi_install::utility::install_imageIO_readFromFile(jsiRuntime);
-    jsi_install::utility::install_imageIO_readFromMemory(jsiRuntime);
-    jsi_install::utility::install_imageIO_saveToMemory(jsiRuntime);
-    jsi_install::utility::install_imageDrawer_drawOnImage(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_cropImage(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_cropAndDeskewImage(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_adjustBrightness(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_adjustContrast(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_filterImage(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_convertToGray(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_convertToBinaryGlobal(jsiRuntime);
-    jsi_install::utility::install_imageProcessor_convertToBinaryLocal(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"));
-    }
-    if (jclzDSRect == nullptr) {
-        jclzDSRect = (jclass) env->NewWeakGlobalRef(env->FindClass("com/dynamsoft/core/basic_structures/DSRect"));
-    }
-    auto rt = reinterpret_cast<Runtime *>(jsiPtr);
-    install_imageManager_methods(*rt);
-}
+//
+// Created by Allen on 24/09/23.
+//
+
+#include "JsiUtility.h"
+#include "RawBuffer.h"
+
+jobject jImageManagerModule = nullptr;
+jclass jclzQuad = nullptr;
+jclass jclzPoint = nullptr;
+jclass jclzDSRect = nullptr;
+
+using namespace facebook::jsi;
+
+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;
+}
+
+jobject jsDsRectToJobject(Runtime &rt, JNIEnv *env, Object &jsDSRect) {
+    if (!jsDSRect.hasProperty(rt, "left") || !jsDSRect.hasProperty(rt, "top") || !jsDSRect.hasProperty(rt, "right") || !jsDSRect.hasProperty(rt, "bottom") ||
+        !jsDSRect.hasProperty(rt, "measuredInPercentage")) {
+        return nullptr;
+    }
+    float top = (float) jsDSRect.getProperty(rt, "top").asNumber();
+    float left = (float) jsDSRect.getProperty(rt, "left").asNumber();
+    float bottom = (float) jsDSRect.getProperty(rt, "bottom").asNumber();
+    float right = (float) jsDSRect.getProperty(rt, "right").asNumber();
+    bool measuredInPercentage = jsDSRect.getProperty(rt, "measuredInPercentage").asBool();
+    jmethodID init = env->GetMethodID(jclzDSRect, "<init>", "(FFFFZ)V");
+    jobject jDSRect = env->NewObject(jclzDSRect, init, left, top, right, bottom, measuredInPercentage);
+    return jDSRect;
+}
+
+
+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 readImageDataHOFromFile(Runtime &rt, string filePath) {
+    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, "readFromFileCalledInJsi", "(Ljava/lang/String;)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    jstring jFilePath = env->NewStringUTF(filePath.c_str());
+    auto jImageData = env->CallObjectMethod(jImageManagerModule, methodId, jFilePath);
+    ImageDataHostObject imageHO;
+    jsiConversion::core::getHOFromJImageData(env, jImageData, imageHO);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jFilePath);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHO;
+}
+
+ImageDataHostObject readImageDataHOFromMemory(Runtime &rt, unsigned char *buffer, int bufferSize) {
+    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, "readFromMemoryCalledInJsi", "([B)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jBuffer = env->NewByteArray(bufferSize);
+    env->SetByteArrayRegion(jBuffer, 0, bufferSize, (jbyte *) buffer);
+    auto jImageData = env->CallObjectMethod(jImageManagerModule, methodId, jBuffer);
+    ImageDataHostObject imageHO;
+    jsiConversion::core::getHOFromJImageData(env, jImageData, imageHO);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jBuffer);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHO;
+}
+
+ArrayBuffer saveImageDataHOToMemory(Runtime &rt, ImageDataHostObject &imageDataHO, int fileFormat) {
+    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, "saveToMemoryCalledInJsi", "(Lcom/dynamsoft/core/basic_structures/ImageData;I)[B");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jBuffer = (jbyteArray) env->CallObjectMethod(jImageManagerModule, methodId, jImageData, fileFormat);
+    auto pBuffer = (uint8_t *) env->GetByteArrayElements(jBuffer, nullptr);
+    int bufferSize = env->GetArrayLength(jBuffer);
+    auto mutableBuffer = std::make_shared<MutableRawBuffer>(pBuffer, bufferSize, false);
+    ArrayBuffer arrayBuffer(rt, mutableBuffer);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    return arrayBuffer;
+}
+
+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 &jsDSRect) {
+    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/DSRect;)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jDSRect = jsDsRectToJobject(rt, env, jsDSRect);
+    auto jImageDataAfterCrop = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jDSRect);
+    ImageDataHostObject imageHOAfterCrop;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterCrop, imageHOAfterCrop);
+    env->DeleteLocalRef(jDSRect);
+    env->DeleteLocalRef(jImageDataAfterCrop);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterCrop;
+}
+
+ImageDataHostObject cropAndDeskewImage(Runtime &rt, ImageDataHostObject &imageDataHO, Object &jsQuad, int dstWidth, int dstHeight, int padding) {
+    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, "cropAndDeskewImageCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;Lcom/dynamsoft/core/basic_structures/Quadrilateral;III)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jQuad = jsQuadToJobject(rt, env, jsQuad);
+    auto jImageDataAfterCropAndDeskew = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jQuad, dstWidth, dstHeight, padding);
+    ImageDataHostObject imageHOAfterCrop;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterCropAndDeskew, imageHOAfterCrop);
+    env->DeleteLocalRef(jQuad);
+    env->DeleteLocalRef(jImageDataAfterCropAndDeskew);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterCrop;
+}
+
+
+const int type_adjust_brightness = 0;
+const int type_adjust_contrast = 1;
+const int type_filter = 2;
+
+ImageDataHostObject adjustOrFilter(Runtime &rt, ImageDataHostObject &imageDataHO, int value, int type) {
+    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;
+    switch (type) {
+        case type_adjust_brightness:
+            methodId = env->GetMethodID(clz, "adjustBrightnessCalledInJsi",
+                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
+            break;
+        case type_adjust_contrast:
+            methodId = env->GetMethodID(clz, "adjustContrastCalledInJsi",
+                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
+            break;
+        case type_filter:
+        default:
+            methodId = env->GetMethodID(clz, "filterImageCalledInJsi",
+                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
+            break;
+    }
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfter = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, value);
+    ImageDataHostObject imageHOAfter;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfter, imageHOAfter);
+    env->DeleteLocalRef(jImageDataAfter);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfter;
+}
+
+ImageDataHostObject convertToGray(Runtime &rt, ImageDataHostObject &imageDataHO, float r, float g, float b) {
+    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, "convertToGrayCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;FFF)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, r, g, b);
+    ImageDataHostObject imageHOAfterConvert;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
+    env->DeleteLocalRef(jImageDataAfterConvert);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterConvert;
+}
+
+ImageDataHostObject convertToBinaryGlobal(Runtime &rt, ImageDataHostObject &imageDataHO, int threshold, bool invert) {
+    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, "convertToBinaryGlobalCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;IZ)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, threshold, invert);
+    ImageDataHostObject imageHOAfterConvert;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
+    env->DeleteLocalRef(jImageDataAfterConvert);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterConvert;
+}
+
+ImageDataHostObject convertToBinaryLocal(Runtime &rt, ImageDataHostObject &imageDataHO, int blockSize, int compensation, bool invert) {
+    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, "convertToBinaryLocalCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;IIZ)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, blockSize, compensation, invert);
+    ImageDataHostObject imageHOAfterConvert;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
+    env->DeleteLocalRef(jImageDataAfterConvert);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterConvert;
+}
+
+
+#define JSI_FUNC [](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value
+
+namespace jsi_install::utility {
+    void install_imageIO_saveToFile(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_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_imageIO_readFromFile(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_readFromFile");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto readFromFileFcn = Function::createFromHostFunction(jsiRuntime, nameID, 1, JSI_FUNC {
+                auto filePath = arguments[0].asString(runtime).utf8(runtime);
+                auto imageDataHostObject = readImageDataHOFromFile(runtime, filePath);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageDataHostObject));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(readFromFileFcn));
+        }
+    }
+
+    void install_imageIO_readFromMemory(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_readFromMemory");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto readFromMemoryFcn = Function::createFromHostFunction(jsiRuntime, nameID, 1, JSI_FUNC {
+                auto buffer = arguments[0].asObject(runtime).getArrayBuffer(runtime);
+                auto pBuffer = (unsigned char *) buffer.data(runtime);
+                auto len = (int) buffer.length(runtime);
+                auto imageDataHostObject = readImageDataHOFromMemory(runtime, pBuffer, len);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageDataHostObject));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(readFromMemoryFcn));
+        }
+    }
+
+    void install_imageIO_saveToMemory(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_saveToMemory");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto saveToMemoryFcn = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                int fileFormat = arguments[1].asNumber();
+                auto arrayBuffer = saveImageDataHOToMemory(runtime, imageDataHostObject, fileFormat);
+                return arrayBuffer;
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(saveToMemoryFcn));
+        }
+    }
+
+    void install_imageDrawer_drawOnImage(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageDrawer_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_imageProcessor_cropImage(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageProcessor_cropImage");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto cropImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto jsDsRect = arguments[1].asObject(runtime);
+                ImageDataHostObject imageHOAfterCrop = cropImage(runtime, imageDataHostObject, jsDsRect);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropImageFcn));
+        }
+    }
+
+    void install_imageProcessor_cropAndDeskewImage(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageProcessor_cropAndDeskewImage");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto cropAndDeskewImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 5, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto jsQuads = arguments[1].asObject(runtime);
+                int dstWidth = arguments[2].asNumber();
+                int dstHeight = arguments[3].asNumber();
+                int padding = arguments[4].asNumber();
+                ImageDataHostObject imageHOAfterCrop = cropAndDeskewImage(runtime, imageDataHostObject, jsQuads, dstWidth, dstHeight, padding);
+                if (imageHOAfterCrop.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropAndDeskewImageFcn));
+        }
+    }
+
+    void install_imageProcessor_adjustBrightness(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_adjustBrightness");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto value = arguments[1].asNumber();
+                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_adjust_brightness);
+                if (imageHOAfter.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
+        }
+    }
+
+    void install_imageProcessor_adjustContrast(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_adjustContrast");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto value = arguments[1].asNumber();
+                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_adjust_contrast);
+                if (imageHOAfter.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
+        }
+    }
+
+    void install_imageProcessor_filterImage(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_filterImage");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto value = arguments[1].asNumber();
+                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_filter);
+                if (imageHOAfter.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
+        }
+    }
+
+    void install_imageProcessor_convertToGray(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToGray");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto convertToGrayFcn = Function::createFromHostFunction(jsiRuntime, nameId, 4, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                float r = arguments[1].asNumber();
+                float g = arguments[2].asNumber();
+                float b = arguments[3].asNumber();
+                ImageDataHostObject grayImageHO = convertToGray(runtime, imageDataHostObject, r, g, b);
+                if (grayImageHO.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(grayImageHO));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToGrayFcn));
+        }
+    }
+
+    void install_imageProcessor_convertToBinaryGlobal(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToBinaryGlobal");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto convertToBinaryGlobalFcn = Function::createFromHostFunction(jsiRuntime, nameId, 3, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                int threshold = arguments[1].asNumber();
+                bool isInvert = arguments[2].asBool();
+                ImageDataHostObject binaryImageHO = convertToBinaryGlobal(runtime, imageDataHostObject, threshold, isInvert);
+                if (binaryImageHO.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(binaryImageHO));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToBinaryGlobalFcn));
+        }
+    }
+
+    void install_imageProcessor_convertToBinaryLocal(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToBinaryLocal");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto convertToBinaryLocalFcn = Function::createFromHostFunction(jsiRuntime, nameId, 4, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                int blockSize = arguments[1].asNumber();
+                int compensation = arguments[2].asNumber();
+                bool isInvert = arguments[3].asBool();
+                ImageDataHostObject binaryImageHO = convertToBinaryLocal(runtime, imageDataHostObject, blockSize, compensation, isInvert);
+                if (binaryImageHO.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(binaryImageHO));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToBinaryLocalFcn));
+        }
+    }
+} //namespace jsi_install::utility
+
+void install_imageManager_methods(Runtime &jsiRuntime) {
+    jsi_install::utility::install_imageIO_saveToFile(jsiRuntime);
+    jsi_install::utility::install_imageIO_readFromFile(jsiRuntime);
+    jsi_install::utility::install_imageIO_readFromMemory(jsiRuntime);
+    jsi_install::utility::install_imageIO_saveToMemory(jsiRuntime);
+    jsi_install::utility::install_imageDrawer_drawOnImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_cropImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_cropAndDeskewImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_adjustBrightness(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_adjustContrast(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_filterImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_convertToGray(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_convertToBinaryGlobal(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_convertToBinaryLocal(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"));
+    }
+    if (jclzDSRect == nullptr) {
+        jclzDSRect = (jclass) env->NewWeakGlobalRef(env->FindClass("com/dynamsoft/core/basic_structures/DSRect"));
+    }
+    auto rt = reinterpret_cast<Runtime *>(jsiPtr);
+    install_imageManager_methods(*rt);
+}