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

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

@@ -0,0 +1,181 @@
+package com.scanner
+
+import android.graphics.Color
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.RCTModernEventEmitter
+
+@ReactModule(name = ScannerViewManager.NAME)
+class ScannerViewManager : SimpleViewManager<ScannerView>() {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  public override fun createViewInstance(context: ThemedReactContext): ScannerView {
+    return ScannerView(context)
+  }
+
+  // Barcode configuration
+  @ReactProp(name = "barcodeTypes")
+  fun setBarcodeTypes(view: ScannerView?, types: ReadableArray?) {
+    if (types != null) {
+      val typeList = mutableListOf<String>()
+      for (i in 0 until types.size()) {
+        typeList.add(types.getString(i) ?: "")
+      }
+      Log.d("ScannerViewManager", "Barcode types set: $typeList")
+      // Note: The actual barcode type filtering would be implemented in ScannerView
+      // For now, ML Kit will detect all supported barcode types
+    }
+  }
+
+  // Focus area configuration
+  @ReactProp(name = "focusArea")
+  fun setFocusArea(view: ScannerView?, focusArea: ReadableMap?) {
+    if (focusArea != null) {
+      val enabled = focusArea.getBoolean("enabled") ?: false
+      val showOverlay = focusArea.getBoolean("showOverlay") ?: false
+      val borderColor = focusArea.getString("borderColor")
+      val tintColor = focusArea.getString("tintColor")
+      val size = focusArea.getDynamic("size")
+      val position = focusArea.getMap("position")
+      
+      // Set focus area properties
+      view?.setFocusAreaEnabled(enabled)
+      view?.setEnableFrame(showOverlay)
+      
+      if (borderColor != null) {
+        view?.setBorderColor(borderColor)
+      }
+      
+      if (tintColor != null) {
+        view?.setTintColor(tintColor)
+      }
+      
+      if (position != null) {
+        val x = position.getDouble("x").toFloat()
+        val y = position.getDouble("y").toFloat()
+        view?.setPosition(x, y)
+      }
+      
+      if (size != null) {
+        val frameSize: FrameSize = when {
+          size.type == ReadableType.Number -> FrameSize.Square(size.asInt())
+          size.type == ReadableType.Map -> {
+            val frameSizeMap = size.asMap()
+            val width = frameSizeMap.getInt("width")
+            val height = frameSizeMap.getInt("height")
+            FrameSize.Rectangle(width, height)
+          }
+          else -> FrameSize.Square(300) // Default
+        }
+        view?.setFrameSize(frameSize)
+      }
+      
+      Log.d("ScannerViewManager", "Focus area configured: enabled=$enabled, showOverlay=$showOverlay, borderColor=$borderColor, tintColor=$tintColor, position=$position")
+    }
+  }
+
+  // Barcode frames configuration
+  @ReactProp(name = "barcodeFrames")
+  fun setBarcodeFrames(view: ScannerView?, barcodeFrames: ReadableMap?) {
+    if (barcodeFrames != null) {
+      val enabled = barcodeFrames.getBoolean("enabled") ?: false
+      val color = barcodeFrames.getString("color")
+      val onlyInFocusArea = barcodeFrames.getBoolean("onlyInFocusArea") ?: false
+      
+      // Set barcode frames properties
+      view?.setBarcodeFramesEnabled(enabled)
+      view?.setShowBarcodeFramesOnlyInFrame(onlyInFocusArea)
+      
+      if (color != null) {
+        view?.setBarcodeFramesColor(color)
+      }
+      
+      Log.d("ScannerViewManager", "Barcode frames configured: enabled=$enabled, onlyInFocusArea=$onlyInFocusArea, color=$color")
+    }
+  }
+
+  // Torch control
+  @ReactProp(name = "torch")
+  fun setTorch(view: ScannerView?, enabled: Boolean?) {
+    view?.setTorch(enabled ?: false)
+  }
+
+  // Event handlers
+  @ReactProp(name = "onBarcodeScanned")
+  fun setOnBarcodeScanned(view: ScannerView?, onBarcodeScanned: Boolean?) {
+    // This prop is used to register the event handler
+    // The actual event emission happens in ScannerView.processImage()
+    Log.d("ScannerViewManager", "onBarcodeScanned event handler registered")
+  }
+
+  @ReactProp(name = "onScannerError")
+  fun setOnScannerError(view: ScannerView?, onScannerError: Boolean?) {
+    // This prop is used to register the event handler
+    Log.d("ScannerViewManager", "onScannerError event handler registered")
+  }
+
+  @ReactProp(name = "onLoad")
+  fun setOnLoad(view: ScannerView?, onLoad: Boolean?) {
+    // This prop is used to register the event handler
+    Log.d("ScannerViewManager", "onLoad event handler registered")
+  }
+
+  @ReactProp(name = "zoom")
+  fun setZoom(view: ScannerView?, zoom: Double) {
+    view?.setZoom(zoom.toFloat())
+  }
+
+  @ReactProp(name = "pauseScanning")
+  fun setPauseScanning(view: ScannerView?, pause: Boolean?) {
+    if (pause == true) {
+      view?.pauseScanning()
+    } else {
+      view?.resumeScanning()
+    }
+  }
+
+  @ReactProp(name = "barcodeScanStrategy")
+  fun setBarcodeScanStrategy(view: ScannerView?, strategy: String?) {
+    view?.setBarcodeScanStrategy(strategy ?: "ALL")
+  }
+
+  @ReactProp(name = "keepScreenOn")
+  fun setKeepScreenOn(view: ScannerView?, keepOn: Boolean?) {
+    view?.setKeepScreenOnEnabled(keepOn ?: true)
+  }
+
+  @ReactProp(name = "barcodeEmissionInterval")
+  fun setBarcodeEmissionInterval(view: ScannerView?, interval: Double) {
+    // Use 0.5 as default if interval is 0 or negative (React Native may pass 0 for undefined)
+    val actualInterval = if (interval > 0) interval else 0.5
+    view?.setBarcodeEmissionInterval(actualInterval)
+  }
+
+  companion object {
+    const val NAME = "ScannerView"
+  }
+
+  override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
+    val map = mutableMapOf<String, Any>()
+    map["onBarcodeScanned"] = mapOf(
+      "phasedRegistrationNames" to mapOf(
+        "bubbled" to "onBarcodeScanned"
+      )
+    )
+    // Add more events here if needed
+    return map
+  }
+}
+
+// Data classes for frame configuration
+sealed class FrameSize {
+  data class Square(val size: Int) : FrameSize()
+  data class Rectangle(val width: Int, val height: Int) : FrameSize()
+}

