feat(scanner): update KeepScreenOn to increase brightness for bills when pulled up

Signed-off-by: Brandon McAnsh <git@bmcreations.dev>

Author: bmc08gt

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

@@ -1,8 +1,6 @@
 package com.flipcash.app.scanner.internal
 
 import android.annotation.SuppressLint
-import android.app.Activity
-import android.view.WindowManager
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
@@ -27,14 +25,12 @@ import com.getcode.opencode.model.financial.orZero
 import com.getcode.ui.components.OnLifecycleEvent
 import com.getcode.ui.scanner.CodeScanner
 import com.getcode.ui.scanner.NoCamerasAvailableException
+import com.getcode.ui.utils.KeepScreenOn
 import com.getcode.util.vibration.LocalVibrator
 import com.getcode.utils.ErrorUtils
 import com.kik.kikx.kikcodes.implementation.KikCodeResult
 import dev.theolm.rinku.DeepLink
-import kotlinx.coroutines.delay
 import timber.log.Timber
-import java.util.Timer
-import kotlin.concurrent.schedule
 
 @Composable
 internal fun Scanner(deepLink: DeeplinkType?) {
@@ -182,15 +178,10 @@ internal fun Scanner(deepLink: DeeplinkType?) {
         if (billState.bill != null) {
             navigator.hide()
         }
-        resetScreenTimeout(context as Activity)
     }
-}
 
-private fun resetScreenTimeout(activity: Activity) {
-    activity.window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-    Timer().schedule(10000) {
-        activity.runOnUiThread {
-            activity.window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-        }
-    }
+    KeepScreenOn(
+        isEnabled = billState.bill != null,
+        useBrightness = true,
+    )
 }

ui/components/src/main/kotlin/com/getcode/ui/utils/KeepScreenOn.kt

@@ -1,37 +1,60 @@
 package com.getcode.ui.utils
 
+import android.app.Activity
 import android.view.WindowManager
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalLifecycleOwner
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleEventObserver
+import kotlinx.coroutines.delay
 
+/**
+ * A composable function that keeps the screen on for a specified duration when enabled.
+ * It can also optionally increase the screen brightness to a target level if it's below a minimum threshold.
+ *
+ * This is useful for scenarios like displaying a QR code where the user needs the screen to
+ * stay on and be bright enough to be scanned.
+ *
+ * The effect is launched whenever the `isEnabled` parameter changes to `true`. After the specified
+ * `timeoutMs`, the screen-on flag and any brightness changes are reverted.
+ *
+ * @param isEnabled A boolean flag to enable or disable the keep-screen-on functionality.
+ * @param timeoutMs The duration in milliseconds for which to keep the screen on. Defaults to 10 seconds.
+ * @param useBrightness A boolean flag to control whether the screen brightness should be adjusted.
+ * @param minBrightness The minimum brightness threshold. If the current brightness is below this value
+ *                      (or is set to automatic), the brightness will be adjusted. Brightness is a value from 0.0 to 1.0.
+ * @param targetBrightness The brightness level to set the screen to if adjustment is needed. Brightness is a value from 0.0 to 1.0.
+ */
 @Composable
-fun KeepScreenOn(isEnabled: Boolean) {
+fun KeepScreenOn(
+    isEnabled: Boolean,
+    timeoutMs: Long = 10_000L,
+    useBrightness: Boolean = false,
+    minBrightness: Float = 0.4f,
+    targetBrightness: Float = 0.6f
+) {
     val context = LocalContext.current
-    val lifecycleOwner = LocalLifecycleOwner.current
-    val window = (context as? androidx.activity.ComponentActivity)?.window
 
-    DisposableEffect(lifecycleOwner, isEnabled) {
-        val observer = LifecycleEventObserver { _, event ->
-            if (event == Lifecycle.Event.ON_RESUME) {
-                if (isEnabled) {
-                    // Keep screen on
-                    window?.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-                } else {
-                    // Allow screen to turn off
-                    window?.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-                }
-            }
-        }
+    LaunchedEffect(isEnabled) {
+        if (!isEnabled) return@LaunchedEffect
 
-        lifecycleOwner.lifecycle.addObserver(observer)
+        val window = (context as Activity).window
+        val layoutParams = window.attributes
+        val originalBrightness = layoutParams.screenBrightness
 
-        onDispose {
-            lifecycleOwner.lifecycle.removeObserver(observer)
-            window?.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        if (useBrightness && (originalBrightness < minBrightness || originalBrightness == WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE)) {
+            layoutParams.screenBrightness = targetBrightness
+            window.attributes = layoutParams
+        }
+
+        try {
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            delay(timeoutMs)
+        } finally {
+            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            if (useBrightness) {
+                layoutParams.screenBrightness = originalBrightness
+                window.attributes = layoutParams
+            }
         }
     }
 }