react-native-fabric-barcode-scanner 1.0.0

package/ios/RNScannerView.swift

@@ -0,0 +1,132 @@
+import AVFoundation
+import UIKit
+
+private final class MetadataOutputHandler: NSObject, AVCaptureMetadataOutputObjectsDelegate {
+  var onBarcodeScanned: ((NSDictionary) -> Void)?
+
+  func metadataOutput(_ output: AVCaptureMetadataOutput,
+                       didOutput metadataObjects: [AVMetadataObject],
+                       from connection: AVCaptureConnection) {
+    for object in metadataObjects {
+      guard let readable = object as? AVMetadataMachineReadableCodeObject,
+            let value = readable.stringValue else { continue }
+      onBarcodeScanned?([
+        "value": value,
+        "type": RNScannerHelper.name(for: readable.type),
+        "timestamp": Int32(Date().timeIntervalSince1970 * 1000)
+      ] as NSDictionary)
+    }
+  }
+}
+
+@objc(RNScannerView)
+public class RNScannerView: UIView {
+
+  private let session = AVCaptureSession()
+  private var previewLayer: AVCaptureVideoPreviewLayer?
+  private let metadataOutput = AVCaptureMetadataOutput()
+  private let metadataHandler = MetadataOutputHandler()
+  private let sessionQueue = DispatchQueue(label: "com.rncustomscanner.session")
+  private var isSessionConfigured = false
+
+  @objc public var isActive: Bool = true {
+    didSet {
+      sessionQueue.async {
+        if !self.isSessionConfigured {
+          self.configureSessionIfNeeded()
+        } else {
+          self.updateSessionState()
+        }
+      }
+    }
+  }
+  @objc public var torchOn: Bool = false { didSet { RNScannerHelper().setTorchEnabled(torchOn) } }
+  @objc public var scanFormats: [String] = RNScannerHelper.supportedFormats { didSet { applyMetadataFilters() } }
+
+  // Wired up by ScannerViewManager to emit the Fabric event
+  @objc public var onBarcodeScanned: ((NSDictionary) -> Void)? {
+    didSet { metadataHandler.onBarcodeScanned = onBarcodeScanned }
+  }
+
+  public override init(frame: CGRect) {
+    super.init(frame: frame)
+    sessionQueue.async {
+      self.configureSessionIfNeeded()
+    }
+  }
+  public required init?(coder: NSCoder) { fatalError("init(coder:) not implemented") }
+
+  // Only builds the AVCaptureSession if permission is already granted.
+  // Requesting permission is entirely JS's responsibility via
+  // ScannerModule.requestCameraPermission() — this view never triggers
+  // the system permission dialog itself.
+  private func configureSessionIfNeeded() {
+    guard !isSessionConfigured else {
+      updateSessionState()
+      return
+    }
+    guard AVCaptureDevice.authorizationStatus(for: .video) == .authorized else {
+      return
+    }
+    buildSessionGraph()
+  }
+
+  private func buildSessionGraph() {
+    session.beginConfiguration()
+    guard let device = AVCaptureDevice.default(for: .video),
+          let input = try? AVCaptureDeviceInput(device: device),
+          session.canAddInput(input) else {
+      session.commitConfiguration()
+      return
+    }
+    session.addInput(input)
+    guard session.canAddOutput(metadataOutput) else {
+      session.commitConfiguration()
+      return
+    }
+    session.addOutput(metadataOutput)
+    metadataOutput.setMetadataObjectsDelegate(metadataHandler, queue: DispatchQueue.main)
+    session.commitConfiguration()
+    isSessionConfigured = true
+
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else { return }
+      self.applyMetadataFilters()
+      let layer = AVCaptureVideoPreviewLayer(session: self.session)
+      layer.videoGravity = .resizeAspectFill
+      layer.frame = self.bounds
+      self.layer.addSublayer(layer)
+      self.previewLayer = layer
+      self.updateSessionState()
+    }
+  }
+
+  private func applyMetadataFilters() {
+    let requested = scanFormats.compactMap { RNScannerHelper.avFormat(for: $0) }
+    let available = metadataOutput.availableMetadataObjectTypes
+    metadataOutput.metadataObjectTypes = requested.filter { available.contains($0) }
+  }
+
+  private func updateSessionState() {
+    sessionQueue.async {
+      guard self.isSessionConfigured else { return }
+      if self.isActive && !self.session.isRunning {
+        self.session.startRunning()
+      } else if !self.isActive && self.session.isRunning {
+        self.session.stopRunning()
+      }
+    }
+  }
+
+  public override func layoutSubviews() {
+    super.layoutSubviews()
+    previewLayer?.frame = bounds
+  }
+
+  public override func removeFromSuperview() {
+    sessionQueue.async { [session] in
+      if session.isRunning { session.stopRunning() }
+    }
+    super.removeFromSuperview()
+  }
+}

