fix(scanner): fall back to any camera when there is no back camera

The scanner required LENS_FACING_BACK. An Infinix X688B exposes one camera
to CameraX and reports it as front facing, so every bind threw
IllegalArgumentException("No available camera can be found"), was retried
three times a second apart, and left a blank preview (Bugsnag
6aca4823396a2e952015e21d, 9 events on 2026.10.2).

Prefer the back camera and otherwise bind the first camera the device
exposes. Stop retrying IllegalArgumentException, which doesn't change
between attempts. A device with no camera now fails with
NoCamerasAvailableException, which shows the unavailable state and is no
longer reported as an error.

Author: bmc08gt

apps/flipcash/features/scanner/src/main/kotlin/com/flipcash/app/scanner/internal/Scanner.kt

@@ -287,10 +287,13 @@ internal fun Scanner() {
                         }
                     },
                     onError = {
+                        // A device without a usable camera is an expected state, not an error
+                        // to report.
                         if (it is NoCamerasAvailableException) {
                             cameraAvailable = false
+                        } else {
+                            ErrorUtils.handleError(it)
                         }
-                        ErrorUtils.handleError(it)
                     }
                 )
             },

ui/scanner/build.gradle.kts

@@ -30,4 +30,7 @@ dependencies {
     implementation(libs.compose.animation)
     implementation(libs.compose.material)
 
+    testImplementation(kotlin("test"))
+    testImplementation(libs.kotlinx.coroutines.test)
+
 }

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

@@ -89,13 +89,6 @@ fun CodeScanner(
         Preview.Builder().build().apply { surfaceProvider = previewView.surfaceProvider }
     }
 
-    val cameraSelector = remember {
-        val lensFacing = CameraSelector.LENS_FACING_BACK
-        CameraSelector.Builder()
-            .requireLensFacing(lensFacing)
-            .build()
-    }
-
     // Ask for the analysis stream through ResolutionSelector rather than the deprecated
     // setTargetResolution. The old API is only a hint, and on a 4:3 sensor it resolves a 1920x1080
     // request down to a 720x720 square -- which costs range twice over. A square crop keeps the
@@ -150,7 +143,6 @@ fun CodeScanner(
             cameraProvider.bindToLifecycleSafely(
                 context,
                 lifecycleOwner,
-                cameraSelector,
                 preview,
                 imageAnalysis
             ).onSuccess {
@@ -187,7 +179,6 @@ fun CodeScanner(
                         cameraProvider.bindToLifecycleSafely(
                             context,
                             lifecycleOwner,
-                            cameraSelector,
                             preview,
                             imageAnalysis
                         ).onSuccess {
@@ -289,16 +280,22 @@ private suspend fun Context.getCameraProvider(): ProcessCameraProvider {
 private suspend fun ProcessCameraProvider.bindToLifecycleSafely(
     context: Context,
     lifecycleOwner: LifecycleOwner,
-    cameraSelector: CameraSelector,
     preview: Preview,
     imageAnalysis: ImageAnalysis,
     retries: Int = 3,
 ): Result<Camera> {
     val hasCamera = context.packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA_ANY)
     if (!hasCamera) {
-        return Result.failure(IllegalStateException("No camera available on this device"))
+        return Result.failure(NoCamerasAvailableException())
     }
 
+    // Some devices expose no back camera to CameraX -- an Infinix X688B lists a single camera and
+    // reports it as front facing -- so requiring LENS_FACING_BACK fails every bind there. Prefer
+    // the back camera and fall back to whatever the device has; a code held up to a front camera
+    // still scans.
+    val cameraSelector = pickScannerCamera(availableCameraInfos) { it.lensFacing }?.cameraSelector
+        ?: return Result.failure(NoCamerasAvailableException())
+
     return runCatching {
         bindWithRetry(retries) {
             bindToLifecycle(
@@ -319,11 +316,23 @@ suspend fun bindWithRetry(
         try {
             return bind()
         } catch (e: Exception) {
-            if (attempt == retries - 1) throw e
+            // CameraX throws IllegalArgumentException when no camera matches the selector or the
+            // use cases can't be combined. Neither changes between attempts, so retrying only
+            // delays the failure.
+            if (e is IllegalArgumentException || attempt == retries - 1) throw e
             delay(1000)
         }
     }
     throw NoCamerasAvailableException()
 }
 
+/**
+ * The back camera when there is one, otherwise the first camera the device exposes, or null when
+ * it exposes none.
+ */
+internal fun <T> pickScannerCamera(cameras: List<T>, lensFacing: (T) -> Int): T? {
+    return cameras.firstOrNull { lensFacing(it) == CameraSelector.LENS_FACING_BACK }
+        ?: cameras.firstOrNull()
+}
+
 class NoCamerasAvailableException : Throwable()

ui/scanner/src/test/kotlin/com/getcode/ui/scanner/ScannerCameraSelectionTest.kt

@@ -0,0 +1,62 @@
+package com.getcode.ui.scanner
+
+import androidx.camera.core.CameraSelector
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNull
+
+class ScannerCameraSelectionTest {
+
+    private data class FakeCamera(val id: String, val lensFacing: Int)
+
+    private val front = FakeCamera("front", CameraSelector.LENS_FACING_FRONT)
+    private val back = FakeCamera("back", CameraSelector.LENS_FACING_BACK)
+    private val external = FakeCamera("external", CameraSelector.LENS_FACING_EXTERNAL)
+
+    @Test
+    fun picksTheBackCameraWhenThereIsOne() {
+        assertEquals(back, pickScannerCamera(listOf(front, back)) { it.lensFacing })
+    }
+
+    @Test
+    fun fallsBackToTheOnlyFrontCamera() {
+        // Infinix X688B: CameraX lists one camera, id 0, reporting LENS_FACING_FRONT.
+        assertEquals(front, pickScannerCamera(listOf(front)) { it.lensFacing })
+    }
+
+    @Test
+    fun fallsBackToTheFirstCameraWithoutABackOne() {
+        assertEquals(external, pickScannerCamera(listOf(external, front)) { it.lensFacing })
+    }
+
+    @Test
+    fun picksNothingWithoutCameras() {
+        assertNull(pickScannerCamera(emptyList<FakeCamera>()) { it.lensFacing })
+    }
+
+    @Test
+    fun bindWithRetryDoesNotRetryAnUnmatchedSelector() = runTest {
+        var attempts = 0
+        assertFailsWith<IllegalArgumentException> {
+            bindWithRetry(retries = 3) {
+                attempts++
+                throw IllegalArgumentException("No available camera can be found")
+            }
+        }
+        assertEquals(1, attempts)
+    }
+
+    @Test
+    fun bindWithRetryRetriesOtherFailures() = runTest {
+        var attempts = 0
+        assertFailsWith<IllegalStateException> {
+            bindWithRetry(retries = 3) {
+                attempts++
+                throw IllegalStateException("camera in use")
+            }
+        }
+        assertEquals(3, attempts)
+    }
+}