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

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

@@ -1,247 +1,247 @@
-package com.dynamsoft.reactnativelib.dce
-
-import android.graphics.PointF
-import android.util.Log
-import android.util.Size
-import androidx.lifecycle.Lifecycle
-import com.dynamsoft.dce.CameraEnhancer
-import com.dynamsoft.dce.CameraView
-import com.dynamsoft.dce.EnumCameraPosition
-import com.dynamsoft.dce.EnumFocusMode
-import com.dynamsoft.dce.EnumResolution
-import com.dynamsoft.dce.Feedback
-import com.dynamsoft.dce.utils.PermissionUtil
-import com.dynamsoft.reactnativelib.basicutils.toScanRegion
-import com.dynamsoft.reactnativelib.basicutils.toWritableMap
-import com.dynamsoft.reactnativelib.core.ImageSourceAdapterModuleImpl.Companion.mapISA
-import com.facebook.react.bridge.Arguments
-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 kotlinx.coroutines.withContext
-import kotlinx.coroutines.withTimeoutOrNull
-
-
-class CameraEnhancerModuleImpl(private val reactContext: ReactApplicationContext) : LifecycleEventListener {
-    companion object {
-        const val NAME = "DynamsoftCameraView"
-        const val TAG = "CameraEnhancerModule"
-    }
-
-    private var ifOpenCalled = false
-    private var cameraLifecycleOwner = CameraLifeCycleOwner()
-    private var camera: CameraEnhancer? = null
-    private var currentCameraViewId: Int? = null
-
-    init {
-        reactContext.addLifecycleEventListener(this)
-    }
-
-    fun getName(): String = NAME
-
-    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() {
-        //Don't handle ON_DESTROY, which can cause problems on some devices when some apps that have started background services return to the foreground
-        //cameraLifecycleOwner.lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
-    }
-
-    @ReactMethod
-    fun requestCameraPermission() {
-        reactContext.currentActivity?.apply {
-            PermissionUtil.requestCameraPermission(this)
-        }
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    fun createInstance(): String {
-        if(camera == null) {
-            camera = CameraEnhancer(cameraLifecycleOwner).apply {
-                mapISA[this.toString()] = this
-            }
-        }
-        return camera.toString()
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    fun destroyInstance(id: String): Boolean {
-        if(camera?.toString() == id) {
-            camera?.close()
-            camera?.cameraView = null
-            currentCameraViewId = null
-            camera = null
-        }
-        mapISA.remove(id)
-        return true
-    }
-
-    @ReactMethod
-    fun open() {
-        ifOpenCalled = true
-        if (currentCameraViewId != null && (camera?.cameraView == null || camera?.cameraView?.id != currentCameraViewId)) {
-            findAndSetCameraView(currentCameraViewId!!) { camera?.open() }
-        } else {
-            camera?.open()
-        }
-    }
-
-    @ReactMethod
-    fun close() {
-        ifOpenCalled = false
-        camera?.close()
-    }
-
-    @ReactMethod
-    fun setCameraView(viewTag: Int) {
-        if(viewTag == 0) {
-            return
-        }
-        currentCameraViewId = viewTag
-        findAndSetCameraView(viewTag)
-    }
-
-    @ReactMethod
-    fun selectCamera(@EnumCameraPosition position: Int) {
-        camera?.selectCamera(position)
-    }
-
-    @ReactMethod
-    fun getCameraPosition(promise: Promise) {
-        promise.resolve(camera?.cameraPosition)
-    }
-
-    @ReactMethod
-    fun setFocus(x: Float, y: Float, @EnumFocusMode focusMode: Int) {
-        camera?.setFocus(PointF(x, y), focusMode)
-    }
-
-    @ReactMethod
-    fun getFocusMode(promise: Promise) {
-        promise.resolve(camera?.focusMode)
-    }
-
-    @ReactMethod
-    fun setZoomFactor(factor: Float) {
-        camera?.zoomFactor = factor
-    }
-
-    @ReactMethod
-    fun getZoomFactor(promise: Promise) {
-        promise.resolve(camera?.zoomFactor)
-    }
-
-    @ReactMethod
-    fun enableEnhancedFeatures(features: Int) {
-        camera?.enableEnhancedFeatures(features)
-    }
-
-    @ReactMethod
-    fun disableEnhancedFeatures(features: Int) {
-        camera?.disableEnhancedFeatures(features)
-    }
-
-    @ReactMethod
-    fun setScanRegion(region: ReadableMap?) {
-        camera?.scanRegion = region?.toScanRegion()
-    }
-
-    @ReactMethod
-    fun getScanRegion(promise: Promise) {
-        promise.resolve(camera?.scanRegion?.toWritableMap())
-    }
-
-    @ReactMethod
-    fun turnOnTorch() {
-        camera?.turnOnTorch()
-    }
-
-    @ReactMethod
-    fun turnOffTorch() {
-        camera?.turnOffTorch()
-    }
-
-
-    @ReactMethod
-    fun setResolution(resolution: Int) {
-        if(resolution == 4) {
-            camera?.setResolution(EnumResolution.RESOLUTION_4K)
-        } else if(resolution == 5) {
-            camera?.setResolution(EnumResolution.RESOLUTION_MAX)
-        } else {
-            camera?.setResolution(resolution)
-        }
-    }
-    @ReactMethod
-    fun getResolution(promise: Promise) {
-        val resolution = camera?.resolution ?: Size(0,0)
-        promise.resolve(Arguments.createMap().apply {
-            putInt("width", resolution.width)
-            putInt("height", resolution.height)
-        })
-    }
-
-    @ReactMethod
-    fun beep() {
-        Feedback.beep()
-    }
-
-    @ReactMethod
-    fun vibrate() {
-        Feedback.vibrate()
-    }
-
-    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 {
-                Log.e(TAG, "findAndSetCameraView: before setCameraView $camera ${cameraView.id}", )
-                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
-                }
-            }
-            if (view != null) {
-                return@withTimeoutOrNull view
-            }
-            if (!isActive) {
-                break
-            }
-        }
-        return@withTimeoutOrNull null
-    }
-
-}
+package com.dynamsoft.reactnativelib.dce
+
+import android.graphics.PointF
+import android.util.Log
+import android.util.Size
+import androidx.lifecycle.Lifecycle
+import com.dynamsoft.dce.CameraEnhancer
+import com.dynamsoft.dce.CameraView
+import com.dynamsoft.dce.EnumCameraPosition
+import com.dynamsoft.dce.EnumFocusMode
+import com.dynamsoft.dce.EnumResolution
+import com.dynamsoft.dce.Feedback
+import com.dynamsoft.dce.utils.PermissionUtil
+import com.dynamsoft.reactnativelib.basicutils.toScanRegion
+import com.dynamsoft.reactnativelib.basicutils.toWritableMap
+import com.dynamsoft.reactnativelib.core.ImageSourceAdapterModuleImpl.Companion.mapISA
+import com.facebook.react.bridge.Arguments
+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 kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+
+
+class CameraEnhancerModuleImpl(private val reactContext: ReactApplicationContext) : LifecycleEventListener {
+    companion object {
+        const val NAME = "DynamsoftCameraView"
+        const val TAG = "CameraEnhancerModule"
+    }
+
+    private var ifOpenCalled = false
+    private var cameraLifecycleOwner = CameraLifeCycleOwner()
+    private var camera: CameraEnhancer? = null
+    private var currentCameraViewId: Int? = null
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+    }
+
+    fun getName(): String = NAME
+
+    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() {
+        //Don't handle ON_DESTROY, which can cause problems on some devices when some apps that have started background services return to the foreground
+        //cameraLifecycleOwner.lifecycle.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+    }
+
+    @ReactMethod
+    fun requestCameraPermission() {
+        reactContext.currentActivity?.apply {
+            PermissionUtil.requestCameraPermission(this)
+        }
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun createInstance(): String {
+        if(camera == null) {
+            camera = CameraEnhancer(cameraLifecycleOwner).apply {
+                mapISA[this.toString()] = this
+            }
+        }
+        return camera.toString()
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun destroyInstance(id: String): Boolean {
+        if(camera?.toString() == id) {
+            camera?.close()
+            camera?.cameraView = null
+            currentCameraViewId = null
+            camera = null
+        }
+        mapISA.remove(id)
+        return true
+    }
+
+    @ReactMethod
+    fun open() {
+        ifOpenCalled = true
+        if (currentCameraViewId != null && (camera?.cameraView == null || camera?.cameraView?.id != currentCameraViewId)) {
+            findAndSetCameraView(currentCameraViewId!!) { camera?.open() }
+        } else {
+            camera?.open()
+        }
+    }
+
+    @ReactMethod
+    fun close() {
+        ifOpenCalled = false
+        camera?.close()
+    }
+
+    @ReactMethod
+    fun setCameraView(viewTag: Int) {
+        if(viewTag == 0) {
+            return
+        }
+        currentCameraViewId = viewTag
+        findAndSetCameraView(viewTag)
+    }
+
+    @ReactMethod
+    fun selectCamera(@EnumCameraPosition position: Int) {
+        camera?.selectCamera(position)
+    }
+
+    @ReactMethod
+    fun getCameraPosition(promise: Promise) {
+        promise.resolve(camera?.cameraPosition)
+    }
+
+    @ReactMethod
+    fun setFocus(x: Float, y: Float, @EnumFocusMode focusMode: Int) {
+        camera?.setFocus(PointF(x, y), focusMode)
+    }
+
+    @ReactMethod
+    fun getFocusMode(promise: Promise) {
+        promise.resolve(camera?.focusMode)
+    }
+
+    @ReactMethod
+    fun setZoomFactor(factor: Float) {
+        camera?.zoomFactor = factor
+    }
+
+    @ReactMethod
+    fun getZoomFactor(promise: Promise) {
+        promise.resolve(camera?.zoomFactor)
+    }
+
+    @ReactMethod
+    fun enableEnhancedFeatures(features: Int) {
+        camera?.enableEnhancedFeatures(features)
+    }
+
+    @ReactMethod
+    fun disableEnhancedFeatures(features: Int) {
+        camera?.disableEnhancedFeatures(features)
+    }
+
+    @ReactMethod
+    fun setScanRegion(region: ReadableMap?) {
+        camera?.scanRegion = region?.toScanRegion()
+    }
+
+    @ReactMethod
+    fun getScanRegion(promise: Promise) {
+        promise.resolve(camera?.scanRegion?.toWritableMap())
+    }
+
+    @ReactMethod
+    fun turnOnTorch() {
+        camera?.turnOnTorch()
+    }
+
+    @ReactMethod
+    fun turnOffTorch() {
+        camera?.turnOffTorch()
+    }
+
+
+    @ReactMethod
+    fun setResolution(resolution: Int) {
+        if(resolution == 4) {
+            camera?.setResolution(EnumResolution.RESOLUTION_4K)
+        } else if(resolution == 5) {
+            camera?.setResolution(EnumResolution.RESOLUTION_MAX)
+        } else {
+            camera?.setResolution(resolution)
+        }
+    }
+    @ReactMethod
+    fun getResolution(promise: Promise) {
+        val resolution = camera?.resolution ?: Size(0,0)
+        promise.resolve(Arguments.createMap().apply {
+            putInt("width", resolution.width)
+            putInt("height", resolution.height)
+        })
+    }
+
+    @ReactMethod
+    fun beep() {
+        Feedback.beep()
+    }
+
+    @ReactMethod
+    fun vibrate() {
+        Feedback.vibrate()
+    }
+
+    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 {
+                Log.e(TAG, "findAndSetCameraView: before setCameraView $camera ${cameraView.id}", )
+                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
+                }
+            }
+            if (view != null) {
+                return@withTimeoutOrNull view
+            }
+            if (!isActive) {
+                break
+            }
+        }
+        return@withTimeoutOrNull null
+    }
+
+}

