dynamsoft-capture-vision-react-native 2.4.2000-alpha.2 → 2.6.1002

package/LICENSE

@@ -0,0 +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.
+ 
+Copyright © 2003–2025 Dynamsoft. All Rights Reserved.

package/README.md

@@ -18,17 +18,45 @@ DCV powers your software development through the following aspects:
 
 DCV enables you to develop highly customizable applications for barcode reading, label recognition, document board detection, and result parsing. These applications offer enterprise-grade performance and can be tailored to meet your specific business needs.
 
+## System Requirements
+
+### React Native
+
+- Supported Version: 0.71.0 or higher
+
+### Android
+
+- Supported OS: Android 5.0 (API Level 21) or higher.
+- Supported ABI: armeabi-v7a, arm64-v8a, x86 and x86_64.
+- Development Environment: Android Studio 2022.2.1 or higher.
+
+### iOS
+
+- Supported OS: iOS 11+ (iOS 13+ recommended).
+- Supported ABI: arm64 and x86_64.
+- Development Environment: Xcode 13+ (Xcode 14.1+ recommended).
+
+### Others
+
+- Node: 18 or higher
+
+## User Guide
+
+- [Barcode Reader Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/ScanSingleBarcode/barcode-reader-integration-guide.md)
+- [Document Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/DetectAndDeskewDocument/document-scanner-integration-guide.md)
+- [MRZ Scanner Integration Guide](https://github.com/Dynamsoft/capture-vision-react-native-samples/blob/main/ScanMRZ/mrz-scanner-integration-guide.md)
+
 ## Samples
 
 You can view all the DCV React Native samples via the following links:
 
-- [Barcode reader simple sample](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/v2.x-alpha/BarcodeReaderSimpleSample)
-- [Document Scanner](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/v2.x-alpha/DocumentNormalizerSimpleSample)
-- [MRZ Scanner](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/v2.x-alpha/MRZScanner)
+- [ScanSingleBarcode](https://github.com/Dynamsoft/capture-vision-react-native-samples/tree/main/ScanSingleBarcode)
+- [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)
 
 ## License
 
-- You can also request an extension for your trial license in the [customer portal](https://www.dynamsoft.com/customer/license/trialLicense?product=dcv&utm_source=github)
+- You can request a 30-day trial license via the [Request a Trial License](https://www.dynamsoft.com/customer/license/trialLicense?product=dcv&utm_source=npm&package=mobile) link.
 
 ## Contact
 

package/android/build.gradle

@@ -110,10 +110,6 @@ rootProject.allprojects {
         maven {
             url "https://download2.dynamsoft.com/maven/aar"
         }
-        maven {
-            url "http://192.168.8.101:8081/repository/maven-dynamsoft-public/"
-            allowInsecureProtocol true
-        }
     }
 }
 
@@ -129,5 +125,5 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
 
-    implementation "com.dynamsoft:dynamsoftcapturevisionbundle:2.4.2000"
+    implementation "com.dynamsoft:dynamsoftcapturevisionbundle:2.6.1002"
 }

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

@@ -1,36 +1,46 @@
 package com.dynamsoft.reactnativelib.dce
 
-import android.annotation.SuppressLint
 import android.graphics.PointF
 import android.util.Log
-import androidx.annotation.MainThread
 import androidx.lifecycle.Lifecycle
-import com.dynamsoft.dce.*
+import com.dynamsoft.dce.CameraEnhancer
+import com.dynamsoft.dce.CameraView
+import com.dynamsoft.dce.EnumCameraPosition
+import com.dynamsoft.dce.EnumFocusMode
+import com.dynamsoft.dce.Feedback
 import com.dynamsoft.dce.utils.PermissionUtil
 import com.dynamsoft.reactnative.dce.utils.CameraLifeCycleOwner
 import com.dynamsoft.reactnativelib.core.ImageSourceAdapterModuleImpl.Companion.mapISA
 import com.dynamsoft.reactnativelib.utils.toScanRegion
 import com.dynamsoft.reactnativelib.utils.toWritableMap
-import com.facebook.react.bridge.*
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.UIManagerHelper
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
-import kotlin.coroutines.suspendCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
 
 
 class CameraEnhancerModuleImpl(private val reactContext: ReactApplicationContext) : LifecycleEventListener {
     companion object {
         const val NAME = "DynamsoftCameraView"
-        const val TAG = "CameraEnhancerModuleImpl"
+        const val TAG = "CameraEnhancerModule"
     }
 
+    private var ifOpenCalled = false
     private var cameraLifecycleOwner = CameraLifeCycleOwner()
-    private var camera: CameraEnhancer? = null
-    private var currentCameraViewId:Int? = null
+    private var camera: CameraEnhancer = CameraEnhancer(cameraLifecycleOwner).apply {
+        mapISA[this.toString()] = this
+    }
+    private var currentCameraViewId: Int? = null
 
     init {
         reactContext.addLifecycleEventListener(this)
@@ -41,12 +51,14 @@ class CameraEnhancerModuleImpl(private val reactContext: ReactApplicationContext
     override fun onHostResume() {
         cameraLifecycleOwner.lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_START)
         cameraLifecycleOwner.lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_RESUME)
+        if(ifOpenCalled) {
+            open()
+        }
     }
 
     override fun onHostPause() {
         cameraLifecycleOwner.lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE)
         cameraLifecycleOwner.lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
-
     }
 
     override fun onHostDestroy() {
@@ -62,105 +74,89 @@ class CameraEnhancerModuleImpl(private val reactContext: ReactApplicationContext
 
     @ReactMethod(isBlockingSynchronousMethod = true)
     fun createInstance(): String {
-        if (camera == null) {
-            camera = CameraEnhancer(cameraLifecycleOwner).apply {
-                mapISA[this.toString()] = this
-            }
-        }
-        return camera!!.toString()
+        return camera.toString()
     }
 
     @ReactMethod
     fun open() {
-        try {
-            camera?.apply {
-                open()
-                if(currentCameraViewId != null && (cameraView == null || cameraView.id != currentCameraViewId)) {
-                    setCameraView(currentCameraViewId!!)
-                }
-            }
-        } catch (e: CameraEnhancerException) {
-            e.printStackTrace()
+        ifOpenCalled = true
+        if (currentCameraViewId != null && (camera.cameraView == null || camera.cameraView?.id != currentCameraViewId)) {
+            findAndSetCameraView(currentCameraViewId!!) { camera.open() }
+        } else {
+            camera.open()
         }
     }
 
     @ReactMethod
     fun close() {
-        camera?.close()
+        ifOpenCalled = false
+        camera.close()
     }
 
-    @SuppressLint("LongLogTag")
     @ReactMethod
     fun setCameraView(viewTag: Int) {
         currentCameraViewId = viewTag
-        CoroutineScope(Dispatchers.Main).launch(CoroutineName("setCameraView")) {
-            try {
-                val cameraView = findCameraView(viewTag)
-                camera?.cameraView = cameraView
-            } catch (e: Exception) {
-                Log.w(TAG, "setCameraView: " + e.message )
-            }
-        }
+        findAndSetCameraView(viewTag)
     }
 
     @ReactMethod
     fun selectCamera(@EnumCameraPosition position: Int) {
-        camera?.selectCamera(position)
+        camera.selectCamera(position)
     }
 
     @ReactMethod
     fun getCameraPosition(promise: Promise) {
-        promise.resolve(camera?.cameraPosition)
+        promise.resolve(camera.cameraPosition)
     }
 
     @ReactMethod
     fun setFocus(x: Float, y: Float, @EnumFocusMode focusMode: Int) {
-        camera?.setFocus(PointF(x, y), focusMode)
+        camera.setFocus(PointF(x, y), focusMode)
     }
 
     @ReactMethod
     fun getFocusMode(promise: Promise) {
-        promise.resolve(camera?.focusMode)
+        promise.resolve(camera.focusMode)
     }
 
     @ReactMethod
     fun setZoomFactor(factor: Float) {
-        camera?.zoomFactor = factor
+        camera.zoomFactor = factor
     }
 
     @ReactMethod
     fun getZoomFactor(promise: Promise) {
-        promise.resolve(camera?.zoomFactor)
+        promise.resolve(camera.zoomFactor)
     }
 
     @ReactMethod
     fun enableEnhancedFeatures(features: Int) {
-        camera?.enableEnhancedFeatures(features)
+        camera.enableEnhancedFeatures(features)
     }
 
     @ReactMethod
     fun disableEnhancedFeatures(features: Int) {
-        camera?.disableEnhancedFeatures(features)
+        camera.disableEnhancedFeatures(features)
     }
 
     @ReactMethod
     fun setScanRegion(region: ReadableMap?) {
-        camera?.scanRegion = region?.toScanRegion()
+        camera.scanRegion = region?.toScanRegion()
     }
 
     @ReactMethod
     fun getScanRegion(promise: Promise) {
-        promise.resolve(camera?.scanRegion?.toWritableMap())
+        promise.resolve(camera.scanRegion?.toWritableMap())
     }
 
     @ReactMethod
     fun turnOnTorch() {
-        camera?.turnOnTorch()
+        camera.turnOnTorch()
     }
 
     @ReactMethod
     fun turnOffTorch() {
-        camera?.turnOffTorch()
+        camera.turnOffTorch()
     }
 
     @ReactMethod
@@ -173,24 +169,37 @@ class CameraEnhancerModuleImpl(private val reactContext: ReactApplicationContext
         Feedback.vibrate(reactContext)
     }
 
-    @SuppressLint("LongLogTag")
-    @MainThread
-    private suspend fun findCameraView(viewId: Int): CameraView =
-        suspendCoroutine { continuation ->
-            Log.d(TAG, "Finding view $viewId...")
-            val view = run {
-                val resolveView = UIManagerHelper.getUIManager(
-                    reactContext,
-                    viewId
-                )?.resolveView(viewId)
-                Log.d(TAG, "findCameraView: resolveView=$resolveView")
-                resolveView as CameraView?
+    private fun findAndSetCameraView(viewTag: Int, afterSetCameraView: () -> Unit = {}) {
+        CoroutineScope(Dispatchers.Default).launch(CoroutineName("setCameraView")) {
+            val cameraView = findCameraView(viewTag)
+            if (cameraView == null) {
+                Log.e(TAG, "setCameraView: Can't not find cameraView!(viewId = $viewTag)")
+                return@launch
+            }
+            MainScope().launch {
+                camera.cameraView = cameraView
+                afterSetCameraView()
+            }
+        }
+    }
+
+    private suspend fun findCameraView(viewId: Int): CameraView? = withTimeoutOrNull(300) {
+        while (true) {
+            val view = withContext(Dispatchers.Main) {
+                try {
+                    UIManagerHelper.getUIManager(reactContext, viewId)?.resolveView(viewId) as? CameraView
+                } catch (e: Exception) {
+                    null
+                }
             }
-            Log.d(TAG, "Found view $viewId!")
             if (view != null) {
-                continuation.resume(view)
-            } else {
-                continuation.resumeWithException(Exception("The given view (ID $viewId) was not found in the view manager."))
+                return@withTimeoutOrNull view
+            }
+            if (!isActive) {
+                break
             }
         }
+        return@withTimeoutOrNull null
+    }
+
 }

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

@@ -3,6 +3,7 @@ package com.dynamsoft.reactnative.dce
 import android.view.Choreographer
 import android.view.View
 import com.dynamsoft.dce.ImageEditorView
+import com.dynamsoft.reactnativelib.dce.RNImageEditorView
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
 
@@ -12,24 +13,7 @@ class ImageEditorViewManagerImpl  {
     }
     fun getName() = TAG
     fun createViewInstance(context: ThemedReactContext): ImageEditorView {
-        return ImageEditorView(context).apply {
-            Choreographer.getInstance().postFrameCallback(object : Choreographer.FrameCallback {
-                override fun doFrame(frameTimeNanos: Long) {
-                    manuallyMeasureAndLayout()
-                    viewTreeObserver.dispatchOnGlobalLayout()
-                    Choreographer.getInstance().postFrameCallback(this)
-                }
-            })
-        }
+        return RNImageEditorView(context)
     }
 
-    private fun View.manuallyMeasureAndLayout() {
-        measure(
-            View.MeasureSpec.makeMeasureSpec(measuredWidth, View.MeasureSpec.EXACTLY),
-            View.MeasureSpec.makeMeasureSpec(measuredHeight, View.MeasureSpec.EXACTLY)
-        )
-        layout(0, 0, measuredWidth, measuredHeight)
-    }
-
-
 }

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

@@ -2,24 +2,26 @@ package com.dynamsoft.reactnativelib.dce
 
 import android.util.Log
 import com.dynamsoft.core.basic_structures.ImageData
+import com.dynamsoft.dce.CameraView
 import com.dynamsoft.dce.DrawingItem
 import com.dynamsoft.dce.ImageEditorView
 import com.dynamsoft.dce.QuadDrawingItem
 import com.dynamsoft.reactnative.basicutils.toQuad
 import com.dynamsoft.reactnative.basicutils.toWritableMap
+import com.dynamsoft.reactnativelib.core.ImageSourceAdapterModuleImpl.Companion.nativeInstall
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.IllegalViewOperationException
 import com.facebook.react.uimanager.UIManagerHelper
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
-import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
-import kotlin.coroutines.suspendCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
 
 class ImageEditorViewModuleImpl(private val reactContext: ReactApplicationContext) {
     companion object {
@@ -31,80 +33,76 @@ class ImageEditorViewModuleImpl(private val reactContext: ReactApplicationContex
 
     @ReactMethod
     fun setQuads(viewTag: Int, readableArray: ReadableArray, layerId: Int, promise: Promise) {
-        CoroutineScope(Dispatchers.Main).launch(CoroutineName("setQuads")) {
-            try {
-                val imageEditorView = findImageEditorView(viewTag)
-                val drawingItems = ArrayList<DrawingItem<*>>();
-                for (i in 0 until readableArray.size()) {
-                    drawingItems.add(QuadDrawingItem(readableArray.getMap(i).toQuad()))
-                }
-                imageEditorView.getDrawingLayer(layerId).drawingItems = drawingItems
-                promise.resolve(null)
-            } catch (e: Exception) {
-                Log.w(TAG, "setQuads: " + e.message)
+        CoroutineScope(Dispatchers.Default).launch(CoroutineName("setQuads")) {
+            val imageEditorView = findImageEditorView(viewTag)
+            if(imageEditorView == null) {
+                Log.e(TAG, "setQuads: Can't not find imageEditorView!(viewId = $viewTag)")
                 promise.resolve(null)
+                return@launch
+            }
+            val drawingItems = ArrayList<DrawingItem<*>>()
+            for (i in 0 until readableArray.size()) {
+                drawingItems.add(QuadDrawingItem(readableArray.getMap(i).toQuad()))
             }
+            imageEditorView.getDrawingLayer(layerId).drawingItems = drawingItems
+            promise.resolve(null)
         }
     }
 
     @ReactMethod
     fun getSelectedQuad(viewTag: Int, promise: Promise) {
-        CoroutineScope(Dispatchers.Main).launch(CoroutineName("getSelectedQuad")) {
-            try{
-                val imageEditorView = findImageEditorView(viewTag)
-                val selectedDrawingItem = imageEditorView.selectedDrawingItem
-                if(selectedDrawingItem != null) {
-                    promise.resolve((selectedDrawingItem as QuadDrawingItem).quad.toWritableMap())
-                } else {
-                    promise.reject(Throwable("Please select an DrawingItem."))
-                }
-            } catch (e: Exception) {
-                Log.w(TAG, "getSelectedQuad: " + e.message)
+        CoroutineScope(Dispatchers.Default).launch(CoroutineName("getSelectedQuad")) {
+            val imageEditorView = findImageEditorView(viewTag)
+            if(imageEditorView == null) {
+                Log.e(TAG, "getSelectedQuad: Can't not find imageEditorView!(viewId = $viewTag)")
+                promise.resolve(null)
+                return@launch
+            }
+            val selectedDrawingItem = imageEditorView.selectedDrawingItem
+            if (selectedDrawingItem != null) {
+                promise.resolve((selectedDrawingItem as QuadDrawingItem).quad.toWritableMap())
+            } else {
                 promise.resolve(null)
             }
         }
     }
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    fun install() : Boolean {
+    fun install(): Boolean {
         reactContext.javaScriptContextHolder?.apply {
             nativeInstall(get())
         }
         return true
     }
 
-    private suspend fun findImageEditorView(viewId: Int): ImageEditorView =
-        suspendCoroutine { continuation ->
-            UiThreadUtil.runOnUiThread {
-                Log.d(TAG, "Finding view $viewId...")
-                val view = if (reactContext != null) {
-                    val resolveView = UIManagerHelper.getUIManager(
-                        reactContext,
-                        viewId
-                    )?.resolveView(viewId)
-                    Log.d(TAG, "findCameraView: resolveView=$resolveView")
-                    resolveView as ImageEditorView?
-                } else {
+    private suspend fun findImageEditorView(viewId: Int): ImageEditorView? = withTimeoutOrNull(300) {
+        while (true) {
+            val view = withContext(Dispatchers.Main) {
+                try {
+                    UIManagerHelper.getUIManager(reactContext, viewId)?.resolveView(viewId) as? ImageEditorView
+                } catch (e: Exception) {
                     null
                 }
-                Log.d(TAG, if (reactContext != null) "Found view $viewId!" else "Couldn't find view $viewId!")
-                if (view != null) {
-                    continuation.resume(view)
-                } else {
-                    continuation.resumeWithException(Exception("The given view (ID $viewId) was not found in the view manager."))
-                }
+            }
+            if (view != null) {
+                return@withTimeoutOrNull view
+            }
+            if (!isActive) {
+                break
             }
         }
+        return@withTimeoutOrNull null
+    }
 
     //@Native
     private fun setOriginalImageCalledInJSI(imageData: ImageData, editorViewTag: Int) {
-        CoroutineScope(Dispatchers.Main).launch(CoroutineName("setOriginalImageCalledInJSI")) {
-            try {
-                val imageEditorView = findImageEditorView(editorViewTag)
-                imageEditorView.originalImage = imageData
-            } catch (e: Exception) {
-                Log.w(TAG, "setOriginalImageCalledInJSI: " + e.message)
+        CoroutineScope(Dispatchers.Default).launch(CoroutineName("setOriginalImageCalledInJSI")) {
+            val imageEditorView = findImageEditorView(editorViewTag)
+            if(imageEditorView == null) {
+                Log.e(TAG, "setOriginalImageCalledInJSI: Can't not find imageEditorView!(viewId = $editorViewTag)")
+                return@launch
             }
+            imageEditorView?.originalImage = imageData
         }
     }
 

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

@@ -0,0 +1,19 @@
+package com.dynamsoft.reactnativelib.dce
+
+import android.content.Context
+import com.dynamsoft.dce.ImageEditorView
+
+class RNImageEditorView(context: Context) : ImageEditorView(context) {
+    override fun requestLayout() {
+        super.requestLayout()
+        post(this::manuallyMeasureAndLayout)
+    }
+
+    private fun manuallyMeasureAndLayout() {
+        measure(
+            MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
+        )
+        layout(0, 0, measuredWidth, measuredHeight)
+    }
+}

package/android/src/main/java/com/dynamsoft/reactnativelib/utils/ForDDN.kt

@@ -18,6 +18,7 @@ fun DetectedQuadResultItem.toWritableMap(): WritableMap = Arguments.createMap().
     merge((this@toWritableMap as CapturedResultItem).toSharedWritableMap())
     putMap("location", location.toWritableMap())
     putInt("confidenceAsDocumentBoundary", confidenceAsDocumentBoundary)
+    putInt("crossVerificationStatus", crossVerificationStatus)
 }
 
 
@@ -36,6 +37,7 @@ fun DetectedQuadsResult.toWritableMap(): WritableMap = Arguments.createMap().app
 fun NormalizedImageResultItem.toWritableMap(): WritableMap = Arguments.createMap().apply {
     merge((this@toWritableMap as CapturedResultItem).toSharedWritableMap())
     putMap("location", location.toWritableMap())
+    putInt("crossVerificationStatus", crossVerificationStatus)
 }
 
 fun Array<out NormalizedImageResultItem>.toWritableArray(): WritableArray = Arguments.createArray().apply {

package/android/src/newarch/com/dynamsoft/reactnativelib/CameraViewManager.kt

@@ -6,6 +6,7 @@ import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.viewmanagers.DynamsoftCameraViewManagerInterface
 
 class CameraViewManager : SimpleViewManager<CameraView>(),
@@ -19,26 +20,31 @@ class CameraViewManager : SimpleViewManager<CameraView>(),
         return impl.getName()
     }
 
+    @ReactProp(name = "VisibleLayerIds")
     override fun setVisibleLayerIds(view: CameraView?, value: ReadableArray?) {
         if (value != null) {
             view?.let { impl.setVisibleLayerIds(it, value) }
         }
     }
 
+    @ReactProp(name = "scanRegionMaskVisible")
     override fun setScanRegionMaskVisible(view: CameraView?, value: Boolean) {
         view?.let { impl.setScanRegionMaskVisible(it, value) }
     }
 
+    @ReactProp(name = "scanLaserVisible")
     override fun setScanLaserVisible(view: CameraView?, value: Boolean) {
         view?.let { impl.setScanLaserVisible(it, value) }
     }
 
+    @ReactProp(name = "torchButton")
     override fun setTorchButton(view: CameraView?, value: ReadableMap?) {
         if (value != null) {
             view?.let { impl.setTorchButton(it, value) }
         }
     }
 
+    @ReactProp(name = "torchButtonVisible")
     override fun setTorchButtonVisible(view: CameraView?, value: Boolean) {
         view?.let { impl.setTorchButtonVisible(it, value) }
     }

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

@@ -8,15 +8,13 @@ Pod::Spec.new do |s|
   s.version      = package["version"]
   s.summary      = package["description"]
   s.homepage     = package["homepage"]
-  s.license      = "MIT"
-  # optional - use expanded license entry instead:
-  # s.license    = { :type => "MIT", :file => "LICENSE" }
+  s.license      = package["license"]
   s.authors      = { package["author"]["name"] => package["author"]["email"] }
   s.platforms    = { :ios => "11.0" }
-  s.source       = { :git => "https://github.com/dynamsoft/react-native-dcv.git", :tag => "#{s.version}" }
+  s.source = { :http => "https://registry.npmjs.org/#{s.name}/-/#{s.name}-#{s.version}.tgz" }
   s.source_files = "ios/**/*.{h,c,cc,cpp,m,mm,swift}"
   s.requires_arc = true
   s.dependency "React"
-  s.dependency "DynamsoftCaptureVisionBundle", "= 2.4.2000"
+  s.dependency "DynamsoftCaptureVisionBundle", "= 2.6.1002"
 end
 

package/ios/CPP/RNDynamsoft+JSI.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright © Dynamsoft Corporation. All rights reserved.
+ */
+
+#import <DynamsoftCaptureVisionRouter/DSCapturedResult.h>
+#import <DynamsoftCore/DSQuadrilateral.h>
+#import <jsi/jsi.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface DSCapturedResult (JSI)
+
+- (facebook::jsi::Object)convertToJSIObject:(facebook::jsi::Runtime& )runtime;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+DSQuadrilateral * _Nullable convertJSIValueToDSQuadrilateral(facebook::jsi::Runtime &runtime, const facebook::jsi::Object &value);