package/ios/ScannerModule.mm

@@ -0,0 +1,65 @@
+#import "RNCustomScannerSpec.h"
+#import "RNCustomScanner-Swift.h"
+
+using namespace facebook::react;
+
+@interface ScannerModule : NativeScannerModuleSpecBase <NativeScannerModuleSpec>
+@end
+
+@implementation ScannerModule {
+  RNScannerHelper *_helper;
+}
+
+RCT_EXPORT_MODULE(ScannerModule)
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _helper = [RNScannerHelper new];
+  }
+  return self;
+}
+
+- (void)checkCameraPermission:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject {
+  resolve([_helper checkCameraPermission]);
+}
+
+- (void)requestCameraPermission:(RCTPromiseResolveBlock)resolve
+                          reject:(RCTPromiseRejectBlock)reject {
+  [_helper requestCameraPermission:^(NSString *result) {
+    resolve(result);
+  }];
+}
+
+- (void)setTorchEnabled:(BOOL)enabled {
+  [_helper setTorchEnabled:enabled];
+}
+
+- (void)openCameraSettings {
+  [_helper openCameraSettings];
+}
+
+- (facebook::react::ModuleConstants<JS::NativeScannerModule::Constants>)getConstants {
+  std::vector<NSString *> formats;
+  for (NSString *f in RNScannerHelper.supportedFormats) {
+    formats.push_back(f);
+  }
+  return facebook::react::typedConstants<JS::NativeScannerModule::Constants>({
+    .SUPPORTED_FORMATS = formats
+  });
+}
+
+- (facebook::react::ModuleConstants<JS::NativeScannerModule::Constants>)constantsToExport {
+  return [self getConstants];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeScannerModuleSpecJSI>(params);
+}
+
+@end

package/ios/ScannerModule.swift

@@ -0,0 +1,105 @@
+import AVFoundation
+import Foundation
+import UIKit
+
+@objc(RNScannerHelper)
+public class RNScannerHelper: NSObject {
+
+  @objc public static var supportedFormats: [String] {
+    return ["qr", "ean13", "ean8", "upce", "code128", "code39",
+            "code93", "pdf417", "aztec", "datamatrix", "itf14", "interleaved2of5"]
+  }
+
+  // NOTE: intentionally NOT @objc — AVMetadataObject.ObjectType does not
+  // bridge cleanly to Objective-C in the generated -Swift.h header and
+  // causes "expected a type" build errors if exposed. These are internal
+  // Swift-only helpers; call them only from other Swift code.
+  internal static func avFormat(for name: String) -> AVMetadataObject.ObjectType? {
+    switch name {
+    case "qr": return .qr
+    case "ean13": return .ean13
+    case "ean8": return .ean8
+    case "upce": return .upce
+    case "code128": return .code128
+    case "code39": return .code39
+    case "code93": return .code93
+    case "pdf417": return .pdf417
+    case "aztec": return .aztec
+    case "datamatrix": return .dataMatrix
+    case "itf14": return .itf14
+    case "interleaved2of5": return .interleaved2of5
+    default: return nil
+    }
+  }
+
+  internal static func name(for avType: AVMetadataObject.ObjectType) -> String {
+    switch avType {
+    case .qr: return "qr"
+    case .ean13: return "ean13"
+    case .ean8: return "ean8"
+    case .upce: return "upce"
+    case .code128: return "code128"
+    case .code39: return "code39"
+    case .code93: return "code93"
+    case .pdf417: return "pdf417"
+    case .aztec: return "aztec"
+    case .dataMatrix: return "datamatrix"
+    case .itf14: return "itf14"
+    case .interleaved2of5: return "interleaved2of5"
+    default: return "unknown"
+    }
+  }
+
+  public override init() {
+    super.init()
+  }
+
+  @objc public func checkCameraPermission() -> String {
+    switch AVCaptureDevice.authorizationStatus(for: .video) {
+    case .authorized: return "granted"
+    case .denied: return "blocked"
+    case .restricted: return "restricted"
+    case .notDetermined: return "not-determined"
+    @unknown default: return "not-determined"
+    }
+  }
+
+  @objc public func requestCameraPermission(_ completion: @escaping (String) -> Void) {
+    let status = AVCaptureDevice.authorizationStatus(for: .video)
+
+    switch status {
+    case .authorized:
+      completion("granted")
+    case .denied:
+      completion("blocked")
+    case .restricted:
+      completion("restricted")
+    case .notDetermined:
+      AVCaptureDevice.requestAccess(for: .video) { granted in
+        DispatchQueue.main.async {
+          completion(granted ? "granted" : "blocked")
+        }
+      }
+    @unknown default:
+      completion("not-determined")
+    }
+  }
+
+  @objc public func openCameraSettings() {
+    DispatchQueue.main.async {
+      guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
+      UIApplication.shared.open(url)
+    }
+  }
+
+  @objc public func setTorchEnabled(_ enabled: Bool) {
+    guard let device = AVCaptureDevice.default(for: .video), device.hasTorch else { return }
+    do {
+      try device.lockForConfiguration()
+      device.torchMode = enabled ? .on : .off
+      device.unlockForConfiguration()
+    } catch {
+      // Best-effort: torch failures are non-fatal for scanning
+    }
+  }
+}

