react-native-pdf417-scanner 1.0.0

package/android/src/main/java/com/pdf417scanner/PDF417CameraManager.java

@@ -0,0 +1,283 @@
+package com.pdf417scanner;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.ImageFormat;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.media.Image;
+import android.media.ImageReader;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+import android.util.Size;
+import android.view.Surface;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.BinaryBitmap;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.MultiFormatReader;
+import com.google.zxing.PlanarYUVLuminanceSource;
+import com.google.zxing.Result;
+import com.google.zxing.common.HybridBinarizer;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.Map;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+
+public class PDF417CameraManager {
+    private static final String TAG = "PDF417CameraManager";
+    
+    private ReactApplicationContext reactContext;
+    private PDF417ScannerModule scannerModule;
+    private CameraManager cameraManager;
+    private CameraDevice cameraDevice;
+    private CameraCaptureSession captureSession;
+    private ImageReader imageReader;
+    private HandlerThread backgroundThread;
+    private Handler backgroundHandler;
+    private MultiFormatReader multiFormatReader;
+    private Semaphore cameraOpenCloseLock = new Semaphore(1);
+    private String cameraId;
+    private Size previewSize;
+    private boolean isScanning = false;
+    private PDF417ScannerConfig config;
+
+    public PDF417CameraManager(ReactApplicationContext reactContext, PDF417ScannerModule scannerModule) {
+        this.reactContext = reactContext;
+        this.scannerModule = scannerModule;
+        this.cameraManager = (CameraManager) reactContext.getSystemService(Context.CAMERA_SERVICE);
+        setupBarcodeReader();
+    }
+
+    private void setupBarcodeReader() {
+        multiFormatReader = new MultiFormatReader();
+        Map<DecodeHintType, Object> hints = new EnumMap<>(DecodeHintType.class);
+        hints.put(DecodeHintType.POSSIBLE_FORMATS, EnumSet.of(BarcodeFormat.PDF_417));
+        hints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE);
+        multiFormatReader.setHints(hints);
+    }
+
+    public void startScanning(PDF417ScannerConfig config) throws Exception {
+        this.config = config;
+        startBackgroundThread();
+        openCamera();
+    }
+
+    public void stopScanning() {
+        isScanning = false;
+        closeCamera();
+        stopBackgroundThread();
+    }
+
+    public void setTorchEnabled(boolean enabled) throws CameraAccessException {
+        if (captureSession != null && cameraDevice != null) {
+            CaptureRequest.Builder builder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
+            builder.addTarget(imageReader.getSurface());
+            builder.set(CaptureRequest.FLASH_MODE, enabled ? 
+                CaptureRequest.FLASH_MODE_TORCH : CaptureRequest.FLASH_MODE_OFF);
+            captureSession.setRepeatingRequest(builder.build(), null, backgroundHandler);
+        }
+    }
+
+    private void startBackgroundThread() {
+        backgroundThread = new HandlerThread("CameraBackground");
+        backgroundThread.start();
+        backgroundHandler = new Handler(backgroundThread.getLooper());
+    }
+
+    private void stopBackgroundThread() {
+        if (backgroundThread != null) {
+            backgroundThread.quitSafely();
+            try {
+                backgroundThread.join();
+                backgroundThread = null;
+                backgroundHandler = null;
+            } catch (InterruptedException e) {
+                Log.e(TAG, "Error stopping background thread", e);
+            }
+        }
+    }
+
+    private void openCamera() throws Exception {
+        if (!cameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
+            throw new RuntimeException("Time out waiting to lock camera opening.");
+        }
+
+        try {
+            cameraId = selectCamera();
+            if (cameraId == null) {
+                throw new RuntimeException("No suitable camera found");
+            }
+
+            setupImageReader();
+            cameraManager.openCamera(cameraId, stateCallback, backgroundHandler);
+        } catch (CameraAccessException e) {
+            throw new RuntimeException("Failed to open camera", e);
+        }
+    }
+
+    private String selectCamera() throws CameraAccessException {
+        for (String cameraId : cameraManager.getCameraIdList()) {
+            CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
+            Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
+            if (facing != null && facing == CameraCharacteristics.LENS_FACING_BACK) {
+                StreamConfigurationMap map = characteristics.get(
+                    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+                if (map != null) {
+                    previewSize = chooseOptimalSize(map.getOutputSizes(ImageFormat.YUV_420_888));
+                    return cameraId;
+                }
+            }
+        }
+        return null;
+    }
+
+    private Size chooseOptimalSize(Size[] choices) {
+        for (Size size : choices) {
+            if (size.getWidth() <= 1920 && size.getHeight() <= 1080) {
+                return size;
+            }
+        }
+        return choices[0];
+    }
+
+    private void setupImageReader() {
+        imageReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(),
+            ImageFormat.YUV_420_888, 2);
+        imageReader.setOnImageAvailableListener(onImageAvailableListener, backgroundHandler);
+    }
+
+    private final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
+        @Override
+        public void onOpened(@NonNull CameraDevice camera) {
+            cameraOpenCloseLock.release();
+            cameraDevice = camera;
+            createCameraPreviewSession();
+        }
+
+        @Override
+        public void onDisconnected(@NonNull CameraDevice camera) {
+            cameraOpenCloseLock.release();
+            camera.close();
+            cameraDevice = null;
+        }
+
+        @Override
+        public void onError(@NonNull CameraDevice camera, int error) {
+            cameraOpenCloseLock.release();
+            camera.close();
+            cameraDevice = null;
+            scannerModule.onScanError("CAMERA_ERROR", "Camera error: " + error);
+        }
+    };
+
+    private void createCameraPreviewSession() {
+        try {
+            CaptureRequest.Builder builder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
+            builder.addTarget(imageReader.getSurface());
+            
+            if (config.isEnableAutoFocus()) {
+                builder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+            }
+
+            cameraDevice.createCaptureSession(Arrays.asList(imageReader.getSurface()),
+                new CameraCaptureSession.StateCallback() {
+                    @Override
+                    public void onConfigured(@NonNull CameraCaptureSession session) {
+                        if (cameraDevice == null) return;
+                        
+                        captureSession = session;
+                        try {
+                            session.setRepeatingRequest(builder.build(), null, backgroundHandler);
+                            isScanning = true;
+                            scannerModule.onCameraReady();
+                        } catch (CameraAccessException e) {
+                            Log.e(TAG, "Error starting camera preview", e);
+                            scannerModule.onScanError("CAMERA_ERROR", "Failed to start preview");
+                        }
+                    }
+
+                    @Override
+                    public void onConfigureFailed(@NonNull CameraCaptureSession session) {
+                        scannerModule.onScanError("CAMERA_ERROR", "Failed to configure camera");
+                    }
+                }, null);
+        } catch (CameraAccessException e) {
+            Log.e(TAG, "Error creating camera preview session", e);
+            scannerModule.onScanError("CAMERA_ERROR", "Failed to create preview session");
+        }
+    }
+
+    private final ImageReader.OnImageAvailableListener onImageAvailableListener = 
+        new ImageReader.OnImageAvailableListener() {
+            @Override
+            public void onImageAvailable(ImageReader reader) {
+                if (!isScanning) return;
+                
+                Image image = reader.acquireLatestImage();
+                if (image != null) {
+                    try {
+                        processImage(image);
+                    } finally {
+                        image.close();
+                    }
+                }
+            }
+        };
+
+    private void processImage(Image image) {
+        try {
+            ByteBuffer buffer = image.getPlanes()[0].getBuffer();
+            byte[] data = new byte[buffer.remaining()];
+            buffer.get(data);
+
+            PlanarYUVLuminanceSource source = new PlanarYUVLuminanceSource(
+                data, image.getWidth(), image.getHeight(), 0, 0,
+                image.getWidth(), image.getHeight(), false);
+
+            BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
+            Result result = multiFormatReader.decode(bitmap);
+            
+            if (result != null) {
+                scannerModule.onScanResult(result.getText(), result.getBarcodeFormat().toString());
+            }
+        } catch (Exception e) {
+            // No barcode found, continue scanning
+        }
+    }
+
+    private void closeCamera() {
+        try {
+            cameraOpenCloseLock.acquire();
+            if (captureSession != null) {
+                captureSession.close();
+                captureSession = null;
+            }
+            if (cameraDevice != null) {
+                cameraDevice.close();
+                cameraDevice = null;
+            }
+            if (imageReader != null) {
+                imageReader.close();
+                imageReader = null;
+            }
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
+        } finally {
+            cameraOpenCloseLock.release();
+        }
+    }
+}