package/android/src/main/java/com/dynamsoft/reactnativelib/dce/CameraLifeCycleOwner.java

@@ -1,14 +1,14 @@
-package com.dynamsoft.reactnativelib.dce;
-
-import androidx.annotation.NonNull;
-import androidx.lifecycle.LifecycleOwner;
-import androidx.lifecycle.LifecycleRegistry;
-
-public class CameraLifeCycleOwner implements LifecycleOwner {
-    private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
-    @NonNull
-    @Override
-    public LifecycleRegistry getLifecycle() {
-        return lifecycleRegistry;
-    }
-}
+package com.dynamsoft.reactnativelib.dce;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+
+public class CameraLifeCycleOwner implements LifecycleOwner {
+    private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
+    @NonNull
+    @Override
+    public LifecycleRegistry getLifecycle() {
+        return lifecycleRegistry;
+    }
+}

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

@@ -1,77 +1,77 @@
-package com.dynamsoft.reactnativelib.dce
-
-import com.dynamsoft.dce.CameraView
-import com.dynamsoft.dce.DrawingLayer
-import com.dynamsoft.reactnativelib.basicutils.setCameraToggleButtonState
-import com.dynamsoft.reactnativelib.basicutils.setTorchButtonState
-import com.dynamsoft.reactnativelib.basicutils.toCameraToggleButtonState
-import com.dynamsoft.reactnativelib.basicutils.toTorchButtonState
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.annotations.ReactProp
-
-class CameraViewManagerImpl {
-    companion object {
-        const val TAG = "DynamsoftCameraView"
-    }
-
-    fun getName() = TAG
-
-    fun createViewInstance(context: ThemedReactContext): CameraView {
-        return RNCameraView(context)
-    }
-
-    fun receiveCommand(root: CameraView, commandId: String, args: ReadableArray?) {
-    }
-
-    @ReactProp(name = "scanRegionMaskVisible")
-    fun setScanRegionMaskVisible(view: CameraView, isVisible: Boolean) {
-        view.isScanRegionMaskVisible = isVisible
-    }
-
-    @ReactProp(name = "scanLaserVisible")
-    fun setScanLaserVisible(view: CameraView, isVisible: Boolean) {
-        view.isScanLaserVisible = isVisible
-    }
-
-
-    @ReactProp(name = "VisibleLayerIds")
-    fun setVisibleLayerIds(view: CameraView, invisibleLayerIds: ReadableArray) {
-        val ids = IntArray(invisibleLayerIds.size())
-        for (i in ids.indices) {
-            ids[i] = invisibleLayerIds.getInt(i)
-        }
-        intArrayOf(DrawingLayer.DBR_LAYER_ID, DrawingLayer.DDN_LAYER_ID, DrawingLayer.DLR_LAYER_ID).forEach {
-            view.getDrawingLayer(it).isVisible = ids.contains(it)
-        }
-    }
-
-    @ReactProp(name = "torchButton")
-    fun setTorchButton(view: CameraView, torchButton: ReadableMap) {
-        view.setTorchButtonState(torchButton.toTorchButtonState())
-    }
-
-    @ReactProp(name = "torchButtonVisible")
-    fun setTorchButtonVisible(view: CameraView, isVisible: Boolean) {
-        view.torchButtonVisible = isVisible
-    }
-
-    @ReactProp(name = "cameraToggleButton")
-    fun setCameraToggleButton(view: CameraView, cameraToggleButton: ReadableMap) {
-        view.setCameraToggleButtonState(cameraToggleButton.toCameraToggleButtonState())
-    }
-
-    @ReactProp(name = "cameraToggleButtonVisible")
-    fun setCameraToggleButtonVisible(view: CameraView, isVisible: Boolean) {
-        view.cameraToggleButtonVisible = isVisible
-    }
-
-//    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 com.dynamsoft.reactnativelib.dce
+
+import com.dynamsoft.dce.CameraView
+import com.dynamsoft.dce.DrawingLayer
+import com.dynamsoft.reactnativelib.basicutils.setCameraToggleButtonState
+import com.dynamsoft.reactnativelib.basicutils.setTorchButtonState
+import com.dynamsoft.reactnativelib.basicutils.toCameraToggleButtonState
+import com.dynamsoft.reactnativelib.basicutils.toTorchButtonState
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class CameraViewManagerImpl {
+    companion object {
+        const val TAG = "DynamsoftCameraView"
+    }
+
+    fun getName() = TAG
+
+    fun createViewInstance(context: ThemedReactContext): CameraView {
+        return RNCameraView(context)
+    }
+
+    fun receiveCommand(root: CameraView, commandId: String, args: ReadableArray?) {
+    }
+
+    @ReactProp(name = "scanRegionMaskVisible")
+    fun setScanRegionMaskVisible(view: CameraView, isVisible: Boolean) {
+        view.isScanRegionMaskVisible = isVisible
+    }
+
+    @ReactProp(name = "scanLaserVisible")
+    fun setScanLaserVisible(view: CameraView, isVisible: Boolean) {
+        view.isScanLaserVisible = isVisible
+    }
+
+
+    @ReactProp(name = "VisibleLayerIds")
+    fun setVisibleLayerIds(view: CameraView, invisibleLayerIds: ReadableArray) {
+        val ids = IntArray(invisibleLayerIds.size())
+        for (i in ids.indices) {
+            ids[i] = invisibleLayerIds.getInt(i)
+        }
+        intArrayOf(DrawingLayer.DBR_LAYER_ID, DrawingLayer.DDN_LAYER_ID, DrawingLayer.DLR_LAYER_ID).forEach {
+            view.getDrawingLayer(it).isVisible = ids.contains(it)
+        }
+    }
+
+    @ReactProp(name = "torchButton")
+    fun setTorchButton(view: CameraView, torchButton: ReadableMap) {
+        view.setTorchButtonState(torchButton.toTorchButtonState())
+    }
+
+    @ReactProp(name = "torchButtonVisible")
+    fun setTorchButtonVisible(view: CameraView, isVisible: Boolean) {
+        view.torchButtonVisible = isVisible
+    }
+
+    @ReactProp(name = "cameraToggleButton")
+    fun setCameraToggleButton(view: CameraView, cameraToggleButton: ReadableMap) {
+        view.setCameraToggleButtonState(cameraToggleButton.toCameraToggleButtonState())
+    }
+
+    @ReactProp(name = "cameraToggleButtonVisible")
+    fun setCameraToggleButtonVisible(view: CameraView, isVisible: Boolean) {
+        view.cameraToggleButtonVisible = isVisible
+    }
+
+//    private fun View.manuallyMeasureAndLayout() {
+//        measure(
+//            View.MeasureSpec.makeMeasureSpec(measuredWidth, View.MeasureSpec.EXACTLY),
+//            View.MeasureSpec.makeMeasureSpec(measuredHeight, View.MeasureSpec.EXACTLY)
+//        )
+//        layout(0, 0, measuredWidth, measuredHeight)
+//    }
+}