package/ios/ScannerViewManager.mm

@@ -0,0 +1,67 @@
+#import "RNCustomScanner-Swift.h"
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/RNCustomScannerSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNCustomScannerSpec/EventEmitters.h>
+#import <react/renderer/components/RNCustomScannerSpec/Props.h>
+#import <react/renderer/components/RNCustomScannerSpec/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+@interface ScannerView : RCTViewComponentView <RCTScannerViewViewProtocol>
+@end
+
+@implementation ScannerView {
+  RNScannerView *_scannerView;
+}
+
++ (facebook::react::ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<ScannerViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const ScannerViewProps>();
+    _props = defaultProps;
+
+    _scannerView = [[RNScannerView alloc] initWithFrame:self.bounds];
+    __weak ScannerView *weakSelf = self;
+    _scannerView.onBarcodeScanned = ^(NSDictionary<NSString *, id> *payload) {
+      [weakSelf emitBarcodeScanned:payload];
+    };
+    self.contentView = _scannerView;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &newProps = *std::static_pointer_cast<const ScannerViewProps>(props);
+
+  _scannerView.isActive = newProps.isActive;
+  _scannerView.torchOn = newProps.torchOn;
+
+  if (!newProps.scanFormats.empty()) {
+    NSMutableArray<NSString *> *formats = [NSMutableArray new];
+    for (const auto &format : newProps.scanFormats) {
+      [formats addObject:[NSString stringWithUTF8String:format.c_str()]];
+    }
+    _scannerView.scanFormats = formats;
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)emitBarcodeScanned:(NSDictionary<NSString *, id> *)payload {
+  if (!_eventEmitter) return;
+  const auto emitter = std::static_pointer_cast<const ScannerViewEventEmitter>(_eventEmitter);
+  emitter->onBarcodeScanned(ScannerViewEventEmitter::OnBarcodeScanned{
+    .value = std::string([payload[@"value"] UTF8String]),
+    .type = std::string([payload[@"type"] UTF8String]),
+    .timestamp = [payload[@"timestamp"] intValue]
+  });
+}
+
+@end
+
+Class<RCTComponentViewProtocol> ScannerViewCls(void) {
+  return ScannerView.class;
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "react-native-fabric-barcode-scanner",
+  "version": "1.0.0",
+  "description": "High-performance native barcode scanner for React Native with TurboModule + Fabric (New Architecture) support on iOS and Android",
+  "main": "src/index.tsx",
+  "types": "src/index.tsx",
+  "source": "src/index.tsx",
+  "react-native": "src/index.tsx",
+  "files": [
+    "src",
+    "ios",
+    "android",
+    "react-native-fabric-barcode-scanner.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/.cxx",
+    "!android/.gradle"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "react-native",
+    "barcode",
+    "scanner",
+    "qr",
+    "qr-code",
+    "camera",
+    "turbo-module",
+    "fabric",
+    "new-architecture",
+    "mlkit",
+    "camerax"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rajubarde12/react-native-fabric-barcode-scanner.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rajubarde12/react-native-fabric-barcode-scanner/issues"
+  },
+  "homepage": "https://github.com/Rajubarde12/react-native-fabric-barcode-scanner#readme",
+  "author": "Rajubarde12 (https://github.com/Rajubarde12)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": ">=0.74.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "typescript": "^5.0.0"
+  },
+  "codegenConfig": {
+    "name": "RNCustomScannerSpec",
+    "type": "all",
+    "jsSrcsDir": "src",
+    "ios": {
+      "componentProvider": {
+        "ScannerView": "ScannerView"
+      }
+    },
+    "android": {
+      "javaPackageName": "com.rncustomscanner"
+    }
+  }
+}