package/android/src/main/java/com/pdf417scanner/PDF417ScannerConfig.java

@@ -0,0 +1,49 @@
+package com.pdf417scanner;
+
+public class PDF417ScannerConfig {
+    private boolean enableAutoFocus = true;
+    private boolean enableTorch = false;
+    private int scanTimeout = 30000; // 30 seconds
+    private boolean enableBeep = true;
+    private boolean enableVibration = true;
+
+    public boolean isEnableAutoFocus() {
+        return enableAutoFocus;
+    }
+
+    public void setEnableAutoFocus(boolean enableAutoFocus) {
+        this.enableAutoFocus = enableAutoFocus;
+    }
+
+    public boolean isEnableTorch() {
+        return enableTorch;
+    }
+
+    public void setEnableTorch(boolean enableTorch) {
+        this.enableTorch = enableTorch;
+    }
+
+    public int getScanTimeout() {
+        return scanTimeout;
+    }
+
+    public void setScanTimeout(int scanTimeout) {
+        this.scanTimeout = scanTimeout;
+    }
+
+    public boolean isEnableBeep() {
+        return enableBeep;
+    }
+
+    public void setEnableBeep(boolean enableBeep) {
+        this.enableBeep = enableBeep;
+    }
+
+    public boolean isEnableVibration() {
+        return enableVibration;
+    }
+
+    public void setEnableVibration(boolean enableVibration) {
+        this.enableVibration = enableVibration;
+    }
+}

