fix(ui): prevent aggressive brightness override on OLED panels

Replace fixed brightness threshold/target with a relative boost strategy that adds 0.3 to the current brightness (capped at 0.6) when the screen is genuinely near-off (<0.1).
Tie keep-screen-on and brightness to the bill's lifecycle rather than a fixed 10s timeout, and properly restore on backgrounding via lifecycle observer.
Guard against capturing boosted brightness as the original value on re-entry.

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

Author: bmc08gt

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

@@ -4,73 +4,117 @@ import android.app.Activity
 import android.provider.Settings
 import android.view.WindowManager
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.platform.LocalContext
-import kotlinx.coroutines.delay
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import kotlin.math.min
 
 /**
- * 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.
+ * A composable function that keeps the screen on while enabled and optionally adjusts brightness.
  *
  * 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.
+ * The keep-screen-on flag and brightness adjustment remain active for the entire duration that
+ * [isEnabled] is `true` and the app is in the foreground. When [isEnabled] flips to `false`,
+ * the composable leaves composition, or the app is backgrounded, the flag is cleared and
+ * brightness is restored. Returning to the foreground re-applies the overrides.
+ *
+ * When [useBrightness] is enabled and the screen is very dim (below [minBrightness]), brightness
+ * is boosted by [brightnessBoost] relative to the current level (capped at [maxBrightness]).
+ * This avoids jarring jumps on OLED panels with non-linear brightness curves.
  *
  * @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.
+ * @param minBrightness The minimum brightness threshold below which a boost is applied. 0.0 to 1.0.
+ * @param brightnessBoost The amount to add to current brightness when boosting. 0.0 to 1.0.
+ * @param maxBrightness The maximum brightness cap when boosting. 0.0 to 1.0.
  */
 @Composable
 fun KeepScreenOn(
     isEnabled: Boolean,
-    timeoutMs: Long = 10_000L,
     useBrightness: Boolean = false,
-    minBrightness: Float = 0.4f,
-    targetBrightness: Float = 0.6f
+    minBrightness: Float = 0.1f,
+    brightnessBoost: Float = 0.3f,
+    maxBrightness: Float = 0.8f
 ) {
     val context = LocalContext.current
+    val lifecycleOwner = LocalLifecycleOwner.current
+
+    val currentIsEnabled by rememberUpdatedState(isEnabled)
+    var originalBrightness by remember { mutableFloatStateOf(WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE) }
+    var brightnessAdjusted by remember { mutableStateOf(false) }
 
-    LaunchedEffect(isEnabled) {
-        if (!isEnabled) return@LaunchedEffect
+    DisposableEffect(isEnabled, lifecycleOwner) {
+        if (!isEnabled) return@DisposableEffect onDispose { }
 
         val window = (context as Activity).window
-        val layoutParams = window.attributes
-        val originalBrightness = layoutParams.screenBrightness
 
-        // When brightness is system-managed (adaptive brightness), the window
-        // reports BRIGHTNESS_OVERRIDE_NONE (-1.0). We must query the actual
-        // system brightness rather than treating -1.0 as "below threshold" —
-        // otherwise we unconditionally override to targetBrightness which on
-        // modern Pixel panels with non-linear curves appears as near-max.
-        val effectiveBrightness = if (originalBrightness == WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE) {
-            Settings.System.getInt(
-                context.contentResolver,
-                Settings.System.SCREEN_BRIGHTNESS,
-                128 // ~50% fallback if unreadable
-            ) / 255f
-        } else {
-            originalBrightness
+        fun clearOverrides() {
+            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            if (brightnessAdjusted) {
+                val layoutParams = window.attributes
+                layoutParams.screenBrightness = originalBrightness
+                window.attributes = layoutParams
+                brightnessAdjusted = false
+            }
         }
 
-        if (useBrightness && effectiveBrightness < minBrightness) {
-            layoutParams.screenBrightness = targetBrightness
-            window.attributes = layoutParams
-        }
+        fun applyOverrides() {
+            if (!currentIsEnabled) {
+                clearOverrides()
+                return
+            }
 
-        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
+            val layoutParams = window.attributes
+
+            // Only capture original brightness on the first apply — not on
+            // re-apply from ON_RESUME — to avoid saving the boosted value.
+            if (!brightnessAdjusted) {
+                originalBrightness = layoutParams.screenBrightness
+            }
+
+            val effectiveBrightness = if (originalBrightness == WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE) {
+                Settings.System.getInt(
+                    context.contentResolver,
+                    Settings.System.SCREEN_BRIGHTNESS,
+                    128
+                ) / 255f
+            } else {
+                originalBrightness
+            }
+
+            brightnessAdjusted = useBrightness && effectiveBrightness < minBrightness
+            if (brightnessAdjusted) {
+                layoutParams.screenBrightness = min(effectiveBrightness + brightnessBoost, maxBrightness)
                 window.attributes = layoutParams
             }
+
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        }
+
+        applyOverrides()
+
+        val observer = LifecycleEventObserver { _, event ->
+            when (event) {
+                Lifecycle.Event.ON_PAUSE -> clearOverrides()
+                Lifecycle.Event.ON_RESUME -> applyOverrides()
+                else -> Unit
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+
+        onDispose {
+            lifecycleOwner.lifecycle.removeObserver(observer)
+            clearOverrides()
         }
     }
-}
+}