react-native-fabric-barcode-scanner 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rajubarde12
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# react-native-fabric-barcode-scanner
+
+Native barcode scanner for React Native built with **TurboModules** and **Fabric** (New Architecture). Uses AVFoundation on iOS and CameraX + ML Kit on Android.
+
+[![npm version](https://img.shields.io/npm/v/react-native-fabric-barcode-scanner.svg)](https://www.npmjs.com/package/react-native-fabric-barcode-scanner)
+[![license](https://img.shields.io/npm/l/react-native-fabric-barcode-scanner.svg)](https://github.com/Rajubarde12/react-native-fabric-barcode-scanner/blob/main/LICENSE)
+
+## Features
+
+- Fabric `ScannerView` component with continuous barcode scanning
+- TurboModule `ScannerModule` for camera permission and torch control
+- New Architecture support on iOS and Android
+- Configurable barcode formats (`qr`, `ean13`, `code128`, and more)
+- No permission dialogs from the view — permission is handled in JS via the module
+
+## Requirements
+
+- React Native **0.74+**
+- New Architecture enabled (`newArchEnabled=true` recommended)
+- iOS 13.4+
+- Android API 24+
+
+## Installation
+
+```bash
+npm install react-native-fabric-barcode-scanner
+# or
+yarn add react-native-fabric-barcode-scanner
+```
+
+### iOS
+
+```bash
+cd ios && pod install
+```
+
+Add camera usage description to `Info.plist`:
+
+```xml
+<key>NSCameraUsageDescription</key>
+<string>Camera access is required to scan barcodes</string>
+```
+
+### Android
+
+Camera permission is declared by the library. Ensure your app manifest includes camera access if not merged automatically:
+
+```xml
+<uses-permission android:name="android.permission.CAMERA" />
+```
+
+Enable New Architecture in `android/gradle.properties`:
+
+```properties
+newArchEnabled=true
+```
+
+## Usage
+
+```tsx
+import { useEffect, useState } from 'react';
+import { Button, Text, View } from 'react-native';
+import {
+  ScannerView,
+  getCameraPermissionState,
+  requestCameraPermission,
+  openCameraSettings,
+  type CameraPermissionStatus,
+} from 'react-native-fabric-barcode-scanner';
+
+function ScannerScreen() {
+  const [status, setStatus] = useState<CameraPermissionStatus>('not-determined');
+
+  const refreshPermission = async () => {
+    const state = await getCameraPermissionState();
+    setStatus(state.status);
+    return state;
+  };
+
+  useEffect(() => {
+    refreshPermission();
+  }, []);
+
+  if (status === 'granted') {
+    return (
+      <ScannerView
+        style={{ flex: 1 }}
+        isActive
+        torchOn={false}
+        scanFormats={['qr', 'ean13', 'code128']}
+        onBarcodeScanned={(event) => {
+          console.log(event.nativeEvent.value, event.nativeEvent.type);
+        }}
+      />
+    );
+  }
+
+  return (
+    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center', padding: 24 }}>
+      {status === 'not-determined' || status === 'denied' ? (
+        <Button
+          title="Allow camera"
+          onPress={async () => {
+            const next = await requestCameraPermission();
+            setStatus(next);
+          }}
+        />
+      ) : null}
+
+      {status === 'blocked' || status === 'restricted' ? (
+        <>
+          <Text style={{ marginBottom: 12, textAlign: 'center' }}>
+            Camera access is {status}. Open settings to enable it.
+          </Text>
+          <Button title="Open settings" onPress={openCameraSettings} />
+        </>
+      ) : null}
+    </View>
+  );
+}
+```
+
+## API
+
+### `ScannerView` props
+
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `isActive` | `boolean` | `true` | Start/stop the camera session |
+| `torchOn` | `boolean` | `false` | Enable device torch |
+| `scanFormats` | `string[]` | all supported | Barcode formats to decode |
+| `onBarcodeScanned` | `(event) => void` | — | Fired continuously while a code is visible |
+
+### Camera permission (same API on iOS & Android)
+
+Use **one flow** for both platforms:
+
+```tsx
+if (status === 'not-determined' || status === 'denied') {
+  // Show "Allow camera" → requestCameraPermission()
+} else if (status === 'blocked' || status === 'restricted') {
+  // Show "Open settings" → openCameraSettings()
+} else {
+  // granted → show ScannerView
+}
+```
+
+| Status | Meaning | Developer action |
+|--------|---------|------------------|
+| `granted` | Camera allowed | Show `ScannerView` |
+| `not-determined` | Never asked yet | `requestCameraPermission()` |
+| `denied` | Denied, system dialog can still appear | `requestCameraPermission()` |
+| `blocked` | System will not ask again | `openCameraSettings()` |
+| `restricted` | Restricted by device policy (iOS) | `openCameraSettings()` |
+
+**How each platform maps to the same status:**
+
+| Scenario | iOS returns | Android returns |
+|----------|-------------|-----------------|
+| Never asked | `not-determined` | `not-determined` |
+| User allowed | `granted` | `granted` |
+| Denied, can ask again | — (iOS does not re-prompt) | `denied` |
+| Denied permanently | `blocked` (after 1 deny) | `blocked` (after 2+ denies or "Don't ask again") |
+| Device restricted | `restricted` | — |
+
+iOS blocks after **one** deny. Android allows **2–3** prompts, then returns `blocked` — but your JS code stays the same on both platforms.
+
+### `ScannerModule` methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `getCameraPermissionState()` | `Promise<{ status, canRequest, canOpenSettings }>` | Full permission state for UI |
+| `checkCameraPermission()` | `Promise<CameraPermissionStatus>` | Current camera permission status |
+| `requestCameraPermission()` | `Promise<CameraPermissionStatus>` | Request permission (only when allowed) |
+| `openCameraSettings()` | `void` | Open app settings so user can enable camera |
+| `canRequestCameraPermission(status)` | `boolean` | `true` for `not-determined` or `denied` |
+| `shouldOpenCameraSettings(status)` | `boolean` | `true` for `blocked` or `restricted` |
+| `isCameraPermissionGranted(status)` | `boolean` | `true` when `granted` |
+| `setTorchEnabled(enabled)` | `void` | Toggle torch outside the view |
+
+### Supported formats
+
+`qr`, `ean13`, `ean8`, `upce`, `code128`, `code39`, `code93`, `pdf417`, `aztec`, `datamatrix`, `itf14`, `interleaved2of5`
+
+## New Architecture
+
+This library is built for React Native's New Architecture:
+
+- **TurboModule**: `ScannerModule`
+- **Fabric component**: `ScannerView`
+- Codegen spec: `RNCustomScannerSpec`
+
+Legacy architecture is supported via paper fallbacks on Android.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Repository
+
+- **GitHub**: [Rajubarde12/react-native-fabric-barcode-scanner](https://github.com/Rajubarde12/react-native-fabric-barcode-scanner)
+- **npm**: [react-native-fabric-barcode-scanner](https://www.npmjs.com/package/react-native-fabric-barcode-scanner)
+- **Issues**: [Report a bug](https://github.com/Rajubarde12/react-native-fabric-barcode-scanner/issues)

package/android/build.gradle

@@ -0,0 +1,68 @@
+buildscript {
+    ext.safeExtGet = { prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+}
+
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+
+android {
+    namespace "com.rncustomscanner"
+    compileSdk safeExtGet("compileSdkVersion", 36)
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 24)
+        targetSdkVersion safeExtGet("targetSdkVersion", 36)
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    }
+
+    buildFeatures {
+        buildConfig true
+    }
+
+    sourceSets {
+        main {
+            java {
+                if (isNewArchitectureEnabled()) {
+                    srcDirs += [
+                        "src/newarch/java",
+                        "${project.buildDir}/generated/source/codegen/java",
+                    ]
+                } else {
+                    srcDirs += ["src/oldarch/java"]
+                }
+            }
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+def kotlinVersion = safeExtGet("kotlinVersion", "2.1.20")
+
+dependencies {
+    implementation "com.facebook.react:react-android"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
+
+    def cameraxVersion = "1.4.2"
+    implementation "androidx.camera:camera-core:$cameraxVersion"
+    implementation "androidx.camera:camera-camera2:$cameraxVersion"
+    implementation "androidx.camera:camera-lifecycle:$cameraxVersion"
+    implementation "androidx.camera:camera-view:$cameraxVersion"
+    implementation "androidx.appcompat:appcompat:1.7.0"
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.8.7"
+
+    implementation "com.google.mlkit:barcode-scanning:17.3.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+</manifest>

package/android/src/main/java/com/rncustomscanner/BarcodeAnalyzer.kt

@@ -0,0 +1,56 @@
+package com.rncustomscanner
+
+import android.annotation.SuppressLint
+import androidx.camera.core.ExperimentalGetImage
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageProxy
+import com.google.mlkit.vision.barcode.BarcodeScanner
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.google.mlkit.vision.common.InputImage
+
+class BarcodeAnalyzer(
+    private var onBarcodesDetected: (List<Barcode>) -> Unit,
+) : ImageAnalysis.Analyzer {
+
+    private var scanner: BarcodeScanner = createScanner(intArrayOf())
+
+    fun updateFormats(formats: IntArray) {
+        scanner.close()
+        scanner = createScanner(formats)
+    }
+
+    private fun createScanner(formats: IntArray): BarcodeScanner {
+        val builder = BarcodeScannerOptions.Builder()
+        if (formats.isNotEmpty()) {
+            builder.setBarcodeFormats(formats.first(), *formats.drop(1).toIntArray())
+        }
+        return BarcodeScanning.getClient(builder.build())
+    }
+
+    @SuppressLint("UnsafeOptInUsageError")
+    @ExperimentalGetImage
+    override fun analyze(image: ImageProxy) {
+        val mediaImage = image.image
+        if (mediaImage == null) {
+            image.close()
+            return
+        }
+
+        val inputImage = InputImage.fromMediaImage(mediaImage, image.imageInfo.rotationDegrees)
+        scanner.process(inputImage)
+            .addOnSuccessListener { barcodes ->
+                if (barcodes.isNotEmpty()) {
+                    onBarcodesDetected(barcodes)
+                }
+            }
+            .addOnCompleteListener {
+                image.close()
+            }
+    }
+
+    fun close() {
+        scanner.close()
+    }
+}

package/android/src/main/java/com/rncustomscanner/BarcodeFormatMapper.kt

@@ -0,0 +1,59 @@
+package com.rncustomscanner
+
+import com.google.mlkit.vision.barcode.common.Barcode
+
+object BarcodeFormatMapper {
+    val supportedFormats: List<String> = listOf(
+        "qr",
+        "ean13",
+        "ean8",
+        "upce",
+        "code128",
+        "code39",
+        "code93",
+        "pdf417",
+        "aztec",
+        "datamatrix",
+        "itf14",
+        "interleaved2of5",
+    )
+
+    fun toMlKitFormat(name: String): Int? {
+        return when (name) {
+            "qr" -> Barcode.FORMAT_QR_CODE
+            "ean13" -> Barcode.FORMAT_EAN_13
+            "ean8" -> Barcode.FORMAT_EAN_8
+            "upce" -> Barcode.FORMAT_UPC_E
+            "code128" -> Barcode.FORMAT_CODE_128
+            "code39" -> Barcode.FORMAT_CODE_39
+            "code93" -> Barcode.FORMAT_CODE_93
+            "pdf417" -> Barcode.FORMAT_PDF417
+            "aztec" -> Barcode.FORMAT_AZTEC
+            "datamatrix" -> Barcode.FORMAT_DATA_MATRIX
+            "itf14", "interleaved2of5" -> Barcode.FORMAT_ITF
+            else -> null
+        }
+    }
+
+    fun fromMlKitFormat(@Barcode.BarcodeFormat format: Int): String {
+        return when (format) {
+            Barcode.FORMAT_QR_CODE -> "qr"
+            Barcode.FORMAT_EAN_13 -> "ean13"
+            Barcode.FORMAT_EAN_8 -> "ean8"
+            Barcode.FORMAT_UPC_E -> "upce"
+            Barcode.FORMAT_UPC_A -> "upce"
+            Barcode.FORMAT_CODE_128 -> "code128"
+            Barcode.FORMAT_CODE_39 -> "code39"
+            Barcode.FORMAT_CODE_93 -> "code93"
+            Barcode.FORMAT_PDF417 -> "pdf417"
+            Barcode.FORMAT_AZTEC -> "aztec"
+            Barcode.FORMAT_DATA_MATRIX -> "datamatrix"
+            Barcode.FORMAT_ITF -> "itf14"
+            else -> "unknown"
+        }
+    }
+
+    fun toMlKitFormats(names: List<String>): IntArray {
+        return names.mapNotNull { toMlKitFormat(it) }.distinct().toIntArray()
+    }
+}

package/android/src/main/java/com/rncustomscanner/CameraPermissionHelper.kt

@@ -0,0 +1,140 @@
+package com.rncustomscanner
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.provider.Settings
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.ReactApplicationContext
+
+object CameraPermissionHelper {
+
+    const val STATUS_GRANTED = "granted"
+    const val STATUS_NOT_DETERMINED = "not-determined"
+    const val STATUS_DENIED = "denied"
+    const val STATUS_BLOCKED = "blocked"
+    const val STATUS_RESTRICTED = "restricted"
+
+    private const val PREFS_NAME = "rncustomscanner_permissions"
+    private const val KEY_CAMERA_REQUESTED = "camera_requested"
+    private const val KEY_CAMERA_DENY_COUNT = "camera_deny_count"
+
+    fun checkPermission(context: ReactApplicationContext): String {
+        if (isGranted(context)) {
+            return STATUS_GRANTED
+        }
+
+        if (!wasPermissionRequested(context)) {
+            return STATUS_NOT_DETERMINED
+        }
+
+        if (shouldShowRationale(context)) {
+            return STATUS_DENIED
+        }
+
+        // Unified with iOS: only blocked when the system will not show the dialog again.
+        // Android may deny 1-2 times before reaching this state.
+        return if (getDenyCount(context) >= 2) {
+            STATUS_BLOCKED
+        } else {
+            STATUS_DENIED
+        }
+    }
+
+    fun resolveRequestResult(
+        context: ReactApplicationContext,
+        grantResults: IntArray,
+    ): String {
+        markPermissionRequested(context)
+
+        val granted = grantResults.isNotEmpty() &&
+            grantResults[0] == PackageManager.PERMISSION_GRANTED
+
+        if (granted) {
+            clearDenyCount(context)
+            return STATUS_GRANTED
+        }
+
+        incrementDenyCount(context)
+        return resolveDeniedStatus(context)
+    }
+
+    fun canRequestPermission(status: String): Boolean {
+        return status == STATUS_NOT_DETERMINED || status == STATUS_DENIED
+    }
+
+    fun markPermissionRequested(context: ReactApplicationContext) {
+        getPrefs(context)
+            .edit()
+            .putBoolean(KEY_CAMERA_REQUESTED, true)
+            .apply()
+    }
+
+    fun openAppSettings(context: ReactApplicationContext) {
+        val intent = Intent(
+            Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+            Uri.fromParts("package", context.packageName, null),
+        ).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        context.startActivity(intent)
+    }
+
+    private fun resolveDeniedStatus(context: ReactApplicationContext): String {
+        if (shouldShowRationale(context)) {
+            return STATUS_DENIED
+        }
+
+        // First denial: always "denied" (Android can still show the dialog again).
+        // Second+ denial without rationale: "blocked" (same as iOS after one deny).
+        return if (getDenyCount(context) >= 2) {
+            STATUS_BLOCKED
+        } else {
+            STATUS_DENIED
+        }
+    }
+
+    private fun isGranted(context: ReactApplicationContext): Boolean {
+        val activity = context.currentActivity
+        val checkContext = activity ?: context
+        return ContextCompat.checkSelfPermission(checkContext, Manifest.permission.CAMERA) ==
+            PackageManager.PERMISSION_GRANTED
+    }
+
+    private fun shouldShowRationale(context: ReactApplicationContext): Boolean {
+        val activity = context.currentActivity ?: return false
+        return ActivityCompat.shouldShowRequestPermissionRationale(
+            activity,
+            Manifest.permission.CAMERA,
+        )
+    }
+
+    private fun wasPermissionRequested(context: ReactApplicationContext): Boolean {
+        return getPrefs(context).getBoolean(KEY_CAMERA_REQUESTED, false)
+    }
+
+    private fun getDenyCount(context: ReactApplicationContext): Int {
+        return getPrefs(context).getInt(KEY_CAMERA_DENY_COUNT, 0)
+    }
+
+    private fun incrementDenyCount(context: ReactApplicationContext) {
+        val count = getDenyCount(context)
+        getPrefs(context)
+            .edit()
+            .putInt(KEY_CAMERA_DENY_COUNT, count + 1)
+            .apply()
+    }
+
+    private fun clearDenyCount(context: ReactApplicationContext) {
+        getPrefs(context)
+            .edit()
+            .putInt(KEY_CAMERA_DENY_COUNT, 0)
+            .apply()
+    }
+
+    private fun getPrefs(context: ReactApplicationContext) =
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+}

package/android/src/main/java/com/rncustomscanner/RNCustomScannerPackage.kt

@@ -0,0 +1,44 @@
+package com.rncustomscanner
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class RNCustomScannerPackage : TurboReactPackage() {
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext,
+    ): List<ViewManager<*, *>> {
+        return listOf(ScannerViewManager(reactContext))
+    }
+
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? {
+        return if (name == ScannerModule.NAME) {
+            ScannerModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        return ReactModuleInfoProvider {
+            mapOf(
+                ScannerModule.NAME to ReactModuleInfo(
+                    ScannerModule.NAME,
+                    ScannerModule.NAME,
+                    false,
+                    false,
+                    false,
+                    isTurboModule,
+                ),
+            )
+        }
+    }
+}