@cleanuidev/react-native-scanner 1.0.0-beta.1

package/android/build.gradle

@@ -0,0 +1,90 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Scanner_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Scanner_" + name]).toInteger()
+}
+
+android {
+  namespace "com.scanner"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  
+  // Camera dependencies
+  implementation "androidx.camera:camera-core:1.3.1"
+  implementation "androidx.camera:camera-camera2:1.3.1"
+  implementation "androidx.camera:camera-lifecycle:1.3.1"
+  implementation "androidx.camera:camera-view:1.3.1"
+  
+  // ML Kit for barcode scanning
+  implementation "com.google.mlkit:barcode-scanning:17.2.0"
+  
+  // Lifecycle dependencies
+  implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0"
+  implementation "androidx.lifecycle:lifecycle-common-java8:2.7.0"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+Scanner_kotlinVersion=2.0.21
+Scanner_minSdkVersion=24
+Scanner_targetSdkVersion=34
+Scanner_compileSdkVersion=35
+Scanner_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Camera permissions -->
+  <uses-permission android:name="android.permission.CAMERA" />
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+  <uses-feature android:name="android.hardware.camera" android:required="true" />
+  <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
+  <uses-feature android:name="android.hardware.camera.flash" android:required="false" />
+</manifest>

package/android/src/main/java/com/scanner/CameraInfoModule.kt

@@ -0,0 +1,253 @@
+package com.scanner
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.hardware.camera2.CameraCharacteristics
+import android.hardware.camera2.CameraManager
+import android.Manifest
+import android.util.Log
+import androidx.camera.core.CameraSelector
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+// Removed @ReactModule annotation for compatibility
+class CameraInfoModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+  private val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+  private var cameraProvider: ProcessCameraProvider? = null
+
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun getCameraInfo(promise: Promise) {
+    try {
+      // Check camera permission first
+      if (!hasCameraPermission()) {
+        promise.reject("PERMISSION_ERROR", "Camera permission not granted")
+        return
+      }
+
+      val cameraManager = reactApplicationContext.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+      val cameraArray = Arguments.createArray()
+      
+      // Check if camera list is available
+      if (cameraManager.cameraIdList.isEmpty()) {
+        promise.reject("NO_CAMERAS_ERROR", "No cameras found on device")
+        return
+      }
+      
+      // Collect all camera info first, then deduplicate
+      val allCameras = mutableListOf<Pair<String, CameraCharacteristics>>()
+      
+      for (cameraId in cameraManager.cameraIdList) {
+        try {
+          val characteristics = cameraManager.getCameraCharacteristics(cameraId)
+          allCameras.add(cameraId to characteristics)
+        } catch (e: Exception) {
+          Log.w("CameraInfoModule", "Failed to get characteristics for camera $cameraId", e)
+          continue
+        }
+      }
+      
+      // Deduplicate cameras based on characteristics
+      val uniqueCameras = deduplicateCameras(allCameras)
+      
+      // Create camera info maps for unique cameras
+      for ((cameraId, characteristics) in uniqueCameras) {
+        val cameraInfo = createCameraInfoMap(cameraId, characteristics)
+        cameraArray.pushMap(cameraInfo)
+      }
+      
+      // If no cameras were successfully processed, return error
+      if (cameraArray.size() == 0) {
+        promise.reject("CAMERA_ACCESS_ERROR", "Failed to access any camera characteristics")
+        return
+      }
+      
+      val result = Arguments.createMap().apply {
+        putArray("cameras", cameraArray)
+        putString("defaultBackCamera", getDefaultBackCameraId(cameraManager))
+        putString("defaultFrontCamera", getDefaultFrontCameraId(cameraManager))
+      }
+      
+      promise.resolve(result)
+    } catch (e: Exception) {
+      Log.e("CameraInfoModule", "Error getting camera info", e)
+      promise.reject("CAMERA_INFO_ERROR", "Failed to get camera information: ${e.message}", e)
+    }
+  }
+
+  @ReactMethod
+  fun getCurrentCameraInfo(promise: Promise) {
+    try {
+      val cameraProviderFuture = ProcessCameraProvider.getInstance(reactApplicationContext)
+      cameraProviderFuture.addListener({
+        try {
+          cameraProvider = cameraProviderFuture.get()
+          val cameraInfo = getCurrentCameraCapabilities()
+          promise.resolve(cameraInfo)
+        } catch (e: Exception) {
+          Log.e("CameraInfoModule", "Error getting current camera info", e)
+          promise.reject("CURRENT_CAMERA_ERROR", "Failed to get current camera info", e)
+        }
+      }, ContextCompat.getMainExecutor(reactApplicationContext))
+    } catch (e: Exception) {
+      Log.e("CameraInfoModule", "Error initializing camera provider", e)
+      promise.reject("CAMERA_PROVIDER_ERROR", "Failed to initialize camera provider", e)
+    }
+  }
+
+  private fun hasCameraPermission(): Boolean {
+    return reactApplicationContext.checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
+  }
+
+  private fun createCameraInfoMap(cameraId: String, characteristics: CameraCharacteristics): WritableMap {
+    val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)
+    val sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION) ?: 0
+    val minFocusDistance = characteristics.get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE)
+    val availableFocalLengths = characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS)
+    val availableAeModes = characteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES)
+    val availableAfModes = characteristics.get(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES)
+    val flashAvailable = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) ?: false
+    
+    // Determine if this is a macro camera
+    val isMacroCamera = isMacroCamera(characteristics)
+    
+    // Get zoom range
+    val maxZoom = characteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM) ?: 1.0f
+    val minZoom = 1.0f // Digital zoom typically starts at 1.0
+    
+    return Arguments.createMap().apply {
+      putString("id", cameraId)
+      putString("facing", when (lensFacing) {
+        CameraCharacteristics.LENS_FACING_FRONT -> "front"
+        CameraCharacteristics.LENS_FACING_BACK -> "back"
+        else -> "unknown"
+      })
+      putInt("sensorOrientation", sensorOrientation)
+      putDouble("minFocusDistance", minFocusDistance?.toDouble() ?: -1.0)
+      putBoolean("hasFlash", flashAvailable)
+      putBoolean("isMacroCamera", isMacroCamera)
+      
+      // Add zoom range as separate properties
+      putDouble("zoomMin", minZoom.toDouble())
+      putDouble("zoomMax", maxZoom.toDouble())
+      
+      // Convert arrays to supported types for React Native
+      putArray("focalLengths", availableFocalLengths?.let { lengths ->
+        val stringArray = lengths.map { it.toString() }.toTypedArray()
+        Arguments.fromArray(stringArray)
+      } ?: Arguments.createArray())
+      
+      putArray("aeModes", availableAeModes?.let { modes ->
+        val stringArray = modes.map { it.toString() }.toTypedArray()
+        Arguments.fromArray(stringArray)
+      } ?: Arguments.createArray())
+      
+      putArray("afModes", availableAfModes?.let { modes ->
+        val stringArray = modes.map { it.toString() }.toTypedArray()
+        Arguments.fromArray(stringArray)
+      } ?: Arguments.createArray())
+    }
+  }
+
+  private fun isMacroCamera(characteristics: CameraCharacteristics): Boolean {
+    val minFocusDistance = characteristics.get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE)
+    val availableFocalLengths = characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS)
+    
+    // Macro cameras typically have very small minimum focus distance
+    val hasCloseFocus = minFocusDistance != null && minFocusDistance < 0.5f
+    
+    // Macro cameras often have specific focal lengths
+    val hasMacroFocalLength = availableFocalLengths?.any { it < 3.0f } == true
+    
+    return hasCloseFocus || hasMacroFocalLength
+  }
+
+  private fun deduplicateCameras(cameras: List<Pair<String, CameraCharacteristics>>): List<Pair<String, CameraCharacteristics>> {
+    val uniqueCameras = mutableListOf<Pair<String, CameraCharacteristics>>()
+    val seenCharacteristics = mutableSetOf<String>()
+    
+    for ((cameraId, characteristics) in cameras) {
+      // Create a unique key based on camera characteristics
+      val key = createCameraKey(characteristics)
+      
+      if (!seenCharacteristics.contains(key)) {
+        seenCharacteristics.add(key)
+        uniqueCameras.add(cameraId to characteristics)
+      } else {
+        Log.d("CameraInfoModule", "Skipping duplicate camera: $cameraId")
+      }
+    }
+    
+    return uniqueCameras
+  }
+
+  private fun createCameraKey(characteristics: CameraCharacteristics): String {
+    val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING) ?: -1
+    val sensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION) ?: 0
+    val minFocusDistance = characteristics.get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE)
+    val availableFocalLengths = characteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS)
+    val flashAvailable = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE) ?: false
+    
+    // Create a unique key based on physical characteristics
+    val focalLengthsStr = availableFocalLengths?.joinToString(",") ?: ""
+    val minFocusStr = minFocusDistance?.toString() ?: "null"
+    
+    return "$lensFacing-$sensorOrientation-$minFocusStr-$focalLengthsStr-$flashAvailable"
+  }
+
+  private fun getDefaultBackCameraId(cameraManager: CameraManager): String {
+    for (cameraId in cameraManager.cameraIdList) {
+      try {
+        val characteristics = cameraManager.getCameraCharacteristics(cameraId)
+        val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)
+        if (lensFacing == CameraCharacteristics.LENS_FACING_BACK) {
+          return cameraId
+        }
+      } catch (e: Exception) {
+        Log.w("CameraInfoModule", "Failed to get characteristics for camera $cameraId", e)
+        continue
+      }
+    }
+    return cameraManager.cameraIdList.firstOrNull() ?: ""
+  }
+
+  private fun getDefaultFrontCameraId(cameraManager: CameraManager): String {
+    for (cameraId in cameraManager.cameraIdList) {
+      try {
+        val characteristics = cameraManager.getCameraCharacteristics(cameraId)
+        val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)
+        if (lensFacing == CameraCharacteristics.LENS_FACING_FRONT) {
+          return cameraId
+        }
+      } catch (e: Exception) {
+        Log.w("CameraInfoModule", "Failed to get characteristics for camera $cameraId", e)
+        continue
+      }
+    }
+    return ""
+  }
+
+  private fun getCurrentCameraCapabilities(): WritableMap {
+    // This would be called when a camera is already bound
+    // For now, return basic info
+    return Arguments.createMap().apply {
+      putString("status", "camera_bound")
+      putString("message", "Camera capabilities available when camera is bound")
+    }
+  }
+
+  override fun onCatalystInstanceDestroy() {
+    super.onCatalystInstanceDestroy()
+    cameraExecutor.shutdown()
+  }
+
+  companion object {
+    const val NAME = "CameraInfoModule"
+  }
+} 

package/android/src/main/java/com/scanner/ScannerPackage.kt

@@ -0,0 +1,21 @@
+package com.scanner
+
+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
+
+class ScannerViewPackage : ReactPackage {
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    val viewManagers: MutableList<ViewManager<*, *>> = ArrayList()
+    viewManagers.add(ScannerViewManager())
+    return viewManagers
+  }
+
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    val modules: MutableList<NativeModule> = ArrayList()
+    modules.add(CameraInfoModule(reactContext))
+    return modules
+  }
+}