package/android/src/main/java/com/pdf417scanner/PDF417ScannerModule.java

@@ -0,0 +1,138 @@
+package com.pdf417scanner;
+
+import android.Manifest;
+import android.content.pm.PackageManager;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+
+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.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class PDF417ScannerModule extends ReactContextBaseJavaModule {
+    private static final String TAG = "PDF417ScannerModule";
+    private static final String MODULE_NAME = "PDF417Scanner";
+    
+    private PDF417CameraManager cameraManager;
+    private ReactApplicationContext reactContext;
+    private Handler mainHandler;
+
+    public PDF417ScannerModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.mainHandler = new Handler(Looper.getMainLooper());
+        this.cameraManager = new PDF417CameraManager(reactContext, this);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        constants.put("SCAN_RESULT_EVENT", "PDF417ScanResult");
+        constants.put("SCAN_ERROR_EVENT", "PDF417ScanError");
+        constants.put("CAMERA_READY_EVENT", "PDF417CameraReady");
+        return constants;
+    }
+
+    @ReactMethod
+    public void startScanning(ReadableMap config, Promise promise) {
+        try {
+            if (!hasRequiredPermissions()) {
+                promise.reject("PERMISSION_DENIED", "Camera permission is required");
+                return;
+            }
+
+            PDF417ScannerConfig scannerConfig = new PDF417ScannerConfig();
+            if (config.hasKey("enableAutoFocus")) {
+                scannerConfig.setEnableAutoFocus(config.getBoolean("enableAutoFocus"));
+            }
+            if (config.hasKey("enableTorch")) {
+                scannerConfig.setEnableTorch(config.getBoolean("enableTorch"));
+            }
+            if (config.hasKey("scanTimeout")) {
+                scannerConfig.setScanTimeout(config.getInt("scanTimeout"));
+            }
+            if (config.hasKey("enableBeep")) {
+                scannerConfig.setEnableBeep(config.getBoolean("enableBeep"));
+            }
+            if (config.hasKey("enableVibration")) {
+                scannerConfig.setEnableVibration(config.getBoolean("enableVibration"));
+            }
+
+            cameraManager.startScanning(scannerConfig);
+            promise.resolve(null);
+        } catch (Exception e) {
+            Log.e(TAG, "Error starting scanner", e);
+            promise.reject("START_SCANNING_ERROR", e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void stopScanning(Promise promise) {
+        try {
+            cameraManager.stopScanning();
+            promise.resolve(null);
+        } catch (Exception e) {
+            Log.e(TAG, "Error stopping scanner", e);
+            promise.reject("STOP_SCANNING_ERROR", e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void setTorchEnabled(boolean enabled, Promise promise) {
+        try {
+            cameraManager.setTorchEnabled(enabled);
+            promise.resolve(null);
+        } catch (Exception e) {
+            Log.e(TAG, "Error setting torch", e);
+            promise.reject("TORCH_ERROR", e.getMessage());
+        }
+    }
+
+    private boolean hasRequiredPermissions() {
+        return ActivityCompat.checkSelfPermission(reactContext, Manifest.permission.CAMERA) 
+               == PackageManager.PERMISSION_GRANTED;
+    }
+
+    public void sendEvent(String eventName, WritableMap params) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+            .emit(eventName, params);
+    }
+
+    public void onScanResult(String data, String format) {
+        WritableMap result = Arguments.createMap();
+        result.putString("data", data);
+        result.putString("format", format);
+        result.putDouble("timestamp", System.currentTimeMillis());
+        sendEvent("PDF417ScanResult", result);
+    }
+
+    public void onScanError(String code, String message) {
+        WritableMap error = Arguments.createMap();
+        error.putString("code", code);
+        error.putString("message", message);
+        sendEvent("PDF417ScanError", error);
+    }
+
+    public void onCameraReady() {
+        sendEvent("PDF417CameraReady", null);
+    }
+}

package/android/src/main/java/com/pdf417scanner/PDF417ScannerPackage.java

@@ -0,0 +1,28 @@
+package com.pdf417scanner;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class PDF417ScannerPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new PDF417ScannerModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,60 @@
+export interface PDF417ScanResult {
+    data: string;
+    format: string;
+    timestamp: number;
+}
+export interface PDF417ScanError {
+    code: string;
+    message: string;
+}
+export interface PDF417ScannerConfig {
+    enableAutoFocus?: boolean;
+    enableTorch?: boolean;
+    scanTimeout?: number;
+    enableBeep?: boolean;
+    enableVibration?: boolean;
+}
+declare class PDF417ScannerModule {
+    private eventEmitter;
+    private isScanning;
+    constructor();
+    /**
+     * Request camera permission
+     */
+    requestCameraPermission(): Promise<boolean>;
+    /**
+     * Check if camera permission is granted
+     */
+    hasCameraPermission(): Promise<boolean>;
+    /**
+     * Start PDF417 scanning
+     */
+    startScanning(config?: PDF417ScannerConfig): Promise<void>;
+    /**
+     * Stop PDF417 scanning
+     */
+    stopScanning(): Promise<void>;
+    /**
+     * Check if scanner is currently running
+     */
+    isCurrentlyScanning(): boolean;
+    /**
+     * Enable/disable torch (flashlight)
+     */
+    setTorchEnabled(enabled: boolean): Promise<void>;
+    /**
+     * Listen for scan results
+     */
+    onScanResult(callback: (result: PDF417ScanResult) => void): () => void;
+    /**
+     * Listen for scan errors
+     */
+    onScanError(callback: (error: PDF417ScanError) => void): () => void;
+    /**
+     * Listen for camera ready event
+     */
+    onCameraReady(callback: () => void): () => void;
+}
+declare const _default: PDF417ScannerModule;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,cAAM,mBAAmB;IACvB,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,UAAU,CAAkB;;IAMpC;;OAEG;IACG,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC;IAuBjD;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,OAAO,CAAC;IAgB7C;;OAEG;IACG,aAAa,CAAC,MAAM,GAAE,mBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBpE;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAanC;;OAEG;IACH,mBAAmB,IAAI,OAAO;IAI9B;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtD;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,MAAM,IAAI;IAKtE;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GAAG,MAAM,IAAI;IAKnE;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;CAIhD;;AAED,wBAAyC"}

package/lib/index.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const { PDF417Scanner } = react_native_1.NativeModules;
+class PDF417ScannerModule {
+    constructor() {
+        this.isScanning = false;
+        this.eventEmitter = new react_native_1.NativeEventEmitter(PDF417Scanner);
+    }
+    /**
+     * Request camera permission
+     */
+    async requestCameraPermission() {
+        if (react_native_1.Platform.OS !== 'android') {
+            return true;
+        }
+        try {
+            const granted = await react_native_1.PermissionsAndroid.request(react_native_1.PermissionsAndroid.PERMISSIONS.CAMERA, {
+                title: 'Camera Permission',
+                message: 'This app needs camera access to scan PDF417 barcodes',
+                buttonNeutral: 'Ask Me Later',
+                buttonNegative: 'Cancel',
+                buttonPositive: 'OK',
+            });
+            return granted === react_native_1.PermissionsAndroid.RESULTS.GRANTED;
+        }
+        catch (err) {
+            console.warn('Camera permission error:', err);
+            return false;
+        }
+    }
+    /**
+     * Check if camera permission is granted
+     */
+    async hasCameraPermission() {
+        if (react_native_1.Platform.OS !== 'android') {
+            return true;
+        }
+        try {
+            const hasPermission = await react_native_1.PermissionsAndroid.check(react_native_1.PermissionsAndroid.PERMISSIONS.CAMERA);
+            return hasPermission;
+        }
+        catch (err) {
+            console.warn('Permission check error:', err);
+            return false;
+        }
+    }
+    /**
+     * Start PDF417 scanning
+     */
+    async startScanning(config = {}) {
+        if (this.isScanning) {
+            throw new Error('Scanner is already running');
+        }
+        const hasPermission = await this.hasCameraPermission();
+        if (!hasPermission) {
+            const granted = await this.requestCameraPermission();
+            if (!granted) {
+                throw new Error('Camera permission denied');
+            }
+        }
+        try {
+            await PDF417Scanner.startScanning(config);
+            this.isScanning = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to start scanning: ${error}`);
+        }
+    }
+    /**
+     * Stop PDF417 scanning
+     */
+    async stopScanning() {
+        if (!this.isScanning) {
+            return;
+        }
+        try {
+            await PDF417Scanner.stopScanning();
+            this.isScanning = false;
+        }
+        catch (error) {
+            throw new Error(`Failed to stop scanning: ${error}`);
+        }
+    }
+    /**
+     * Check if scanner is currently running
+     */
+    isCurrentlyScanning() {
+        return this.isScanning;
+    }
+    /**
+     * Enable/disable torch (flashlight)
+     */
+    async setTorchEnabled(enabled) {
+        try {
+            await PDF417Scanner.setTorchEnabled(enabled);
+        }
+        catch (error) {
+            throw new Error(`Failed to set torch: ${error}`);
+        }
+    }
+    /**
+     * Listen for scan results
+     */
+    onScanResult(callback) {
+        const subscription = this.eventEmitter.addListener('PDF417ScanResult', callback);
+        return () => subscription.remove();
+    }
+    /**
+     * Listen for scan errors
+     */
+    onScanError(callback) {
+        const subscription = this.eventEmitter.addListener('PDF417ScanError', callback);
+        return () => subscription.remove();
+    }
+    /**
+     * Listen for camera ready event
+     */
+    onCameraReady(callback) {
+        const subscription = this.eventEmitter.addListener('PDF417CameraReady', callback);
+        return () => subscription.remove();
+    }
+}
+exports.default = new PDF417ScannerModule();
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}