react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/BarcodeScannerActivity.kt

@@ -0,0 +1,361 @@
+package com.customcamera
+
+import android.Manifest
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageManager
+import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
+import android.os.Bundle
+import android.util.Log
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.TextView
+import androidx.activity.ComponentActivity
+import androidx.annotation.OptIn
+import androidx.camera.core.Camera
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ExperimentalGetImage
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageProxy
+import androidx.camera.core.Preview
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.view.PreviewView
+import androidx.core.content.ContextCompat
+import androidx.core.view.WindowCompat
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+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
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+/**
+ * Full-screen barcode / QR scanner.
+ *
+ * Self-contained CameraX ([Preview] + [ImageAnalysis]) + ML Kit pipeline, intentionally kept
+ * separate from the 3274-line [CustomCameraActivity] so the capture screen is untouched. Returns
+ * the first decoded value via [EXTRA_RESULT_VALUE] (and its human-readable format via
+ * [EXTRA_RESULT_FORMAT]) using the standard Activity result contract; the owning
+ * [CustomCameraModule.scanQRCode] resolves its promise from onActivityResult.
+ */
+class BarcodeScannerActivity : ComponentActivity() {
+
+  private lateinit var previewView: PreviewView
+  // Rendered as a MONOCHROME bolt glyph (⚡ + U+FE0E text-presentation selector) in a TextView —
+  // not a color emoji — so setTextColor(WHITE) tints it white like the rest of the UI. The on/off
+  // state is shown via alpha in toggleTorch().
+  private lateinit var torchButton: TextView
+  private lateinit var cameraExecutor: ExecutorService
+
+  private var camera: Camera? = null
+
+  /**
+   * Latches once the first barcode is delivered so a burst of successful frames can never call
+   * setResult()/finish() twice (which would leak a second result and, upstream, double-resolve
+   * the JS promise). Written and read only on the main thread (ML Kit success callbacks post
+   * there), but kept @Volatile as defensive documentation of the invariant.
+   */
+  @Volatile
+  private var resultDelivered = false
+  private var torchOn = false
+
+  private val scanner by lazy {
+    BarcodeScanning.getClient(
+      BarcodeScannerOptions.Builder()
+        .setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
+        .build()
+    )
+  }
+
+  private val localizers = mutableListOf<() -> Unit>()
+
+  private fun TextView.bindText(key: String, default: String, vararg args: Any) {
+    val updater = { this.text = Localization.getString(key, default, *args) }
+    updater()
+    localizers.add(updater)
+  }
+
+  private fun View.bindContentDescription(key: String, default: String, vararg args: Any) {
+    val updater = { this.contentDescription = Localization.getString(key, default, *args) }
+    updater()
+    localizers.add(updater)
+  }
+
+  private val localizationReceiver = object : BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+      window.decorView.rootView.layoutDirection = if (Localization.isRtl) View.LAYOUT_DIRECTION_RTL else View.LAYOUT_DIRECTION_LTR
+      localizers.forEach { it.invoke() }
+    }
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    window.decorView.rootView.layoutDirection = if (Localization.isRtl) View.LAYOUT_DIRECTION_RTL else View.LAYOUT_DIRECTION_LTR
+    cameraExecutor = Executors.newSingleThreadExecutor()
+    setContentView(buildUi())
+
+    // Match the system bars to the scanner's own backdrop (dark by default, but host-overridable
+    // via components.barcodeScanner.background): transparent bars with a light/dark icon appearance
+    // picked from the resolved backdrop so the status/nav icons stay legible over it.
+    val scannerBackground = CameraTheme.get(this).componentColor("barcodeScanner", "background", Color.BLACK)
+    window.statusBarColor = Color.TRANSPARENT
+    window.navigationBarColor = Color.TRANSPARENT
+    val lightBars = !isColorDark(scannerBackground)
+    WindowCompat.getInsetsController(window, window.decorView).apply {
+      isAppearanceLightStatusBars = lightBars
+      isAppearanceLightNavigationBars = lightBars
+    }
+
+    LocalBroadcastManager.getInstance(this).registerReceiver(
+      localizationReceiver, IntentFilter(Localization.ACTION_LOCALIZATION_CHANGED)
+    )
+
+    if (hasCameraPermission()) {
+      startCamera()
+    } else {
+      requestPermissions(arrayOf(Manifest.permission.CAMERA), PERMISSION_REQUEST)
+    }
+  }
+
+  // ── UI ────────────────────────────────────────────────────────────────────
+
+  private fun buildUi(): View {
+    val theme = CameraTheme.get(this)
+    val root = FrameLayout(this).apply {
+      layoutParams = ViewGroup.LayoutParams(MATCH, MATCH)
+      setBackgroundColor(theme.componentColor("barcodeScanner", "background", Color.BLACK))
+    }
+
+    previewView = PreviewView(this).apply {
+      layoutParams = FrameLayout.LayoutParams(MATCH, MATCH)
+    }
+    root.addView(previewView)
+
+    // Minimal centered scan frame (transparent fill, rounded border).
+    val frameSize = dp(250)
+    val scanFrame = View(this).apply {
+      layoutParams = FrameLayout.LayoutParams(frameSize, frameSize, Gravity.CENTER)
+      background = GradientDrawable().apply {
+        setColor(Color.TRANSPARENT)
+        setStroke(dp(3), theme.componentColor("barcodeScanner", "frameBorder", Color.WHITE))
+        cornerRadius = dp(16).toFloat()
+      }
+    }
+    root.addView(scanFrame)
+
+    val hint = TextView(this).apply {
+      layoutParams = FrameLayout.LayoutParams(WRAP, WRAP, Gravity.CENTER_HORIZONTAL).apply {
+        topMargin = dp(140)
+      }
+      bindText("pointCameraAtBarcode", "Point the camera at a QR code or barcode")
+      setTextColor(theme.componentColor("barcodeScanner", "hintText", Color.WHITE))
+      textSize = 14f
+    }
+    root.addView(hint)
+
+    val closeButton = ImageButton(this).apply {
+      layoutParams = FrameLayout.LayoutParams(dp(48), dp(48), Gravity.TOP or Gravity.START).apply {
+        topMargin = dp(40)
+        marginStart = dp(16)
+      }
+      setImageDrawable(theme.config.iconDrawable(this@BarcodeScannerActivity, "close", R.drawable.ic_close))
+      theme.config.iconTint("close")?.let { setColorFilter(it) }
+      background = circleBackground()
+      setPadding(dp(10), dp(10), dp(10), dp(10))
+      bindContentDescription("closeScanner", "Close scanner")
+      setOnClickListener { cancel() }
+    }
+    root.addView(closeButton)
+
+    torchButton = TextView(this).apply {
+      layoutParams = FrameLayout.LayoutParams(dp(48), dp(48), Gravity.TOP or Gravity.END).apply {
+        topMargin = dp(40)
+        marginEnd = dp(16)
+      }
+      text = "⚡︎"
+      gravity = Gravity.CENTER
+      includeFontPadding = false
+      setTextColor(theme.componentColor("barcodeScanner", "torchGlyph", Color.WHITE))
+      setTextSize(TypedValue.COMPLEX_UNIT_PX, dp(22).toFloat())
+      // Dimmed until the torch is switched on (see toggleTorch).
+      alpha = 0.4f
+      background = circleBackground()
+      bindContentDescription("toggleFlashlight", "Toggle flashlight")
+      setOnClickListener { toggleTorch() }
+    }
+    root.addView(torchButton)
+
+    return root
+  }
+
+  private fun circleBackground(): GradientDrawable = GradientDrawable().apply {
+    shape = GradientDrawable.OVAL
+    setColor(
+      CameraTheme.get(this@BarcodeScannerActivity)
+        .componentColor("barcodeScanner", "buttonBackground", 0x66000000)
+    )
+  }
+
+  private fun toggleTorch() {
+    val control = camera?.cameraControl ?: return
+    if (camera?.cameraInfo?.hasFlashUnit() != true) return
+    torchOn = !torchOn
+    control.enableTorch(torchOn)
+    // Bright when on, dimmed when off — the 🔦 glyph itself is unchanged.
+    torchButton.alpha = if (torchOn) 1f else 0.4f
+  }
+
+  // ── Camera + analysis ───────────────────────────────────────────────────────
+
+  private fun startCamera() {
+    val providerFuture = ProcessCameraProvider.getInstance(this)
+    providerFuture.addListener(
+      {
+        // Not lifecycle-scoped: can fire after the user backed out. Binding a destroyed owner
+        // throws, so bail if we're already tearing down.
+        if (isFinishing || isDestroyed) return@addListener
+        try {
+          bindCamera(providerFuture.get())
+        } catch (e: Exception) {
+          Log.e(TAG, "Failed to start barcode scanner camera", e)
+          cancel()
+        }
+      },
+      ContextCompat.getMainExecutor(this)
+    )
+  }
+
+  private fun bindCamera(provider: ProcessCameraProvider) {
+    val preview = Preview.Builder().build().also {
+      it.setSurfaceProvider(previewView.surfaceProvider)
+    }
+
+    val analysis = ImageAnalysis.Builder()
+      .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+      .build()
+      .also { it.setAnalyzer(cameraExecutor) { proxy -> analyze(proxy) } }
+
+    // hasCamera() can throw CameraInfoUnavailableException, so probe it safely (mirrors
+    // CustomCameraActivity.hasCameraSafe) and prefer the back camera for scanning.
+    val hasBack = runCatching { provider.hasCamera(CameraSelector.DEFAULT_BACK_CAMERA) }.getOrDefault(false)
+    val selector =
+      if (hasBack) CameraSelector.DEFAULT_BACK_CAMERA else CameraSelector.DEFAULT_FRONT_CAMERA
+
+    provider.unbindAll()
+    camera = provider.bindToLifecycle(this, selector, preview, analysis)
+  }
+
+  @OptIn(ExperimentalGetImage::class)
+  private fun analyze(imageProxy: ImageProxy) {
+    if (resultDelivered) {
+      imageProxy.close()
+      return
+    }
+    val mediaImage = imageProxy.image
+    if (mediaImage == null) {
+      imageProxy.close()
+      return
+    }
+
+    val input = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
+    scanner.process(input)
+      .addOnSuccessListener { barcodes ->
+        val hit = barcodes.firstOrNull { !it.rawValue.isNullOrEmpty() }
+        if (hit != null && !resultDelivered) {
+          resultDelivered = true
+          deliverResult(hit.rawValue!!, formatName(hit.format))
+        }
+      }
+      .addOnFailureListener { e -> Log.w(TAG, "Barcode analysis failed", e) }
+      // MUST always close the proxy, or STRATEGY_KEEP_ONLY_LATEST stops delivering frames
+      // and scanning silently freezes.
+      .addOnCompleteListener { imageProxy.close() }
+  }
+
+  private fun deliverResult(value: String, format: String) {
+    runOnUiThread {
+      setResult(
+        RESULT_OK,
+        Intent()
+          .putExtra(EXTRA_RESULT_VALUE, value)
+          .putExtra(EXTRA_RESULT_FORMAT, format)
+      )
+      finish()
+    }
+  }
+
+  private fun cancel() {
+    setResult(RESULT_CANCELED)
+    finish()
+  }
+
+  // ── Permissions ─────────────────────────────────────────────────────────────
+
+  private fun hasCameraPermission(): Boolean =
+    ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) ==
+      PackageManager.PERMISSION_GRANTED
+
+  override fun onRequestPermissionsResult(
+    requestCode: Int,
+    permissions: Array<String>,
+    grantResults: IntArray
+  ) {
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    if (requestCode != PERMISSION_REQUEST) return
+    if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+      startCamera()
+    } else {
+      cancel()
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    LocalBroadcastManager.getInstance(this).unregisterReceiver(localizationReceiver)
+    if (::cameraExecutor.isInitialized) cameraExecutor.shutdown()
+    scanner.close()
+  }
+
+  // ── Helpers ───────────────────────────────────────────────────────────────
+
+  private fun dp(value: Int): Int = (value * resources.displayMetrics.density).toInt()
+
+  private fun formatName(format: Int): String = when (format) {
+    Barcode.FORMAT_QR_CODE -> "QR_CODE"
+    Barcode.FORMAT_AZTEC -> "AZTEC"
+    Barcode.FORMAT_DATA_MATRIX -> "DATA_MATRIX"
+    Barcode.FORMAT_PDF417 -> "PDF417"
+    Barcode.FORMAT_EAN_13 -> "EAN_13"
+    Barcode.FORMAT_EAN_8 -> "EAN_8"
+    Barcode.FORMAT_UPC_A -> "UPC_A"
+    Barcode.FORMAT_UPC_E -> "UPC_E"
+    Barcode.FORMAT_CODE_128 -> "CODE_128"
+    Barcode.FORMAT_CODE_39 -> "CODE_39"
+    Barcode.FORMAT_CODE_93 -> "CODE_93"
+    Barcode.FORMAT_CODABAR -> "CODABAR"
+    Barcode.FORMAT_ITF -> "ITF"
+    else -> "UNKNOWN"
+  }
+
+  companion object {
+    private const val TAG = "BarcodeScanner"
+    private const val PERMISSION_REQUEST = 9301
+    private val MATCH = ViewGroup.LayoutParams.MATCH_PARENT
+    private val WRAP = ViewGroup.LayoutParams.WRAP_CONTENT
+
+    const val EXTRA_RESULT_VALUE = "com.customcamera.extra.SCAN_VALUE"
+    const val EXTRA_RESULT_FORMAT = "com.customcamera.extra.SCAN_FORMAT"
+
+    fun createIntent(context: Context): Intent =
+      Intent(context, BarcodeScannerActivity::class.java)
+  }
+}