package/android/src/main/java/com/scanner/utils/BarcodeFrameManager.kt

@@ -0,0 +1,170 @@
+package com.scanner.utils
+
+import android.graphics.RectF
+import android.util.Log
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.TimeUnit
+
+/**
+ * Manages barcode frames with efficient cleanup scheduling.
+ * Only schedules cleanup when there are active frames to monitor.
+ */
+class BarcodeFrameManager {
+  companion object {
+    private const val FRAME_TIMEOUT_MS = 1000L // 1 second timeout
+    private const val CLEANUP_DELAY_MS = 1000L // 1 second delay before cleanup
+    const val TAG = "BarcodeFrameManager"
+  }
+
+  // Thread-safe map to store active barcode frames
+  private val activeBarcodeFrames = ConcurrentHashMap<String, BarcodeFrame>()
+
+  // Executor for cleanup scheduling
+  private val cleanupExecutor: ScheduledExecutorService =
+    Executors.newSingleThreadScheduledExecutor()
+
+  // Current cleanup task (if any)
+  private var currentCleanupTask: java.util.concurrent.ScheduledFuture<*>? = null
+
+  // Callback to update the display
+  private var onFramesChanged: (() -> Unit)? = null
+
+  /**
+   * Data class representing a barcode frame with its position and last seen time
+   */
+  data class BarcodeFrame(
+    val rect: RectF,
+    val lastSeenTime: Long
+  )
+
+  /**
+   * Set callback to be called when frames change
+   */
+  fun setOnFramesChangedListener(listener: () -> Unit) {
+    onFramesChanged = listener
+  }
+
+  /**
+   * Update barcode frames with new detections
+   */
+  fun updateBarcodeFrames(barcodeFrames: Map<String, RectF>) {
+    val currentTime = System.currentTimeMillis()
+    val currentBarcodeValues = mutableSetOf<String>()
+
+    // Update existing frames or add new ones
+    barcodeFrames.forEach { (barcodeValue, rect) ->
+      currentBarcodeValues.add(barcodeValue)
+      activeBarcodeFrames[barcodeValue] = BarcodeFrame(
+        rect = rect,
+        lastSeenTime = currentTime
+      )
+    }
+
+    // Remove frames for barcodes no longer visible
+    val framesToRemove = activeBarcodeFrames.keys.filter { it !in currentBarcodeValues }
+    framesToRemove.forEach { barcodeValue ->
+      activeBarcodeFrames.remove(barcodeValue)
+    }
+
+    // Schedule cleanup if we have frames and no cleanup is currently scheduled
+    if (activeBarcodeFrames.isNotEmpty() && currentCleanupTask?.isDone != false) {
+      scheduleCleanup()
+    }
+
+    // Notify display update
+    onFramesChanged?.invoke()
+  }
+
+  /**
+   * Get current active frames for display
+   */
+  fun getActiveFrames(): List<RectF> {
+    return activeBarcodeFrames.values.map { it.rect }
+  }
+
+  /**
+   * Get count of active frames
+   */
+//    fun getActiveFrameCount(): Int {
+//        return activeBarcodeFrames.size
+//    }
+
+  /**
+   * Schedule cleanup of stale frames
+   */
+  private fun scheduleCleanup() {
+    // Cancel any existing cleanup task
+    currentCleanupTask?.cancel(false)
+
+    // Schedule new cleanup task
+    currentCleanupTask = cleanupExecutor.schedule({
+      cleanupStaleFrames()
+    }, CLEANUP_DELAY_MS, TimeUnit.MILLISECONDS)
+
+    Log.d(TAG, "Scheduled cleanup in ${CLEANUP_DELAY_MS}ms for ${activeBarcodeFrames.size} frames")
+  }
+
+  /**
+   * Clean up stale frames and reschedule if needed
+   */
+  private fun cleanupStaleFrames() {
+    val currentTime = System.currentTimeMillis()
+    val framesToRemove = mutableListOf<String>()
+
+    activeBarcodeFrames.forEach { (barcodeValue, frame) ->
+      if (currentTime - frame.lastSeenTime > FRAME_TIMEOUT_MS) {
+        framesToRemove.add(barcodeValue)
+      }
+    }
+
+    if (framesToRemove.isNotEmpty()) {
+      framesToRemove.forEach { barcodeValue ->
+        activeBarcodeFrames.remove(barcodeValue)
+      }
+
+      Log.d(TAG, "Removed ${framesToRemove.size} stale barcode frames")
+      onFramesChanged?.invoke()
+    }
+
+    // Reschedule cleanup if there are still frames to monitor
+    if (activeBarcodeFrames.isNotEmpty()) {
+      scheduleCleanup()
+    } else {
+      Log.d(TAG, "No more frames to monitor, stopping cleanup")
+    }
+  }
+
+  /**
+   * Clear all frames immediately
+   */
+  fun clearAllFrames() {
+    val frameCount = activeBarcodeFrames.size
+    activeBarcodeFrames.clear()
+    currentCleanupTask?.cancel(false)
+
+    if (frameCount > 0) {
+      Log.d(TAG, "Cleared all $frameCount barcode frames")
+      onFramesChanged?.invoke()
+    }
+  }
+
+  /**
+   * Shutdown the manager and cleanup resources
+   */
+  fun shutdown() {
+    currentCleanupTask?.cancel(false)
+    cleanupExecutor.shutdown()
+    try {
+      if (!cleanupExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
+        cleanupExecutor.shutdownNow()
+      }
+    } catch (e: InterruptedException) {
+      cleanupExecutor.shutdownNow()
+      Thread.currentThread().interrupt()
+    }
+    Log.d(TAG, "BarcodeFrameManager shutdown complete")
+  }
+
+}

