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

package/android/build.gradle

@@ -28,7 +28,30 @@ static def supportsNamespace() {
     return (major == 7 && minor >= 3) || major >= 8
 }
 
+
+def getReactNativeVersion() {
+    def packageJsonFile = file("$rootDir/../node_modules/react-native/package.json")
+    if (packageJsonFile.exists()) {
+        def packageJson = new groovy.json.JsonSlurper().parseText(packageJsonFile.text)
+        return packageJson.version
+    }
+    return "unknown"
+}
+
+static def getMajor(String version) {
+    def parts = version.tokenize('.')
+    return parts.size() > 0 ? parts[0].toInteger() : 0
+}
+
+static def getMinor(String version) {
+    def parts = version.tokenize('.')
+    return parts.size() > 1 ? parts[1].toInteger() : 0
+}
+
 android {
+    def reactNativeVersion = getReactNativeVersion()
+    def versionNumber = getMajor(reactNativeVersion) * 100 + getMinor(reactNativeVersion)
+
     if (supportsNamespace()) {
         namespace "com.dynamsoft.reactnativelib"
         sourceSets {
@@ -44,27 +67,48 @@ android {
         targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
         versionCode 1
         versionName "1.0"
+
+        if(versionNumber < 79) {
+            externalNativeBuild {
+                cmake {
+                    arguments "-DANDROID_STL=c++_shared"
+                }
+            }
+        }
     }
     lintOptions {
         abortOnError false
     }
 
-    buildTypes {
-        release {
-            sourceSets {
-                main {
-                    jniLibs.srcDirs = ["src/main/jniLibs/release"]
-                }
+    if(versionNumber < 79) {
+        buildFeatures {
+            prefab true
+            buildConfig true
+        }
+        externalNativeBuild {
+            cmake {
+                path "src/main/cpp/CMakeLists.txt"
             }
         }
-        debug {
-            sourceSets {
-                main {
-                    jniLibs.srcDirs = ["src/main/jniLibs/debug"]
+    } else {
+        buildTypes {
+            release {
+                sourceSets {
+                    main {
+                        jniLibs.srcDirs = ["src/main/dysJniLibs/release"]
+                    }
+                }
+            }
+            debug {
+                sourceSets {
+                    main {
+                        jniLibs.srcDirs = ["src/main/dysJniLibs/debug"]
+                    }
                 }
             }
         }
     }
+
 }
 
 repositories {
@@ -105,5 +149,5 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
 
-    implementation "com.dynamsoft:capturevisionbundle:3.0.3100"
+    implementation "com.dynamsoft:capturevisionbundle:3.0.5000"
 }

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project("rn_dys")
+
+file(GLOB SRC_FILES "*.cpp")
+
+add_library(${CMAKE_PROJECT_NAME} SHARED
+    ${SRC_FILES})
+
+find_package(ReactAndroid REQUIRED CONFIG)
+
+target_link_libraries(${CMAKE_PROJECT_NAME}
+    ReactAndroid::jsi   # <-- RN: JSI
+    android
+    log)
+
+target_link_options(${CMAKE_PROJECT_NAME} PRIVATE
+        "-Wl,-z,max-page-size=16384"
+        "-Wl,--gc-sections"
+        "-Wl,--strip-all"
+        "-s"
+)

package/android/src/main/cpp/ImgHO.cpp

@@ -0,0 +1,95 @@
+//
+// Created by Allen on 24/08/26.
+//
+
+#include "ImgHO.h"
+#include "RawBuffer.h"
+#include "android_log.h"
+
+#define JSI_FUNC [=](Runtime & runtime, const Value& thisValue, const Value* arguments, size_t count) -> Value
+#define GET_VALUE(X) if(name==#X){return this->X;}
+#define SET_INT_VALUE(X) if(name==#X){this->X = (int) value.asNumber();}
+
+ImageDataHostObject::ImageDataHostObject(int width, int height, int stride, int format, int orientation, uint8_t *buffer, int bufferSize)
+        : width(width), height(height), stride(stride), format(format), orientation(orientation), buffer(buffer), bufferSize(bufferSize) {
+}
+
+ImageDataHostObject ImageDataHostObject::getHOFromObject(Runtime &runtime, Object jsObj) {
+    if (jsObj.isHostObject(runtime)) {
+        return *((ImageDataHostObject *) (jsObj.asHostObject(runtime).get()));
+    }
+    ImageDataHostObject imageHO;
+    int width = jsObj.hasProperty(runtime, "width") ? (int) jsObj.getProperty(runtime, "width").asNumber() : 0;
+    int height = jsObj.hasProperty(runtime, "height") ? (int) jsObj.getProperty(runtime, "height").asNumber() : 0;
+    int stride = jsObj.hasProperty(runtime, "stride") ? (int) jsObj.getProperty(runtime, "stride").asNumber() : 0;
+    int format = jsObj.hasProperty(runtime, "format") ? (int) jsObj.getProperty(runtime, "format").asNumber() : 0;
+    int orientation = jsObj.hasProperty(runtime, "orientation") ? (int) jsObj.getProperty(runtime, "orientation").asNumber() : 0;
+    uint8_t *buffer = nullptr;
+    int bufferSize = 0;
+    if (jsObj.hasProperty(runtime, "buffer")) {
+        ArrayBuffer array_buffer = jsObj.getProperty(runtime, "buffer").asObject(runtime).getArrayBuffer(runtime);
+        buffer = array_buffer.data(runtime);
+        bufferSize = (int) array_buffer.length(runtime);
+    }
+    return ImageDataHostObject(width, height, stride, format, orientation, buffer, bufferSize);
+}
+
+Value ImageDataHostObject::get(Runtime &runtime, const PropNameID &propName) {
+    auto name = propName.utf8(runtime);
+    GET_VALUE(width)
+    GET_VALUE(height)
+    GET_VALUE(stride)
+    GET_VALUE(format)
+    GET_VALUE(orientation)
+    GET_VALUE(bufferSize)
+    //todo
+    if (name == "buffer") {
+        auto mutableBuffer = std::make_shared<MutableRawBuffer>(buffer, bufferSize, false);
+        return ArrayBuffer(runtime, mutableBuffer);
+    }
+
+    if (name == "release") {
+        auto release = JSI_FUNC {
+            if(buffer != nullptr) {
+                delete[] buffer;
+                buffer = nullptr;
+                bufferSize = 0;
+            }
+            return {};
+        };
+        return Function::createFromHostFunction(runtime, PropNameID::forUtf8(runtime, "release"), 0, release);
+    }
+    return {};
+}
+
+void ImageDataHostObject::set(Runtime &runtime, const PropNameID &propName, const Value &value) {
+    auto name = propName.utf8(runtime);
+    SET_INT_VALUE(width)
+    SET_INT_VALUE(height)
+    SET_INT_VALUE(stride)
+    SET_INT_VALUE(format)
+    SET_INT_VALUE(orientation)
+    //todo
+    if (name == "buffer") {
+        auto arrayBuffer = value.asObject(runtime).getArrayBuffer(runtime);
+        this->buffer = arrayBuffer.data(runtime);
+        this->bufferSize = (int) arrayBuffer.length(runtime);
+    }
+}
+
+std::vector<PropNameID> ImageDataHostObject::getPropertyNames(Runtime &rt) {
+    std::vector<PropNameID> result;
+    result.push_back(PropNameID::forUtf8(rt, std::string("width")));
+    result.push_back(PropNameID::forUtf8(rt, std::string("height")));
+    result.push_back(PropNameID::forUtf8(rt, std::string("stride")));
+    result.push_back(PropNameID::forUtf8(rt, std::string("format")));
+    result.push_back(PropNameID::forUtf8(rt, std::string("orientation")));
+    result.push_back(PropNameID::forUtf8(rt, std::string("buffer")));
+    result.push_back(PropNameID::forUtf8(rt, std::string("release")));
+    return result;
+}
+
+void ImageDataHostObject::logString(const char *preStr) const {
+    LOGI("%s wid:%d, hgt:%d, stride:%d, format:%d, orientation:%d, bufferSize:%d, buffer:%p, this:%p",
+         preStr, width, height, stride, format, orientation, bufferSize, buffer, this);
+}

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

@@ -0,0 +1,34 @@
+//
+// Created by Allen on 24/08/26.
+//
+
+#ifndef REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CORE_IMAGEDATAHOSTOBJECT_H_
+#define REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CORE_IMAGEDATAHOSTOBJECT_H_
+
+#include "jsi/jsi.h"
+
+using namespace facebook::jsi;
+
+class ImageDataHostObject : public HostObject {
+  public:
+    int width = 0;
+    int height = 0;
+    int stride = 0;
+    int format = 0;
+    int orientation = 0;
+
+    uint8_t *buffer = nullptr;
+    int bufferSize = 0;
+
+    explicit ImageDataHostObject() = default;
+    explicit ImageDataHostObject(int width, int height, int stride, int format, int orientation, uint8_t *buffer, int bufferSize);
+
+    Value get(Runtime &, const PropNameID &name) override;
+    void set(Runtime &, const PropNameID &name, const Value &value) override;
+    std::vector<PropNameID> getPropertyNames(Runtime &rt) override;
+
+    static ImageDataHostObject getHOFromObject(Runtime &runtime, Object jsObj);
+    void logString(const char *preStr = "ImageDataHostObject") const;
+};
+
+#endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_CORE_IMAGEDATAHOSTOBJECT_H_

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

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

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

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