package/android/src/main/java/com/customcamera/BlurBackgroundView.kt

@@ -0,0 +1,199 @@
+package com.customcamera
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.view.View
+import android.widget.FrameLayout
+import android.widget.ImageView
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import kotlin.math.max
+
+/**
+ * ViewManager for a native, dependency-free "frosted glass" backdrop used behind the
+ * expandable FAB menu.
+ *
+ * How it works (the "snapshot + downscale blur" strategy):
+ *  1. When [BlurBackgroundView.setActive] flips true, it takes a ONE-OFF snapshot of the
+ *     Activity's content view (the media library sitting behind the menu) by drawing it into
+ *     a heavily down-scaled [Bitmap]. Down-scaling is itself most of the blur and makes the
+ *     subsequent work tiny.
+ *  2. A fast, pure-Kotlin separable box blur (no RenderScript, no RenderEffect, no library)
+ *     softens the small bitmap. Because the bitmap is a fraction of screen size, this is cheap
+ *     enough to stay smooth on low-end devices, and it works on every supported API level
+ *     (min SDK 24) — unlike RenderEffect, which is API 31+.
+ *  3. The blurred bitmap is shown in a full-bleed [ImageView] and stretched back up. The
+ *     surrounding React view fades it in/out, so the existing menu animation is preserved.
+ *
+ * Only the BACKGROUND is captured/blurred: the view hides ITSELF for the draw, and the menu
+ * items are still transparent at the instant the menu begins to open, so neither the blur
+ * layer nor the menu rows ever appear inside the blurred snapshot. The snapshot is static
+ * while the menu is open (the library underneath is not interactive then), so a single capture
+ * is both correct and efficient — no per-frame re-blurring.
+ */
+class BlurBackgroundViewManager : SimpleViewManager<BlurBackgroundView>() {
+  override fun getName() = "CustomBlurBackground"
+
+  override fun createViewInstance(reactContext: ThemedReactContext): BlurBackgroundView =
+    BlurBackgroundView(reactContext)
+
+  @ReactProp(name = "active", defaultBoolean = false)
+  fun setActive(view: BlurBackgroundView, active: Boolean) {
+    view.setActive(active)
+  }
+
+  @ReactProp(name = "blurRadius", defaultInt = 4)
+  fun setBlurRadius(view: BlurBackgroundView, radius: Int) {
+    view.blurRadius = radius.coerceIn(1, 25)
+  }
+
+  @ReactProp(name = "downsampleFactor", defaultInt = 6)
+  fun setDownsampleFactor(view: BlurBackgroundView, factor: Int) {
+    view.downsampleFactor = factor.coerceIn(1, 16)
+  }
+}
+
+class BlurBackgroundView(private val reactContext: ThemedReactContext) : FrameLayout(reactContext) {
+  private val imageView = ImageView(reactContext).apply {
+    scaleType = ImageView.ScaleType.FIT_XY
+  }
+
+  /** Down-sample divisor for the snapshot — higher = softer + cheaper. */
+  var downsampleFactor = 6
+  /** Box-blur radius applied to the down-sampled snapshot. */
+  var blurRadius = 4
+
+  private var active = false
+
+  init {
+    addView(
+      imageView,
+      LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+    )
+  }
+
+  fun setActive(next: Boolean) {
+    if (next == active) return
+    active = next
+    if (active) {
+      // Defer to the next frame so the view is measured/laid out and the background
+      // content behind it is fully drawn before we snapshot it.
+      post { if (active) captureAndBlur() }
+    } else {
+      imageView.setImageBitmap(null)
+    }
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    // Keep the frosted backdrop correct after a rotation / resize while it is showing.
+    if (active && w > 0 && h > 0) post { if (active) captureAndBlur() }
+  }
+
+  private fun captureAndBlur() {
+    val source: View =
+      reactContext.currentActivity?.findViewById(android.R.id.content) ?: rootView ?: return
+    val srcW = source.width
+    val srcH = source.height
+    if (srcW <= 0 || srcH <= 0) return
+
+    val factor = max(1, downsampleFactor)
+    val bmpW = max(1, srcW / factor)
+    val bmpH = max(1, srcH / factor)
+
+    val bitmap =
+      try {
+        Bitmap.createBitmap(bmpW, bmpH, Bitmap.Config.ARGB_8888)
+      } catch (e: OutOfMemoryError) {
+        return
+      }
+    val canvas = Canvas(bitmap)
+    val scale = 1f / factor
+    canvas.scale(scale, scale)
+
+    // Exclude our own (currently transparent) blur layer from the snapshot so we never
+    // capture a previous frame of the blur, then restore visibility immediately after.
+    val prevVisibility = visibility
+    visibility = View.INVISIBLE
+    try {
+      source.draw(canvas)
+    } catch (e: Exception) {
+      visibility = prevVisibility
+      return
+    }
+    visibility = prevVisibility
+
+    boxBlur(bitmap, blurRadius)
+    imageView.setImageBitmap(bitmap)
+  }
+
+  /**
+   * In-place separable box blur (two axes, run twice for a smoother, Gaussian-like falloff).
+   * Operates on the raw ARGB pixel array of a small, down-sampled bitmap, so it is O(pixels)
+   * and stays fast on low-end hardware. Alpha is preserved; only RGB channels are averaged.
+   */
+  private fun boxBlur(bitmap: Bitmap, radius: Int) {
+    if (radius < 1) return
+    val w = bitmap.width
+    val h = bitmap.height
+    if (w <= 0 || h <= 0) return
+
+    val pixels = IntArray(w * h)
+    bitmap.getPixels(pixels, 0, w, 0, 0, w, h)
+
+    // Two iterations approximate a Gaussian blur well enough for a frosted backdrop.
+    repeat(2) {
+      blurAxis(pixels, w, h, radius, horizontal = true)
+      blurAxis(pixels, w, h, radius, horizontal = false)
+    }
+
+    bitmap.setPixels(pixels, 0, w, 0, 0, w, h)
+  }
+
+  private fun blurAxis(pixels: IntArray, w: Int, h: Int, radius: Int, horizontal: Boolean) {
+    val lineCount = if (horizontal) h else w
+    val lineLength = if (horizontal) w else h
+    if (lineLength <= 1) return
+    val window = radius * 2 + 1
+    val scratch = IntArray(lineLength)
+
+    for (line in 0 until lineCount) {
+      // Prime the sliding window over the first `radius+1` samples (clamped at the edge).
+      var sumR = 0
+      var sumG = 0
+      var sumB = 0
+      for (i in -radius..radius) {
+        val idx = indexOf(line, i.coerceIn(0, lineLength - 1), w, horizontal)
+        val c = pixels[idx]
+        sumR += (c ushr 16) and 0xFF
+        sumG += (c ushr 8) and 0xFF
+        sumB += c and 0xFF
+      }
+
+      for (pos in 0 until lineLength) {
+        scratch[pos] = (0xFF shl 24) or
+          ((sumR / window) shl 16) or
+          ((sumG / window) shl 8) or
+          (sumB / window)
+
+        // Slide the window forward: drop the trailing sample, add the leading one.
+        val trailing = (pos - radius).coerceIn(0, lineLength - 1)
+        val leading = (pos + radius + 1).coerceIn(0, lineLength - 1)
+        val cOut = pixels[indexOf(line, trailing, w, horizontal)]
+        val cIn = pixels[indexOf(line, leading, w, horizontal)]
+        sumR += ((cIn ushr 16) and 0xFF) - ((cOut ushr 16) and 0xFF)
+        sumG += ((cIn ushr 8) and 0xFF) - ((cOut ushr 8) and 0xFF)
+        sumB += (cIn and 0xFF) - (cOut and 0xFF)
+      }
+
+      // Write the blurred line back into the shared buffer.
+      for (pos in 0 until lineLength) {
+        pixels[indexOf(line, pos, w, horizontal)] = scratch[pos]
+      }
+    }
+  }
+
+  private fun indexOf(line: Int, pos: Int, w: Int, horizontal: Boolean): Int =
+    if (horizontal) line * w + pos else pos * w + line
+}