dynamsoft-capture-vision-react-native 1.0.0

package/android/src/main/java/com/dynamsoft/reactlibrary/RNDynamsoftBarcodeReaderModule.java

@@ -0,0 +1,253 @@
+
+package com.dynamsoft.reactlibrary;
+
+import android.util.Log;
+
+import com.dynamsoft.dbr.BarcodeReader;
+import com.dynamsoft.dbr.BarcodeReaderException;
+import com.dynamsoft.dbr.DBRLicenseVerificationListener;
+import com.dynamsoft.dbr.EnumBarcodeFormat_2;
+import com.dynamsoft.dbr.EnumConflictMode;
+import com.dynamsoft.dbr.EnumPresetTemplate;
+import com.dynamsoft.dbr.ImageData;
+import com.dynamsoft.dbr.LocalizationResult;
+import com.dynamsoft.dbr.Point;
+import com.dynamsoft.dbr.PublicRuntimeSettings;
+import com.dynamsoft.dbr.TextResult;
+import com.dynamsoft.dbr.TextResultListener;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import static com.dynamsoft.reactlibrary.RNDCECameraViewManager.mCamera;
+
+public class RNDynamsoftBarcodeReaderModule extends ReactContextBaseJavaModule {
+
+    private final ReactApplicationContext mReactContext;
+    private BarcodeReader mReader;
+
+    private boolean mIsCameraAttached;
+
+    public RNDynamsoftBarcodeReaderModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        mReactContext = reactContext;
+        mIsCameraAttached = false;
+    }
+
+    @Override
+    public String getName() {
+        return "RNDynamsoftBarcodeReader";
+    }
+
+
+    @ReactMethod
+    public void initLicense(String license, final Promise promise) {
+        BarcodeReader.initLicense(license, new DBRLicenseVerificationListener() {
+            @Override
+            public void DBRLicenseVerificationCallback(boolean b, Exception e) {
+                if (b) {
+                    promise.resolve(true);
+                } else {
+                    BarcodeReaderException be = (BarcodeReaderException) e;
+                    promise.reject(be.getErrorCode() + "", e);
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void createInstance() {
+        try {
+            mReader = new BarcodeReader();
+        } catch (BarcodeReaderException e) {
+            e.printStackTrace();
+        }
+        mReader.setCameraEnhancer(mCamera);
+    }
+
+    @ReactMethod
+    public void getVersion(Promise promise) {
+        promise.resolve(mReader.getVersion());
+    }
+
+    @ReactMethod
+    public void addResultListener() {
+        mReader.setTextResultListener(new TextResultListener() {
+            @Override
+            public void textResultCallback(int i, ImageData imageData, final TextResult[] textResults) {
+                WritableArray results = serializeResults(textResults);
+                mReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(
+                        "resultEvent",
+                        results);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+
+    }
+
+
+    @ReactMethod
+    public void startBarcodeScanning() {
+        if (!mIsCameraAttached) {
+            mReader.setCameraEnhancer(mCamera);
+            mIsCameraAttached = true;
+        }
+        mReader.startScanning();
+    }
+
+    @ReactMethod
+    public void stopBarcodeScanning() {
+        mReader.stopScanning();
+    }
+
+    @ReactMethod
+    public void updateSettingsFromDictionary(ReadableMap map, Promise promise) {
+        if (map == null) {
+            promise.resolve(false);
+            return;
+        }
+        try {
+            PublicRuntimeSettings settings = mReader.getRuntimeSettings();
+            settings.barcodeFormatIds = map.getInt("barcodeFormatIds");
+            settings.barcodeFormatIds_2 = map.getInt("barcodeFormatIds_2");
+            settings.expectedBarcodesCount = map.getInt("expectedBarcodesCount");
+            settings.timeout = map.getInt("timeout");
+            mReader.updateRuntimeSettings(settings);
+            promise.resolve(true);
+        } catch (BarcodeReaderException e) {
+            e.printStackTrace();
+            promise.resolve(false);
+        }
+    }
+
+    @ReactMethod
+    public void updateSettingsFromNumber(int PresetTpl, Promise promise) {
+        if (PresetTpl >= 0 && PresetTpl <= 6) {
+            mReader.updateRuntimeSettings(EnumPresetTemplate.fromValue(PresetTpl));
+            promise.resolve(true);
+        } else {
+            promise.resolve(false);
+        }
+    }
+
+    @ReactMethod
+    public void updateSettingsFromString(String settingsStr, Promise promise) {
+        try {
+            mReader.initRuntimeSettingsWithString(settingsStr, EnumConflictMode.CM_OVERWRITE);
+            promise.resolve(true);
+        } catch (BarcodeReaderException e) {
+            e.printStackTrace();
+            promise.resolve(false);
+        }
+    }
+
+    @ReactMethod
+    public void resetSettings(Promise promise) {
+        try {
+            mReader.resetRuntimeSettings();
+        } catch (BarcodeReaderException e) {
+            e.printStackTrace();
+            promise.resolve(false);
+        }
+        promise.resolve(true);
+    }
+
+    @ReactMethod
+    public void outputSettings(Promise promise) {
+        try {
+            promise.resolve(mReader.outputSettingsToString(""));
+        } catch (BarcodeReaderException e) {
+            e.printStackTrace();
+            promise.reject(e.getErrorCode() + "", e.getCause());
+        }
+    }
+
+    @ReactMethod
+    public void getSettings(Promise promise) {
+        WritableMap settingsMap = Arguments.createMap();
+        try {
+            PublicRuntimeSettings settings = mReader.getRuntimeSettings();
+            settingsMap.putInt("barcodeFormatIds", settings.barcodeFormatIds);
+            settingsMap.putInt("barcodeFormatIds_2", settings.barcodeFormatIds_2);
+            settingsMap.putInt("expectedBarcodesCount", settings.expectedBarcodesCount);
+            settingsMap.putInt("timeout", settings.timeout);
+        } catch (BarcodeReaderException e) {
+            e.printStackTrace();
+            promise.reject(e.getErrorCode() + "", e.getCause());
+        }
+        promise.resolve(settingsMap);
+//        return settingsMap;
+    }
+
+    private WritableArray serializeResults(TextResult[] barcodes) {
+        WritableArray barcodeList = Arguments.createArray();
+
+        for (int i = 0; i < barcodes.length; i++) {
+            TextResult barcode = barcodes[i];
+            WritableMap serializedBarcode = Arguments.createMap();
+
+            if (barcode.barcodeFormat_2 != EnumBarcodeFormat_2.BF2_NULL) {
+                serializedBarcode.putString("barcodeFormatString", barcode.barcodeFormatString_2);
+            } else {
+                serializedBarcode.putString("barcodeFormatString", barcode.barcodeFormatString);
+            }
+            serializedBarcode.putString("barcodeText", barcode.barcodeText);
+            serializedBarcode.putMap("barcodeLocation", handleLocationResult(barcode.localizationResult));
+            barcodeList.pushMap(serializedBarcode);
+        }
+
+        return barcodeList;
+    }
+
+    private WritableMap handleLocationResult(LocalizationResult result) {
+        if (result == null) {
+            return null;
+        }
+        WritableMap location = Arguments.createMap();
+        location.putInt("angle", result.angle);
+        location.putMap("quadrilateral", handleQuadrilateral(result.resultPoints));
+        return location;
+    }
+
+    private WritableMap handleQuadrilateral(Point[] points) {
+        if (points == null) {
+            return null;
+        }
+        WritableMap quadrilateral = Arguments.createMap();
+
+        quadrilateral.putArray("points", handlePoints(points));
+        return quadrilateral;
+    }
+
+    private WritableArray handlePoints(Point[] points) {
+        if (points == null) {
+            return null;
+        }
+        WritableArray pointArray = Arguments.createArray();
+        for (int i = 0; i < 4; i++) {
+            pointArray.pushMap(handleSinglePoint(points[i]));
+        }
+        return pointArray;
+    }
+
+    private WritableMap handleSinglePoint(Point point) {
+        WritableMap pointMap = Arguments.createMap();
+        pointMap.putInt("x", point.x);
+        pointMap.putInt("y", point.y);
+        return pointMap;
+    }
+}

package/android/src/main/java/com/dynamsoft/reactlibrary/RNDynamsoftCaptrueVisionPackage.java

@@ -0,0 +1,28 @@
+
+package com.dynamsoft.reactlibrary;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.bridge.JavaScriptModule;
+public class RNDynamsoftCaptrueVisionPackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+      return Arrays.<NativeModule>asList(new RNDynamsoftBarcodeReaderModule(reactContext));
+    }
+
+    // Deprecated from RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+      return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Arrays.<ViewManager>asList(new RNDCECameraViewManager(reactContext));
+    }
+}

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

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name                    = package["name"]
+  s.version                 = package["version"]
+  s.summary                 = package["description"]
+  s.homepage                = package["homepage"]
+
+  s.authors                 = { package["author"]["name"] => package["author"]["email"] }
+  s.platforms               = { :ios => "10.0" }
+  s.source                  = { :git => "https://github.com/Dynamsoft/capture-vision-react-native.git", :tag => "#{s.version}" }
+  s.source_files            = "ios/RNDynamsoftCaptureVision/**/*.{h,m}"
+  s.requires_arc            = true
+  s.module_name             = "RNDynamsoftCaptureVision"
+  s.header_dir              = "RNDynamsoftCaptureVision"
+  s.dependency 'DynamsoftCameraEnhancer', '= 2.1.4'
+  s.dependency 'DynamsoftBarcodeReader', '= 9.0.2'
+
+  s.dependency "React"
+end

package/ios/RNDynamsoftCaptureVision/DYSCameraView.h

@@ -0,0 +1,26 @@
+//
+//  DYSCameraView.h
+//  RCTDynamsoftBarcodeReader
+//
+//  Created by dynamsoft on 2022/3/16.
+//
+
+#import <UIKit/UIKit.h>
+#import <React/RCTComponent.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface DYSCameraView : UIView
+
+@property (nonatomic) BOOL scanRegionVisible;
+
+@property (nonatomic) BOOL overlayVisible;
+
+@property (nonatomic, strong, nullable) NSDictionary *scanRegion;
+
+- (void)open;
+- (void)close;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNDynamsoftCaptureVision/DYSCameraView.m

@@ -0,0 +1,71 @@
+//
+//  DYSCameraView.m
+//  RCTDynamsoftBarcodeReader
+//
+//  Created by dynamsoft on 2022/3/16.
+//
+
+#import "DYSCameraView.h"
+#import <React/RCTLog.h>
+#import "StaticClass.h"
+
+@implementation DYSCameraView
+
+@synthesize overlayVisible;
+@synthesize scanRegionVisible = _scanRegionVisible;
+@synthesize scanRegion;
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        [self addSubview:[StaticClass instance].view];
+    }
+    return self;
+}
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+    [StaticClass instance].view.frame = self.bounds;
+}
+
+- (void)setOverlayVisible:(BOOL)overlayVisible{
+    [StaticClass instance].view.overlayVisible = overlayVisible;
+}
+
+- (void)setScanRegionVisible:(BOOL)scanRegionVisible{
+    _scanRegionVisible = scanRegionVisible;
+    [StaticClass instance].dce.scanRegionVisible = scanRegionVisible;
+}
+
+- (BOOL)scanRegionVisible{
+    return _scanRegionVisible;
+}
+
+- (void)setScanRegion:(NSDictionary *)scanRegion{
+    if (scanRegion) {
+        NSNumber *regionTop = [scanRegion valueForKey:@"regionTop"];
+        NSNumber *regionLeft = [scanRegion valueForKey:@"regionLeft"];
+        NSNumber *regionRight = [scanRegion valueForKey:@"regionRight"];
+        NSNumber *regionBottom = [scanRegion valueForKey:@"regionBottom"];
+        NSNumber *regionMeasuredByPercentage = [scanRegion valueForKey:@"regionTop"];
+        iRegionDefinition *region = [iRegionDefinition new];
+        region.regionTop = regionTop.integerValue;
+        region.regionLeft = regionLeft.integerValue;
+        region.regionRight = regionRight.integerValue;
+        region.regionBottom = regionBottom.integerValue;
+        region.regionMeasuredByPercentage = regionMeasuredByPercentage.boolValue;
+        NSError *err = [NSError new];
+        [[StaticClass instance].dce setScanRegion:region error:&err];
+        [StaticClass instance].dce.scanRegionVisible = _scanRegionVisible;
+    }
+}
+
+- (void)open{
+    [[StaticClass instance].dce open];
+}
+
+- (void)close{
+    [[StaticClass instance].dce close];
+}
+
+@end

package/ios/RNDynamsoftCaptureVision/DYSCameraViewManager.h

@@ -0,0 +1,17 @@
+//
+//  DYSCameraViewManager.h
+//  RCTDynamsoftBarcodeReader
+//
+//  Created by dynamsoft on 2022/3/16.
+//
+
+#import <React/RCTViewManager.h>
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface DYSCameraViewManager : RCTViewManager
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNDynamsoftCaptureVision/DYSCameraViewManager.m

@@ -0,0 +1,77 @@
+//
+//  DYSCameraViewManager.m
+//  RCTDynamsoftBarcodeReader
+//
+//  Created by dynamsoft on 2022/3/16.
+//
+
+#import <React/RCTUIManager.h>
+#import "DYSCameraViewManager.h"
+#import "DYSCameraView.h"
+#import "StaticClass.h"
+
+@implementation DYSCameraViewManager
+
+RCT_EXPORT_MODULE(DYSCameraView)
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        CGFloat heigth = UIScreen.mainScreen.bounds.size.height;
+        CGFloat width = UIScreen.mainScreen.bounds.size.width;
+        [StaticClass instance].view = [[DCECameraView alloc] initWithFrame:CGRectMake(0, 0, width, heigth)];
+        [StaticClass instance].dce = [[DynamsoftCameraEnhancer alloc] initWithView:[StaticClass instance].view];
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup{
+    return YES;
+}
+
+- (UIView *)view {
+    return [[DYSCameraView alloc] init];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(scanRegionVisible, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(overlayVisible, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(scanRegion, NSDictionary)
+
+RCT_EXPORT_METHOD(open:(nonnull NSNumber *)reactTag) {
+    [self.bridge.uiManager addUIBlock:
+     ^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+         id view = viewRegistry[reactTag];
+         if (!view || ![view isKindOfClass:[DYSCameraView class]]) {
+             RCTLogError(@"Cannot find DYSCameraView with tag #%@", reactTag);
+         } else {
+             [((DYSCameraView *)view) open];
+         }
+     }];
+}
+
+RCT_EXPORT_METHOD(close:(nonnull NSNumber *)reactTag) {
+    [self.bridge.uiManager addUIBlock:
+     ^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+         id view = viewRegistry[reactTag];
+         if (!view || ![view isKindOfClass:[DYSCameraView class]]) {
+             RCTLogError(@"Cannot find DYSCameraView with tag #%@", reactTag);
+         } else {
+             [((DYSCameraView *)view) close];
+         }
+     }];
+}
+
+RCT_EXPORT_METHOD(setScanRegion:(nonnull NSNumber *)reactTag
+                  scanRegion:(NSDictionary *)scanRegion) {
+    [self.bridge.uiManager addUIBlock:
+     ^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+         id view = viewRegistry[reactTag];
+         if (!view || ![view isKindOfClass:[DYSCameraView class]]) {
+             RCTLogError(@"Cannot find DYSCameraView with tag #%@", reactTag);
+         } else {
+             [((DYSCameraView *)view) setScanRegion:scanRegion];
+         }
+     }];
+}
+
+@end

package/ios/RNDynamsoftCaptureVision/RCTDynamsoftBarcodeReader.h

@@ -0,0 +1,14 @@
+//
+//  RCTDynamsoftBarcodeReader.h
+//  RCTDynamsoftBarcodeReader
+//
+//  Created by dynamsoft on 2022/3/16.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCTDynamsoftBarcodeReader : RCTEventEmitter <RCTBridgeModule>
+
+@end