package/react-native-fabric-barcode-scanner.podspec

@@ -0,0 +1,28 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-fabric-barcode-scanner"
+  s.module_name  = "RNCustomScanner"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.platforms    = { :ios => "13.4" }
+  repo_url = package["repository"]["url"].sub(/^git\+/, "")
+  s.source       = { :git => repo_url, :tag => "v#{s.version}" }
+  s.static_framework = true
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  s.dependency "React-Core"
+
+  s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
+    "SWIFT_VERSION" => "5.0"
+  }
+
+  install_modules_dependencies(s)
+end

package/react-native.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {},
+      android: {},
+    },
+  },
+};

package/src/NativeScannerModule.ts

@@ -0,0 +1,21 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export type CameraPermissionStatus =
+  | 'granted'
+  | 'not-determined'
+  | 'denied'
+  | 'blocked'
+  | 'restricted';
+
+export interface Spec extends TurboModule {
+  checkCameraPermission(): Promise<CameraPermissionStatus>;
+  requestCameraPermission(): Promise<CameraPermissionStatus>;
+  openCameraSettings(): void;
+  setTorchEnabled(enabled: boolean): void;
+  getConstants(): {
+    SUPPORTED_FORMATS: string[];
+  };
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ScannerModule');

package/src/ScannerViewNativeComponent.ts

@@ -0,0 +1,28 @@
+import type { ViewProps, HostComponent } from 'react-native';
+import { codegenNativeComponent } from 'react-native';
+import type {
+  Int32,
+  WithDefault,
+  BubblingEventHandler,
+} from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface BarcodeScannedEvent {
+  value: string;
+  type: string; // e.g. 'qr', 'ean13', 'code128', 'pdf417', 'upc-e', etc.
+  timestamp: Int32;
+}
+
+export interface NativeProps extends ViewProps {
+  isActive?: WithDefault<boolean, true>;
+  torchOn?: WithDefault<boolean, false>;
+
+  // comma-free array prop: list of formats to actively decode
+  // e.g. ['qr','ean13','ean8','upc-a','upc-e','code128','code39','pdf417','aztec','datamatrix']
+  scanFormats?: string[];
+
+  onBarcodeScanned?: BubblingEventHandler<BarcodeScannedEvent>;
+}
+
+export default codegenNativeComponent<NativeProps>(
+  'ScannerView',
+) as HostComponent<NativeProps>;

package/src/index.tsx

@@ -0,0 +1,66 @@
+import ScannerModule from './NativeScannerModule';
+import type { CameraPermissionStatus } from './NativeScannerModule';
+import ScannerViewNative from './ScannerViewNativeComponent';
+import type { BarcodeScannedEvent } from './ScannerViewNativeComponent';
+
+export const ScannerView = ScannerViewNative;
+export type { BarcodeScannedEvent, CameraPermissionStatus };
+
+export interface CameraPermissionState {
+  status: CameraPermissionStatus;
+  canRequest: boolean;
+  canOpenSettings: boolean;
+}
+
+export function isCameraPermissionGranted(
+  status: CameraPermissionStatus,
+): boolean {
+  return status === 'granted';
+}
+
+export function canRequestCameraPermission(
+  status: CameraPermissionStatus,
+): boolean {
+  return status === 'not-determined' || status === 'denied';
+}
+
+export function shouldOpenCameraSettings(
+  status: CameraPermissionStatus,
+): boolean {
+  return status === 'blocked' || status === 'restricted';
+}
+
+export async function getCameraPermissionState(): Promise<CameraPermissionState> {
+  const status = await ScannerModule.checkCameraPermission();
+  return {
+    status,
+    canRequest: canRequestCameraPermission(status),
+    canOpenSettings: shouldOpenCameraSettings(status),
+  };
+}
+
+export async function checkCameraPermission(): Promise<CameraPermissionStatus> {
+  return ScannerModule.checkCameraPermission();
+}
+
+export async function requestCameraPermission(): Promise<CameraPermissionStatus> {
+  const current = await ScannerModule.checkCameraPermission();
+
+  if (current === 'granted') {
+    return 'granted';
+  }
+
+  if (!canRequestCameraPermission(current)) {
+    return current;
+  }
+
+  return ScannerModule.requestCameraPermission();
+}
+
+export function openCameraSettings(): void {
+  ScannerModule.openCameraSettings();
+}
+
+export function setTorchEnabled(enabled: boolean): void {
+  ScannerModule.setTorchEnabled(enabled);
+}