fix(scanner): meter exposure on the centre of the frame

Scanning failed outright when a bright screen washed the code out, and the
reason is that auto-exposure is effectively part of the detector.

Candidate finding in scanner.cpp runs entirely on one binary image:

    threshold(greyscale, whitish, 170, 255, THRESH_BINARY);

Every contour, ellipse and code the scanner ever finds comes out of that. The
cutoff is an absolute luminance, not a local or adaptive one, so the detector
never asks whether the code has contrast -- it asks whether the light ink lands
above 170 and the dark ink below it. Measured on a Solana Seeker, decoding
survives up to a black level of exactly 170 and dies at 180; from the other
side it survives down to a white level of 175 and dies at 165. Squeezed around
a mid-grey it decodes an 85-to-171 span and fails at 90-to-166 -- a code that
is still plainly legible, and completely invisible to the scanner, purely for
sitting on the wrong side of a constant.

So a clipped code is not a degraded input, it is a uniform white slab with no
contours to find. Nothing downstream can recover it.

Android left metering to the camera's whole-frame default and never requested
AE at all, not at bind and not on tap, where the existing action carried
FLAG_AF alone. Pointed at a code on a phone screen in a dim room, whole-frame
metering exposes for the room and drives the screen into clipping. iOS has
pinned exposurePointOfInterest to the centre since the session was written;
this closes that gap rather than inventing a new behaviour.

Request AE on the centre of the frame and keep it there, and add FLAG_AE to
tap-to-focus so a tap fixes exposure too -- on a washed-out code the exposure
is the half that is actually broken. Because auto-cancel drops all 3A regions
rather than only the ones the tap set, the tap re-arms the baseline afterwards
instead of silently costing it.

Two details that are load-bearing and do not read as such:

- AE only, no AF. Adding FLAG_AF to a request with auto-cancel disabled would
  fire a one-shot autofocus and leave focus locked wherever it landed, which is
  the opposite of what a scanner wants.
- Applied when the preview stream is actually running, not when bind returns.
  startFocusAndMetering is refused with "Camera is not active" until the camera
  has opened, and it refuses silently -- the first cut of this fix asked at
  bind time and was cancelled every time while looking, from the source, like
  it worked.

The 170 constant itself is the deeper problem, but scanner.cpp is maintained in
parallel on iOS and changing the threshold trades against false positives in a
way synthetic frames cannot measure. That is a cross-platform decision, not a
drive-by.

Author: bmc08gt

ui/scanner/src/main/kotlin/com/getcode/ui/scanner/CodeScanner.kt

@@ -225,9 +225,19 @@ fun CodeScanner(
         mutableStateOf(PreviewView.StreamState.IDLE)
     }
 
-    LaunchedEffect(streamState) {
+    LaunchedEffect(streamState, gestureController) {
         if (streamState == PreviewView.StreamState.STREAMING) {
             trace("camera ready")
+
+            // Exposure is metered on the centre of the frame rather than the whole of it, so a
+            // bright code in a dark room is exposed for the code and not for the room. See
+            // `applyBaselineMetering` -- overexposure does not degrade detection, it ends it.
+            //
+            // Deliberately keyed on the stream actually running, not on the bind returning:
+            // `startFocusAndMetering` is refused with "Camera is not active" until the camera has
+            // opened, and it refuses *silently*. Asking any earlier would leave whole-frame
+            // metering in place while looking, from the source, exactly like a fix.
+            gestureController?.applyBaselineMetering()
         }
     }
 

ui/scanner/src/main/kotlin/com/getcode/ui/scanner/internal/CameraGestureController.kt

@@ -10,6 +10,7 @@ import androidx.camera.core.CameraControl
 import androidx.camera.core.CameraInfo
 import androidx.camera.core.FocusMeteringAction
 import androidx.camera.core.MeteringPoint
+import androidx.camera.core.SurfaceOrientedMeteringPointFactory
 import androidx.compose.ui.geometry.Offset
 import java.util.concurrent.TimeUnit
 import kotlin.math.pow
@@ -88,11 +89,24 @@ internal class CameraGestureController(
 
             override fun onSingleTapUp(event: MotionEvent): Boolean {
                 val point = onTap(Offset(event.x, event.y))
-                val action = FocusMeteringAction.Builder(point, FocusMeteringAction.FLAG_AF)
-                    .setAutoCancelDuration(5, TimeUnit.SECONDS)
+                // AE as well as AF: a tap means "read this", and on a washed-out code the exposure
+                // is the half that is actually broken.
+                val action = FocusMeteringAction.Builder(
+                    point,
+                    FocusMeteringAction.FLAG_AF or FocusMeteringAction.FLAG_AE,
+                )
+                    .setAutoCancelDuration(TAP_METERING_SECONDS, TimeUnit.SECONDS)
                     .build()
 
                 cameraControl.startFocusAndMetering(action)
+
+                // Auto-cancel drops *all* 3A regions, not just the ones this tap set, so without
+                // re-arming, the first tap would cost the centre exposure region permanently.
+                handler.removeCallbacks(restoreBaselineMetering)
+                handler.postDelayed(
+                    restoreBaselineMetering,
+                    TimeUnit.SECONDS.toMillis(TAP_METERING_SECONDS),
+                )
                 return true
             }
 
@@ -114,6 +128,35 @@ internal class CameraGestureController(
         }
     )
 
+    private val restoreBaselineMetering = Runnable { applyBaselineMetering() }
+
+    /**
+     * Meter exposure on the centre of the frame, where the code is, and keep it there.
+     *
+     * With no region set the camera meters the whole frame, which for a scanner is the wrong
+     * subject: a code on a phone screen is a small bright rectangle in a mostly dark scene, so
+     * whole-frame metering exposes for the room and drives the screen into clipping.
+     *
+     * That is fatal rather than merely degrading, because the native detector splits light from
+     * dark at a fixed luminance of 170 with no adaptive fallback -- measured in
+     * `WashoutToleranceTest`, the code's dark ink must land below 170 and its light ink above it,
+     * and contrast beyond that barely matters. A clipped code is not a poor input, it is a uniform
+     * white slab with no contours to find, and detection stops dead. iOS pins
+     * `exposurePointOfInterest` to the centre for the same reason.
+     *
+     * AE only, deliberately. Adding FLAG_AF would fire a one-shot autofocus and, with auto-cancel
+     * disabled, leave focus locked at whatever distance it happened to land on -- the opposite of
+     * what a scanner wants. Focus stays in the camera's own continuous mode.
+     */
+    fun applyBaselineMetering() {
+        val centre = SurfaceOrientedMeteringPointFactory(1f, 1f).createPoint(0.5f, 0.5f)
+        val action = FocusMeteringAction.Builder(centre, FocusMeteringAction.FLAG_AE)
+            .disableAutoCancel()
+            .build()
+
+        cameraControl.startFocusAndMetering(action)
+    }
+
     fun onTouchEvent(event: MotionEvent) {
         if (gesturesEnabled) {
             if (initialZoomLevel == -1f) {
@@ -156,4 +199,8 @@ internal class CameraGestureController(
             }
         })
     }
-}
+
+    private companion object {
+        const val TAP_METERING_SECONDS = 5L
+    }
+}