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

package/LICENSE

@@ -1,5 +1,5 @@
 License Notice
  
-The source code of the Dynamsoft Capture Vision (DCV) React Native Edition published here is released under the Apache 2.0 license: http://www.apache.org/licenses/LICENSE-2.0. Dynamsoft Barcode Reader (DBR) and Dynamsoft Camera Enhancer (DCE) SDK upon which Dynamsoft Capture Vision (DCV) depends are provided under a commercial license from https://www.dynamsoft.com/company/license-agreement/.  This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- 
+The source code of the Dynamsoft Capture Vision (DCV) React Native Edition published here is released under the Apache 2.0 license: http://www.apache.org/licenses/LICENSE-2.0. Dynamsoft Barcode Reader (DBR), Dynamsoft Label Recognizer (DLR), Dynamsoft Document Normalizer (DDN), Dynamsoft Code Parser (DCP) and Dynamsoft Camera Enhancer (DCE) SDK upon which Dynamsoft Capture Vision (DCV) React Native Edition depends are provided under a commercial license from https://www.dynamsoft.com/company/license-agreement/.  This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+
 Copyright © 2003–2025 Dynamsoft. All Rights Reserved.

package/README.md

@@ -32,7 +32,7 @@ DCV enables you to develop highly customizable applications for barcode reading,
 
 ### iOS
 
-- Supported OS: iOS 11+ (iOS 13+ recommended).
+- Supported OS: iOS 13+.
 - Supported ABI: arm64 and x86_64.
 - Development Environment: Xcode 13+ (Xcode 14.1+ recommended).
 
@@ -41,20 +41,18 @@ DCV enables you to develop highly customizable applications for barcode reading,
 - Node: 18 or higher
 
 ## User Guide
-- [Foundation Barcode Reader Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/foundation-barcode-reader-guide.md)
-- [Ready-to-use Barcode Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/ready-to-use-barcode-scanner-guide.md)
-- [Document Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/document-scanner-guide.md)
-- [MRZ Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/mrz-scanner-guide.md)
-- [Divers' License Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/drivers-license-scanner-guide.md)
+
+- [MRZ Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/guide-scan-mrz.md)
+- [Document Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/guide-scan-document.md)
+- [VIN Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/guide-scan-vin.md)
 
 ## Samples
 
 You can view all the DCV React Native samples via the following links:
 
-- [ScanBarcodes](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/main/ScanBarcodes)
-- [DetectAndDeskewDocument](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/main/DetectAndDeskewDocument)
 - [ScanMRZ](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/main/ScanMRZ)
-- [ReadDriverLicense](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/main/ReadDriverLicense)
+- [ScanDocument](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/main/ScanDocument)
+- [ScanVIN](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/main/ScanVIN)
 
 ## License
 

package/android/build.gradle

@@ -8,10 +8,7 @@ def safeExtGet(prop, fallback) {
 
 apply plugin: 'com.android.library'
 apply plugin: "kotlin-android"
-def isNewArchitectureEnabled = rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-if (isNewArchitectureEnabled) {
-    apply plugin: "com.facebook.react"
-}
+
 buildscript {
     def kotlinVersion = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["kotlinVersion"]
     repositories {
@@ -24,32 +21,43 @@ buildscript {
     }
 }
 
-def resolveBuildType() {
-    Gradle gradle = getGradle()
-    String tskReqStr = gradle.getStartParameter().getTaskRequests()['args'].toString()
-
-    return tskReqStr.contains('Release') ? 'release' : 'debug'
-}
-
-def supportsNamespace() {
+static def supportsNamespace() {
     def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
     def major = parsed[0].toInteger()
     def minor = parsed[1].toInteger()
-
-    // Namespace support was added in 7.3.0
     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 {
-        main {
-            manifest.srcFile supportsNamespace()?
-                    "src/main/withoutNamespace/AndroidManifest.xml":
-                    "src/main/withNamespace/AndroidManifest.xml"
-            java.srcDirs += isNewArchitectureEnabled? ["src/newarch"] : ["src/oldarch"]
+        sourceSets {
+            main {
+                manifest.srcFile "src/main/AndroidManifest_noPackage.xml"
+            }
         }
     }
 
@@ -59,17 +67,48 @@ android {
         targetSdkVersion safeExtGet('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
         versionCode 1
         versionName "1.0"
-//        externalNativeBuild {
-//            cmake {
-//                cppFlags "-O2 -frtti -fexceptions -Wall -Wno-unused-variable -fstack-protector-all"
-//                arguments "-DANDROID_STL=c++_shared"
-//            }
-//        }
-        buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled.toString())
+
+        if(versionNumber < 79) {
+            externalNativeBuild {
+                cmake {
+                    arguments "-DANDROID_STL=c++_shared"
+                }
+            }
+        }
     }
     lintOptions {
         abortOnError false
     }
+
+    if(versionNumber < 79) {
+        buildFeatures {
+            prefab true
+            buildConfig true
+        }
+        externalNativeBuild {
+            cmake {
+                path "src/main/cpp/CMakeLists.txt"
+            }
+        }
+    } else {
+        buildTypes {
+            release {
+                sourceSets {
+                    main {
+                        jniLibs.srcDirs = ["src/main/dysJniLibs/release"]
+                    }
+                }
+            }
+            debug {
+                sourceSets {
+                    main {
+                        jniLibs.srcDirs = ["src/main/dysJniLibs/debug"]
+                    }
+                }
+            }
+        }
+    }
+
 }
 
 repositories {
@@ -91,8 +130,13 @@ rootProject.allprojects {
             url "https://download2.dynamsoft.com/maven/aar"
         }
     }
+
+    configurations.all {
+        resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
+    }
 }
 
+
 dependencies {
     def kotlinVersion = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["kotlinVersion"]
 
@@ -105,18 +149,5 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
 
-    implementation("com.dynamsoft:dynamsoftcapturevisionbundle:2.6.1003") {
-        exclude(group: "com.dynamsoft", module: "dynamsoftcameraenhancer")
-    }
-
-    implementation "com.dynamsoft:mrzscannerbundle:2.0.1@aar"
-
-    implementation "com.dynamsoft:dynamsoftbarcodereaderbundle:10.4.3003-beta1@aar"
-    implementation "com.dynamsoft:dynamsoftcameraenhancer:4.2.23-beta2@aar"
-
-    def camerax_version = '1.4.0'
-    api "androidx.camera:camera-core:$camerax_version"
-    api "androidx.camera:camera-camera2:$camerax_version"
-    api "androidx.camera:camera-lifecycle:$camerax_version"
-    api "androidx.camera:camera-view:$camerax_version"
+    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);
+    }
+}