package/android/src/main/java/com/scanner/views/BarcodeFrameOverlayView.kt

@@ -0,0 +1,43 @@
+package com.scanner.views
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import android.util.AttributeSet
+import android.view.View
+
+class BarcodeFrameOverlayView : View {
+
+  private var barcodeBoxes: List<RectF> = emptyList()
+  private val paint = Paint().apply {
+    color = Color.YELLOW
+    style = Paint.Style.STROKE
+    strokeWidth = 5f
+  }
+
+  constructor(context: Context) : super(context) {
+    setWillNotDraw(false)
+  }
+
+  constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {
+    setWillNotDraw(false)
+  }
+
+  constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr) {
+    setWillNotDraw(false)
+  }
+
+  fun setBarcodeBoxes(boxes: List<RectF>) {
+    this.barcodeBoxes = boxes
+    postInvalidate()
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+    for (box in barcodeBoxes) {
+      canvas.drawRect(box, paint)
+    }
+  }
+}

package/android/src/main/java/com/scanner/views/FocusAreaView.kt

@@ -0,0 +1,124 @@
+package com.scanner.views
+
+import android.content.Context
+import android.graphics.*
+import android.util.AttributeSet
+import android.view.View
+import com.scanner.FrameSize
+
+// Separate overlay view for frame drawing
+class FocusAreaView : View {
+  private var enableFrame: Boolean = false
+  private var borderColor: Int = Color.TRANSPARENT
+  private var tintColor: Int = Color.BLACK
+  private var frameSize: FrameSize = FrameSize.Square(300)
+  private var positionX: Float = 50f // Default center (50%)
+  private var positionY: Float = 50f // Default center (50%)
+  var frameRect: RectF? = null
+    private set
+
+  constructor(context: Context) : super(context) {
+    setWillNotDraw(false)
+  }
+
+  constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {
+    setWillNotDraw(false)
+  }
+
+  constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr) {
+    setWillNotDraw(false)
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+
+    if (enableFrame) {
+      drawFrame(canvas)
+    }
+  }
+
+  private fun drawFrame(canvas: Canvas) {
+    // Calculate position based on percentage (0-100)
+    val centerX = (width * positionX / 100f)
+    val centerY = (height * positionY / 100f)
+
+    // Calculate frame dimensions based on frameSize type
+    val currentFrameSize = frameSize // Local copy to avoid smart cast issues
+    val (frameWidth, frameHeight) = when (currentFrameSize) {
+      is FrameSize.Square -> {
+        val density = context.resources.displayMetrics.density
+        val size = currentFrameSize.size * density
+        size to size
+      }
+      is FrameSize.Rectangle -> {
+        val density = context.resources.displayMetrics.density
+        val width = currentFrameSize.width * density
+        val height = currentFrameSize.height * density
+        width to height
+      }
+    }
+
+    val frameHalfWidth = frameWidth / 2f
+    val frameHalfHeight = frameHeight / 2f
+
+    // Calculate frame rectangle with custom position
+    frameRect = RectF(
+      centerX - frameHalfWidth,
+      centerY - frameHalfHeight,
+      centerX + frameHalfWidth,
+      centerY + frameHalfHeight
+    )
+
+    // Draw semi-transparent overlay
+    val overlayPaint = Paint().apply {
+      color = tintColor
+      alpha = 128
+    }
+
+    // Draw overlay with transparent rectangle
+    canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), overlayPaint)
+
+    // Clear the frame area
+    val clearPaint = Paint().apply {
+      color = Color.TRANSPARENT
+      xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR)
+    }
+    canvas.drawRect(frameRect!!, clearPaint)
+
+    // Draw frame border only if color is not transparent
+    if (borderColor != Color.TRANSPARENT) {
+      val borderPaint = Paint().apply {
+        color = borderColor
+        style = Paint.Style.STROKE
+        strokeWidth = 4f
+      }
+      canvas.drawRect(frameRect!!, borderPaint)
+    }
+  }
+
+  fun setEnableFrame(enable: Boolean) {
+    enableFrame = enable
+    invalidate()
+  }
+
+  fun setBorderColor(color: Int) {
+    borderColor = color
+    invalidate()
+  }
+
+  fun setTintColor(color: Int) {
+    tintColor = color
+    invalidate()
+  }
+
+  fun setFrameSize(size: FrameSize) {
+    frameSize = size
+    invalidate()
+  }
+
+  fun setPosition(x: Float, y: Float) {
+    positionX = x.coerceIn(0f, 100f) // Clamp to 0-100 range
+    positionY = y.coerceIn(0f, 100f) // Clamp to 0-100 range
+    invalidate()
+  }
+}