Release 0.6

.gitignore

@@ -8,6 +8,7 @@
 /.gradle-tmp/
 /build/
 /app/build/
+/*/build/
 /.externalNativeBuild/
 /.cxx/
 /captures/

README.md

@@ -1,15 +1,23 @@
 # StatusBarTweak
 
-StatusBarTweak is an Xposed/LSPosed module for Samsung SystemUI. It focuses on
-making the status bar, lockscreen, and Always On Display more configurable while
-still keeping Samsung's own icons and visual style where possible.
+StatusBarTweak is an Xposed/LSPosed module originally built for Samsung
+SystemUI. It focuses on making the status bar, lockscreen, and Always On
+Display more configurable while still keeping the system's own icons and visual
+style where possible.
 
-The project is currently tested only on a Samsung Galaxy Z Fold5 running One UI
-8.0 / Android 16. Expect device- and One UI-version-specific behaviour.
+The project is physically tested only on a Samsung Galaxy Z Fold5 running One UI
+8.0 / Android 16. Other SystemUI builds have emulator-tested support as shown
+in the compatibility matrix.
+
+## AI Assistance
+
+This project was developed with help from AI-assisted coding tools. The design
+decisions, physical device testing, and final behaviour are still manually reviewed.
 
 ## What It Does
 
-- Custom status bar layout for the unlocked screen, lockscreen, and AOD.
+- Custom status bar layout for the unlocked screen, lockscreen, and AOD where
+  supported by the SystemUI build.
 - Independent placement of clock, carrier text, notification icons, status
   icons, and Samsung status chips.
 - Separate notification display handling for Samsung's cards, icons, and dot
@@ -41,31 +49,64 @@ It also supports lightweight markup:
 - Pipe alignment with `|`, useful for aligning split clock rows around a camera
   cutout.
 - Colour variants and reverse Polish notation colour math for light/dark status
-  bar states, for example `color(#batterybar 1.2 * ; invRGB 0.5 *RGB)`.
+  bar states, for example `color(#batterybar 1.2 *RGB ; #batterybar 0.5 *RGB)`, which uses the batterybar's dynamic colour as its base. For the bright tint, it brightens it up some more, while for the dark tint, it is darkened.
 
 The in-app clock page has the full syntax help and examples.
 
 ## Requirements
 
-- A rooted Samsung device.
-- A modern Xposed implementation such as LSPosed.
+- A rooted Android 14+ device or emulator. Actual feature support depends on
+  the SystemUI implementation; see the compatibility matrix.
+- A modern Xposed implementation such as LSPosed or another libxposed-compatible runtime.
 - Xposed API 101 or newer.
-- A Samsung/One UI version close to One UI 8.0 / Android 16.
+- SystemUI access for the module scope.
 
-This module hooks Samsung SystemUI internals. It is not expected to work on
-non-Samsung SystemUI, and updates to One UI may require fixes.
+The module is developed and manually tested on a Samsung Galaxy Z Fold5 running
+One UI 8.0 / Android 16. Non-Samsung builds have emulator-tested support as
+shown below, but hardware-dependent behavior remains experimental unless it has
+also been verified on physical hardware.
 
 ## Device Compatibility
 
-StatusBarTweak is Samsung-specific in its current form. Some lower-level ideas,
-such as drawing a custom battery bar or parsing custom clock text, could be
-ported elsewhere. The layout engine itself depends on Samsung's SystemUI,
-lockscreen, AOD service, notification display modes, status icons, and status
-chip implementation.
+Some behavior cannot be fully verified on emulators. Emulator testing can still
+verify whether hooks load, whether SystemUI stays stable, whether settings apply,
+whether excessive background work appears in logs, and whether the steady state
+looks the way it should.
 
-Plain Android or other OEM skins would need separate hooks and probably a
-different source-collection layer. They should be treated as unsupported rather
-than untested-compatible.
+`⚠️ Experimental` means best-effort support exists, but the emulator cannot
+expose the required hardware or state for real verification.
+
+| Feature | Galaxy Z Fold5<br>One UI 8 / Android 16 | AOSP API 34<br>Android 14 | AOSP API 35<br>Android 15 | AOSP API 36<br>Android 16 | Google APIs API 35<br>Android 15 | Google APIs API 36<br>Android 16 | LineageOS 22<br>Android 15 | LineageOS 23<br>Android 16 |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| Module loads in SystemUI | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Settings app opens and writes settings | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Custom unlocked statusbar layout | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Custom lockscreen statusbar layout | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Custom AOD statusbar layout | ✅ | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental |
+| Notification icons mode | ✅ | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental |
+| Notification cards mode | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| Notification dot mode and read-state behavior | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| Hide notification icons by app | ✅ | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental |
+| Hide status icons | ✅ | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental | ✅ AOD experimental |
+| Dual-SIM status icon handling | ✅ | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental |
+| Samsung status chips: media/navigation/call | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| Samsung charging chip handling | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| Privacy indicator stability | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Custom statusbar clock text | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Custom drawer clock/date text | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Stored clock pattern previews | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Battery bar: base statusbar modes | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Battery bar: fullscreen and transparent statusbar modes | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Battery bar: curved top-edge geometry | ✅ | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental |
+| Battery bar threshold colours and colour math | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Camera cutout and under-display-camera handling | ✅ | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental | ⚠️ Experimental |
+| Rotation and fold/unfold handling | ✅ | ✅ rotation verified | ✅ rotation verified | ✅ rotation verified | ✅ rotation verified | ✅ rotation verified | ✅ rotation verified | ✅ rotation verified |
+| Drawer scrolling and background-work performance | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Debug visualizers and debug notifications | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
+
+Current emulator targets use rooted LSPosed snapshots. They are useful for
+compatibility work, but hardware-specific entries remain marked as experimental
+when the emulator cannot expose the required state.
 
 ## Build
 
@@ -81,8 +122,39 @@ Release builds require local signing configuration:
 ./gradlew assembleRelease
 ```
 
-## Development Note
+## Test Harness
 
-This project has been coded with the help of AI as an implementation aid. The
-design decisions, device testing, and final behaviour are still manually
-reviewed.
+The repository also includes a small companion app for compatibility testing.
+It is not required for normal use of the module. It creates repeatable
+statusbar scenarios such as opaque, transparent, fullscreen, privacy-indicator,
+and notification states:
+
+```bash
+./gradlew :test-harness:assembleDebug
+adb install -r test-harness/build/outputs/apk/debug/test-harness-debug.apk
+adb shell am start -n se.ajpanton.statusbartweak.harness/.MainActivity
+```
+
+Automation can launch scenarios directly:
+
+```bash
+adb shell am start -n se.ajpanton.statusbartweak.harness/.ScenarioActivity --es scenario fullscreen_landscape
+adb shell am start -n se.ajpanton.statusbartweak.harness/.MainActivity --es command post_normal
+```
+
+Useful scenario values include `opaque_light`, `opaque_dark`, `transparent`,
+`fullscreen_portrait`, `fullscreen_landscape`, `camera`, `microphone`, and
+`camera_microphone`.
+
+Useful command values include `post_normal`, `post_ongoing`, `post_grouped`,
+`update`, `start_chronometer`, `start_churn`, `stop_churn`, `start_media`,
+`start_foreground`, `stop_service`, and `clear`.
+
+Battery charging state is controlled by Android system commands rather than by
+the harness APK:
+
+```bash
+adb shell cmd battery set status 2
+adb shell cmd battery set level 80
+adb shell cmd battery reset
+```

app/build.gradle.kts

@@ -69,7 +69,7 @@ android {
 
     defaultConfig {
         applicationId = "se.ajpanton.statusbartweak"
-        minSdk = 35
+        minSdk = 34
         targetSdk = 36
         val buildVersionName = project.findProperty("sbtVersionName")?.toString()
             ?: fallbackVersionName

app/src/main/java/se/ajpanton/statusbartweak/module/ModuleCoordinator.java

@@ -2,6 +2,7 @@ package se.ajpanton.statusbartweak.module;
 
 import io.github.libxposed.api.XposedInterface;
 import io.github.libxposed.api.XposedModuleInterface;
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.runtime.features.RuntimeContext;
 import se.ajpanton.statusbartweak.runtime.features.StandaloneFeatureRegistry;
 import se.ajpanton.statusbartweak.runtime.mode.ModeStateRepository;
@@ -15,11 +16,6 @@ import se.ajpanton.statusbartweak.runtime.mode.ModeStateRepository;
  */
 public final class ModuleCoordinator {
 
-    private static final String PACKAGE_ANDROID = "android";
-    private static final String PACKAGE_SYSTEM = "system";
-    private static final String PACKAGE_SYSTEMUI = "com.android.systemui";
-    private static final String PACKAGE_AODSERVICE = "com.samsung.android.app.aodservice";
-
     private final RuntimeContext runtimeContext;
     private final StandaloneFeatureRegistry standaloneFeatureRegistry;
 
@@ -33,10 +29,7 @@ public final class ModuleCoordinator {
 
     public void onModuleLoaded(XposedModuleInterface.ModuleLoadedParam param) {
         String processName = param.getProcessName();
-        if (!PACKAGE_SYSTEMUI.equals(processName)
-                && !PACKAGE_ANDROID.equals(processName)
-                && !PACKAGE_SYSTEM.equals(processName)
-                && !PACKAGE_AODSERVICE.equals(processName)) {
+        if (!SystemUiCapabilities.isHandledProcessName(processName)) {
             return;
         }
         standaloneFeatureRegistry.onModuleLoaded(param);
@@ -54,9 +47,6 @@ public final class ModuleCoordinator {
     }
 
     private static boolean shouldHandlePackage(String packageName) {
-        return PACKAGE_SYSTEMUI.equals(packageName)
-                || PACKAGE_ANDROID.equals(packageName)
-                || PACKAGE_SYSTEM.equals(packageName)
-                || PACKAGE_AODSERVICE.equals(packageName);
+        return SystemUiCapabilities.isHandledPackageName(packageName);
     }
 }

app/src/main/java/se/ajpanton/statusbartweak/platform/SystemUiCapabilities.java

@@ -0,0 +1,65 @@
+package se.ajpanton.statusbartweak.platform;
+
+import android.os.Build;
+
+import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
+
+public final class SystemUiCapabilities {
+    public static final String PACKAGE_ANDROID = "android";
+    public static final String PACKAGE_SYSTEM = "system";
+    public static final String PACKAGE_SYSTEMUI = "com.android.systemui";
+    public static final String PACKAGE_SAMSUNG_AOD_SERVICE = "com.samsung.android.app.aodservice";
+
+    private SystemUiCapabilities() {
+    }
+
+    public static boolean isSamsungOneUi() {
+        return "samsung".equalsIgnoreCase(Build.MANUFACTURER);
+    }
+
+    public static boolean supportsLockscreenShadeWindowRoot() {
+        return !isSamsungOneUi();
+    }
+
+    public static boolean supportsSamsungAodServiceProcess() {
+        return isSamsungOneUi();
+    }
+
+    public static boolean supportsSamsungAodMiscControllers() {
+        return isSamsungOneUi();
+    }
+
+    public static boolean supportsSamsungStatusChipHooks() {
+        return isSamsungOneUi();
+    }
+
+    public static boolean supportsSamsungNotificationDisplayStyles() {
+        return isSamsungOneUi();
+    }
+
+    public static boolean isSystemUiPackageName(String packageName) {
+        return PACKAGE_SYSTEMUI.equals(packageName);
+    }
+
+    public static boolean isHandledPackageName(String packageName) {
+        return PACKAGE_SYSTEMUI.equals(packageName)
+                || PACKAGE_ANDROID.equals(packageName)
+                || PACKAGE_SYSTEM.equals(packageName)
+                || (supportsSamsungAodServiceProcess()
+                && PACKAGE_SAMSUNG_AOD_SERVICE.equals(packageName));
+    }
+
+    public static boolean isHandledProcessName(String processName) {
+        return isHandledPackageName(processName);
+    }
+
+    public static boolean supportsExperimentalGenericAodStatusbarRoot(SbtSettings settings) {
+        return !isSamsungOneUi()
+                && settings != null
+                && settings.debugExperimentalAodStatusbarRoot;
+    }
+
+    public static boolean treatsUnknownAodNotificationStyleAsIcons(SbtSettings settings) {
+        return supportsExperimentalGenericAodStatusbarRoot(settings);
+    }
+}

app/src/main/java/se/ajpanton/statusbartweak/runtime/NotificationKeyReflection.java

@@ -80,6 +80,10 @@ public final class NotificationKeyReflection {
             return null;
         }
         String normalized = key.trim();
+        String pipePackage = packageFromPipeNotificationKey(normalized);
+        if (pipePackage != null) {
+            return pipePackage;
+        }
         int suffix = normalized.indexOf('@');
         if (suffix >= 0) {
             normalized = normalized.substring(0, suffix);
@@ -91,6 +95,19 @@ public final class NotificationKeyReflection {
         return AppIconRules.isValidPackageName(normalized) ? normalized : null;
     }
 
+    private static String packageFromPipeNotificationKey(String key) {
+        int firstPipe = key.indexOf('|');
+        if (firstPipe < 0) {
+            return null;
+        }
+        int secondPipe = key.indexOf('|', firstPipe + 1);
+        if (secondPipe <= firstPipe + 1) {
+            return null;
+        }
+        String packageName = key.substring(firstPipe + 1, secondPipe);
+        return AppIconRules.isValidPackageName(packageName) ? packageName : null;
+    }
+
     private static String nonEmptyStringFromMethod(Object target, String methodName) {
         Object value = ReflectionSupport.invokeMethod(target, methodName);
         return value instanceof String string && !string.isEmpty() ? string : null;

app/src/main/java/se/ajpanton/statusbartweak/runtime/RuntimeMutationGuard.java

@@ -0,0 +1,27 @@
+package se.ajpanton.statusbartweak.runtime;
+
+public final class RuntimeMutationGuard {
+    private static final ThreadLocal<Integer> SNAPSHOT_RENDER_DEPTH =
+            ThreadLocal.withInitial(() -> 0);
+
+    private RuntimeMutationGuard() {
+    }
+
+    public static void enterSnapshotRenderMutation() {
+        SNAPSHOT_RENDER_DEPTH.set(SNAPSHOT_RENDER_DEPTH.get() + 1);
+    }
+
+    public static void exitSnapshotRenderMutation() {
+        int depth = SNAPSHOT_RENDER_DEPTH.get() - 1;
+        if (depth <= 0) {
+            SNAPSHOT_RENDER_DEPTH.remove();
+        } else {
+            SNAPSHOT_RENDER_DEPTH.set(depth);
+        }
+    }
+
+    public static boolean isSnapshotRenderMutation() {
+        Integer depth = SNAPSHOT_RENDER_DEPTH.get();
+        return depth != null && depth > 0;
+    }
+}

app/src/main/java/se/ajpanton/statusbartweak/runtime/ViewIdNames.java

@@ -8,7 +8,7 @@ public final class ViewIdNames {
     }
 
     public static String idName(View view) {
-        if (view == null || view.getId() == View.NO_ID) {
+        if (view == null || view.getId() == View.NO_ID || (view.getId() >>> 24) == 0) {
             return "";
         }
         try {

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/RuntimeFeature.java

@@ -1,7 +1,7 @@
 package se.ajpanton.statusbartweak.runtime.features;
 
 import io.github.libxposed.api.XposedModuleInterface;
-import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 
 /**
  * Small independent runtime slice.
@@ -15,7 +15,8 @@ public interface RuntimeFeature {
     String getName();
 
     static boolean isSystemUiPackage(XposedModuleInterface.PackageReadyParam param) {
-        return param != null && SbtSettings.PACKAGE_SYSTEMUI.equals(param.getPackageName());
+        return param != null
+                && SystemUiCapabilities.isSystemUiPackageName(param.getPackageName());
     }
 
     default void onModuleLoaded(

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/battery/BatteryBarController.java

@@ -1,5 +1,6 @@
 package se.ajpanton.statusbartweak.runtime.features.battery;
 
+import android.app.KeyguardManager;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
@@ -11,8 +12,11 @@ import android.graphics.Path;
 import android.graphics.PathMeasure;
 import android.graphics.PixelFormat;
 import android.graphics.Rect;
+import android.graphics.RectF;
 import android.os.BatteryManager;
+import android.util.DisplayMetrics;
 import android.view.Gravity;
+import android.view.RoundedCorner;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewParent;
@@ -154,8 +158,17 @@ final class BatteryBarController {
             return result;
         });
         XposedHookSupport.hookAllMethodsIfExists(framework, View.class, "setAlpha", chain -> {
-            Object result = chain.proceed();
             Object target = chain.getThisObject();
+            Object alphaArg = chain.getArgs() != null && !chain.getArgs().isEmpty()
+                    ? chain.getArgs().get(0)
+                    : null;
+            if (target instanceof View root
+                    && alphaArg instanceof Float alpha
+                    && roots.contains(root)
+                    && shouldBlockChargingChipRootAlpha(root, alpha)) {
+                return null;
+            }
+            Object result = chain.proceed();
             if (target instanceof View root && roots.contains(root)) {
                 applyBatteryBarAfterRootTransform(root);
             }
@@ -271,6 +284,7 @@ final class BatteryBarController {
         }
         int result = 17;
         result = 31 * result + root.getVisibility();
+        result = 31 * result + Float.floatToIntBits(root.getAlpha());
         result = 31 * result + Float.floatToIntBits(root.getY());
         result = 31 * result + Float.floatToIntBits(root.getTranslationY());
         result = 31 * result + root.getWidth();
@@ -373,21 +387,26 @@ final class BatteryBarController {
             return;
         }
         SbtSettings settings = RuntimeSettingsCache.get(root.getContext());
-        if (!settings.batteryBarEnabled || root.getWidth() <= 0 || root.getHeight() <= 0) {
+        if (root.getWidth() <= 0 || root.getHeight() <= 0) {
+            removeBatteryBarView(root);
+            return;
+        }
+        BatteryBarGeometry.Scenario scenario = scenarioForRoot(root);
+        boolean transientStatusBarReveal = isFullscreenScenario(scenario)
+                && !isLockedPhoneStatusBarRoot(root)
+                && shouldRenderVisibleFullscreenBar(root);
+        if (transientStatusBarReveal) {
+            scenario = visibleStatusBarScenarioForRoot(root);
+        }
+        if (!isBatteryBarEnabled(settings, scenario)) {
             removeBatteryBarView(root);
             return;
         }
         int color = resolveBarColor(root, settings);
-        BatteryBarGeometry.Scenario scenario = scenarioForRoot(root);
         if (!shouldRenderOnRoot(root)) {
             removeBatteryBarView(root);
             return;
         }
-        boolean transientStatusBarReveal = isFullscreenScenario(scenario)
-                && shouldRenderVisibleFullscreenBar(root);
-        if (transientStatusBarReveal) {
-            scenario = visibleStatusBarScenarioForRoot(root);
-        }
         BatteryBarGeometry geometry = BatteryBarGeometry.resolve(settings, scenario);
         if (isFullscreenScenario(scenario)) {
             removeEmbeddedBatteryBarView(root);
@@ -415,7 +434,7 @@ final class BatteryBarController {
     ) {
         BatteryBarView barView = ensureBatteryBarView(rootGroup);
         layoutBatteryBarView(rootGroup, barView);
-        barView.update(rootGroup, settings, geometry, batteryLevel, plugged, color);
+        barView.update(rootGroup, rootGroup, settings, geometry, batteryLevel, plugged, color);
         barView.bringToFront();
         barView.invalidate();
         lastSignatures.put(rootGroup, buildSignature(rootGroup, settings, color, geometry, scenario));
@@ -442,7 +461,7 @@ final class BatteryBarController {
             return;
         }
         pendingOverlayRetries.remove(root);
-        overlay.view.update(overlay.host, settings, geometry, batteryLevel, plugged, color);
+        overlay.view.update(overlay.host, root, settings, geometry, batteryLevel, plugged, color);
         if (!signature.equals(lastOverlaySignatures.get(root))) {
             overlay.updateLayout(bounds.width, bounds.height);
             lastOverlaySignatures.put(root, signature);
@@ -529,6 +548,7 @@ final class BatteryBarController {
                 + plugged + "|"
                 + color + "|"
                 + settings.batteryBarEnabled + "|"
+                + settings.batteryBarScenarioEnabled + "|"
                 + settings.batteryBarPosition + "|"
                 + settings.batteryBarAlignment + "|"
                 + settings.batteryBarThicknessDp + "|"
@@ -547,7 +567,7 @@ final class BatteryBarController {
             return BatteryBarGeometry.Scenario.LOCKSCREEN;
         }
         boolean fullscreen = isPhoneRoot(root)
-                && isUnlockedScene()
+                && (isUnlockedScene() || isLockedPhoneFullscreenRoot(root))
                 && (isStatusBarSurfaceHidden(root) || isFullscreenSystemBarState());
         boolean landscape = isLandscapeForRoot(root, fullscreen);
         if (fullscreen) {
@@ -565,6 +585,21 @@ final class BatteryBarController {
                 : BatteryBarGeometry.Scenario.UNLOCKED_PORTRAIT;
     }
 
+    private boolean isBatteryBarEnabled(
+            SbtSettings settings,
+            BatteryBarGeometry.Scenario scenario
+    ) {
+        if (settings == null || scenario == null) {
+            return false;
+        }
+        if (scenario == BatteryBarGeometry.Scenario.UNLOCKED_PORTRAIT
+                || scenario == BatteryBarGeometry.Scenario.UNLOCKED_LANDSCAPE) {
+            return settings.batteryBarEnabled;
+        }
+        Boolean scenarioEnabled = settings.batteryBarScenarioEnabled.get(scenario.id);
+        return scenarioEnabled == null || scenarioEnabled;
+    }
+
     private BatteryBarGeometry.Scenario visibleStatusBarScenarioForRoot(View root) {
         boolean landscape = isLandscapeForRoot(root, isFullscreenSystemBarState());
         if (isPhoneRoot(root) && isUnlockedScene() && isTransparentStatusBarActive()) {
@@ -588,11 +623,22 @@ final class BatteryBarController {
             return scene == null || !scene.isUnlocked();
         }
         if (isPhoneRoot(root)) {
-            return scene == null || scene.isUnlocked();
+            if (isLockedPhoneStatusBarRoot(root)) {
+                return isLockedPhoneFullscreenRoot(root);
+            }
+            return scene == null || scene.isUnlocked() || isLockedPhoneFullscreenRoot(root);
         }
         return true;
     }
 
+    private boolean shouldBlockChargingChipRootAlpha(View root, float alpha) {
+        return alpha < 0.99f
+                && isPhoneRoot(root)
+                && isUnlockedScene()
+                && !isFullscreenSystemBarState()
+                && hasSamsungBatteryStatusChip(root);
+    }
+
     private boolean isUnlockedScene() {
         SceneKey scene = runtimeContext.getModeStateRepository().getActiveScene();
         return scene == null || scene.isUnlocked();
@@ -606,6 +652,23 @@ final class BatteryBarController {
         return root != null && root.getClass().getName().contains("KeyguardStatusBarView");
     }
 
+    private boolean isLockedPhoneStatusBarRoot(View root) {
+        return isPhoneRoot(root) && isKeyguardLocked(root.getContext());
+    }
+
+    private boolean isLockedPhoneFullscreenRoot(View root) {
+        return isLockedPhoneStatusBarRoot(root)
+                && (isStatusBarSurfaceHidden(root) || isFullscreenSystemBarState());
+    }
+
+    private boolean isKeyguardLocked(Context context) {
+        if (context == null) {
+            return false;
+        }
+        KeyguardManager keyguardManager = context.getSystemService(KeyguardManager.class);
+        return keyguardManager != null && keyguardManager.isKeyguardLocked();
+    }
+
     private boolean isHiddenKeyguardRoot(View root) {
         return isKeyguardRoot(root) && !root.isShown();
     }
@@ -758,6 +821,32 @@ final class BatteryBarController {
         return bottom <= 0f || top >= screenHeight || right <= 0f || left >= screenWidth;
     }
 
+    private boolean hasSamsungBatteryStatusChip(View root) {
+        if (!(root != null && root.getRootView() instanceof ViewGroup rootView)) {
+            return false;
+        }
+        return findSamsungBatteryStatusChip(rootView) != null;
+    }
+
+    private View findSamsungBatteryStatusChip(View view) {
+        if (view == null) {
+            return null;
+        }
+        if (view.getClass().getName().contains("SamsungBatteryStatusChip")) {
+            return view;
+        }
+        if (!(view instanceof ViewGroup group)) {
+            return null;
+        }
+        for (int i = 0; i < group.getChildCount(); i++) {
+            View found = findSamsungBatteryStatusChip(group.getChildAt(i));
+            if (found != null) {
+                return found;
+            }
+        }
+        return null;
+    }
+
     private static Integer asInteger(Object value) {
         return value instanceof Integer integer ? integer : null;
     }
@@ -922,6 +1011,7 @@ final class BatteryBarController {
                     WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                             | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
                             | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
+                            | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
                             | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                             | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS,
                     PixelFormat.TRANSLUCENT);
@@ -948,8 +1038,8 @@ final class BatteryBarController {
         private final Path fullCurvePath = new Path();
         private final Path drawPath = new Path();
         private final PathMeasure pathMeasure = new PathMeasure();
-        private final float[] pathPoint = new float[2];
         private ViewGroup host;
+        private View roundedCornerSource;
         private SbtSettings settings;
         private BatteryBarGeometry geometry;
         private int batteryLevel = -1;
@@ -964,6 +1054,7 @@ final class BatteryBarController {
 
         void update(
                 ViewGroup host,
+                View roundedCornerSource,
                 SbtSettings settings,
                 BatteryBarGeometry geometry,
                 int batteryLevel,
@@ -971,6 +1062,7 @@ final class BatteryBarController {
                 int color
         ) {
             this.host = host;
+            this.roundedCornerSource = roundedCornerSource;
             this.settings = settings;
             this.geometry = geometry;
             this.batteryLevel = batteryLevel;
@@ -996,7 +1088,18 @@ final class BatteryBarController {
                     ? geometry
                     : BatteryBarGeometry.global(settings);
             int thickness = Math.max(1, dpToPx(getContext(), activeGeometry.thicknessDp));
-            int edgeOffset = Math.max(0, dpToPx(getContext(), settings.batteryBarEdgeOffsetDp));
+            int edgeOffset = Math.max(0, dpToPx(getContext(), activeGeometry.edgeOffsetDp));
+            float fraction = resolveFraction(batteryLevel, settings);
+            if (shouldDrawCurvedTop(activeGeometry)) {
+                buildCurvedPath(
+                        width,
+                        height,
+                        thickness,
+                        edgeOffset,
+                        fraction,
+                        activeGeometry.alignment);
+                return;
+            }
             int left = edgeOffset;
             int right = width - edgeOffset;
             if (right <= left) {
@@ -1007,11 +1110,6 @@ final class BatteryBarController {
             if (bottom <= top) {
                 return;
             }
-            float fraction = resolveFraction(batteryLevel, settings);
-            if (shouldDrawCurvedTop(activeGeometry)) {
-                buildCurvedPath(left, right, height, thickness, fraction, activeGeometry.alignment);
-                return;
-            }
             int availableWidth = right - left;
             int barWidth = Math.round(availableWidth * fraction);
             if (barWidth <= 0) {
@@ -1033,53 +1131,47 @@ final class BatteryBarController {
                 return false;
             }
             return !SbtSettings.BATTERY_BAR_CURVED_GEOMETRY_OFF.equals(
-                    settings.batteryBarCurvedGeometryMode);
+                    geometry.curvedGeometryMode);
         }
 
         private void buildCurvedPath(
-                int left,
-                int right,
+                int width,
                 int height,
                 int thickness,
+                int edgeOffset,
                 float fraction,
                 String alignment
         ) {
-            if (fraction <= 0f || right <= left || height <= 0 || thickness <= 0) {
+            if (fraction <= 0f || width <= 0 || height <= 0 || thickness <= 0) {
                 return;
             }
-            float halfStroke = thickness / 2f;
-            float leftCenter = left + halfStroke;
-            float rightCenter = right - halfStroke;
-            if (rightCenter <= leftCenter) {
-                return;
-            }
-            buildFullCurvePath(leftCenter, rightCenter, height, thickness);
+            buildFullCurvePath(width, height, thickness);
             pathMeasure.setPath(fullCurvePath, false);
             float fullLength = pathMeasure.getLength();
             if (fullLength <= 0f) {
                 return;
             }
-            float targetLength = SbtSettings.BATTERY_BAR_CURVED_GEOMETRY_LENGTH.equals(
-                    settings.batteryBarCurvedGeometryMode)
-                    ? fullLength * fraction
-                    : targetDistanceForHorizontalFraction(
-                            leftCenter,
-                            rightCenter,
-                            fullLength,
-                            fraction);
+            float pathOffset = Math.min(Math.max(0f, edgeOffset), fullLength / 2f);
+            float usableStart = pathOffset;
+            float usableEnd = fullLength - pathOffset;
+            float usableLength = usableEnd - usableStart;
+            if (usableLength <= 0f) {
+                return;
+            }
+            float targetLength = usableLength * fraction;
             if (targetLength <= 0f) {
                 return;
             }
-            targetLength = Math.min(fullLength, targetLength);
-            float start = 0f;
-            float end = targetLength;
+            targetLength = Math.min(usableLength, targetLength);
+            float start = usableStart;
+            float end = usableStart + targetLength;
             if ("rtl".equals(alignment)) {
-                start = fullLength - targetLength;
-                end = fullLength;
+                start = usableEnd - targetLength;
+                end = usableEnd;
             } else if ("center".equals(alignment)) {
-                float center = fullLength / 2f;
-                start = Math.max(0f, center - targetLength / 2f);
-                end = Math.min(fullLength, center + targetLength / 2f);
+                float center = (usableStart + usableEnd) / 2f;
+                start = Math.max(usableStart, center - targetLength / 2f);
+                end = Math.min(usableEnd, center + targetLength / 2f);
             }
             if (end <= start) {
                 return;
@@ -1089,64 +1181,124 @@ final class BatteryBarController {
             pathStrokeWidth = thickness;
         }
 
-        private void buildFullCurvePath(float left, float right, int height, int thickness) {
+        private void buildFullCurvePath(int width, int height, int thickness) {
             fullCurvePath.reset();
             float halfStroke = thickness / 2f;
+            if (width <= thickness) {
+                return;
+            }
             float topY = halfStroke;
             float bottomY = Math.max(topY, height - halfStroke);
             float verticalSpan = bottomY - topY;
-            float radius = Math.min(verticalSpan, (right - left) / 2f);
-            fullCurvePath.moveTo(left, bottomY);
-            if (radius <= 0f) {
-                fullCurvePath.lineTo(right, topY);
+            float outerRadius = Math.min(
+                    resolveTopCornerRadius(verticalSpan + halfStroke),
+                    width / 2f);
+            float curveRadius = outerRadius - halfStroke;
+            if (curveRadius <= 0f) {
+                buildSharpTopPath(width, topY, bottomY, halfStroke);
                 return;
             }
-            fullCurvePath.lineTo(left, topY + radius);
-            fullCurvePath.quadTo(left, topY, left + radius, topY);
-            fullCurvePath.lineTo(right - radius, topY);
-            fullCurvePath.quadTo(right, topY, right, topY + radius);
-            fullCurvePath.lineTo(right, bottomY);
+            float leftTopX = outerRadius;
+            float rightTopX = width - outerRadius;
+            if (rightTopX <= leftTopX) {
+                buildSharpTopPath(width, topY, bottomY, halfStroke);
+                return;
+            }
+            RectF leftCorner = new RectF(
+                    halfStroke,
+                    halfStroke,
+                    outerRadius + curveRadius,
+                    outerRadius + curveRadius);
+            RectF rightCorner = new RectF(
+                    width - outerRadius - curveRadius,
+                    halfStroke,
+                    width - halfStroke,
+                    outerRadius + curveRadius);
+
+            float leftStartAngle = leftCornerStartAngle(bottomY, outerRadius, curveRadius);
+            float leftStartX = cornerX(leftCorner.centerX(), curveRadius, leftStartAngle);
+            float leftStartY = cornerY(leftCorner.centerY(), curveRadius, leftStartAngle);
+            fullCurvePath.moveTo(halfStroke, bottomY);
+            fullCurvePath.lineTo(leftStartX, leftStartY);
+            fullCurvePath.arcTo(leftCorner, leftStartAngle, 270f - leftStartAngle);
+            fullCurvePath.lineTo(rightTopX, topY);
+
+            float rightEndAngle = rightCornerEndAngle(bottomY, outerRadius, curveRadius);
+            fullCurvePath.arcTo(rightCorner, 270f, rightEndAngle - 270f);
+            fullCurvePath.lineTo(width - halfStroke, bottomY);
         }
 
-        private float targetDistanceForHorizontalFraction(
-                float left,
-                float right,
-                float fullLength,
-                float fraction
-        ) {
-            if (fraction >= 1f) {
-                return fullLength;
+        private float resolveTopCornerRadius(float fallback) {
+            WindowInsets insets = roundedCornerSource != null
+                    ? roundedCornerSource.getRootWindowInsets()
+                    : null;
+            if (insets == null) {
+                insets = getRootWindowInsets();
             }
-            float horizontalSpan = right - left;
-            if (horizontalSpan <= 0f) {
-                return fullLength * fraction;
+            if (insets == null) {
+                return fallback;
+            }
+            int leftRadius = roundedCornerRadius(insets, RoundedCorner.POSITION_TOP_LEFT);
+            int rightRadius = roundedCornerRadius(insets, RoundedCorner.POSITION_TOP_RIGHT);
+            if (leftRadius > 0 && rightRadius > 0) {
+                return Math.min(leftRadius, rightRadius);
+            }
+            if (leftRadius > 0 || rightRadius > 0) {
+                return Math.max(leftRadius, rightRadius);
             }
-            float targetHorizontal = horizontalSpan * fraction;
-            if (targetHorizontal <= 0f) {
             return 0f;
         }
-            int steps = Math.max(32, Math.min(512, Math.round(fullLength / 2f)));
-            float previousDistance = 0f;
-            float previousX = left;
-            float accumulatedHorizontal = 0f;
-            for (int step = 1; step <= steps; step++) {
-                float distance = fullLength * step / steps;
-                if (!pathMeasure.getPosTan(distance, pathPoint, null)) {
-                    continue;
+
+        private int roundedCornerRadius(WindowInsets insets, int position) {
+            RoundedCorner corner = insets.getRoundedCorner(position);
+            if (corner == null) {
+                return 0;
             }
-                float dx = Math.abs(pathPoint[0] - previousX);
-                if (accumulatedHorizontal + dx >= targetHorizontal) {
-                    if (dx <= 0f) {
-                        return distance;
+            return stableDensityRadius(Math.max(0, corner.getRadius()));
         }
-                    float ratio = (targetHorizontal - accumulatedHorizontal) / dx;
-                    return previousDistance + (distance - previousDistance) * ratio;
+
+        private int stableDensityRadius(int radius) {
+            if (radius <= 0 || getResources() == null) {
+                return radius;
             }
-                accumulatedHorizontal += dx;
-                previousDistance = distance;
-                previousX = pathPoint[0];
+            DisplayMetrics metrics = getResources().getDisplayMetrics();
+            int currentDpi = metrics != null ? metrics.densityDpi : 0;
+            int stableDpi = DisplayMetrics.DENSITY_DEVICE_STABLE;
+            if (currentDpi <= 0 || stableDpi <= 0 || currentDpi == stableDpi) {
+                return radius;
             }
-            return fullLength;
+            return Math.max(1, Math.round(radius * (stableDpi / (float) currentDpi)));
+        }
+
+        private void buildSharpTopPath(int width, float topY, float bottomY, float halfStroke) {
+            fullCurvePath.moveTo(halfStroke, bottomY);
+            fullCurvePath.lineTo(halfStroke, topY);
+            fullCurvePath.lineTo(width - halfStroke, topY);
+            fullCurvePath.lineTo(width - halfStroke, bottomY);
+        }
+
+        private float leftCornerStartAngle(float bottomY, float outerRadius, float curveRadius) {
+            if (bottomY >= outerRadius) {
+                return 180f;
+            }
+            float ratio = Math.max(-1f, Math.min(1f, (outerRadius - bottomY) / curveRadius));
+            return 180f + (float) Math.toDegrees(Math.asin(ratio));
+        }
+
+        private float rightCornerEndAngle(float bottomY, float outerRadius, float curveRadius) {
+            if (bottomY >= outerRadius) {
+                return 360f;
+            }
+            float ratio = Math.max(-1f, Math.min(1f, (outerRadius - bottomY) / curveRadius));
+            return 360f - (float) Math.toDegrees(Math.asin(ratio));
+        }
+
+        private float cornerX(float centerX, float radius, float angleDegrees) {
+            return centerX + radius * (float) Math.cos(Math.toRadians(angleDegrees));
+        }
+
+        private float cornerY(float centerY, float radius, float angleDegrees) {
+            return centerY + radius * (float) Math.sin(Math.toRadians(angleDegrees));
         }
 
         private int resolveTop(BatteryBarGeometry geometry, int thickness, int height) {

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/chips/StatusChipsFeature.java

@@ -1,6 +1,7 @@
 package se.ajpanton.statusbartweak.runtime.features.chips;
 
 import io.github.libxposed.api.XposedModuleInterface;
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.runtime.features.RuntimeContext;
 import se.ajpanton.statusbartweak.runtime.features.RuntimeFeature;
 
@@ -32,6 +33,9 @@ public final class StatusChipsFeature implements RuntimeFeature {
     }
 
     private void installController(RuntimeContext context, ClassLoader classLoader) {
+        if (!SystemUiCapabilities.supportsSamsungStatusChipHooks()) {
+            return;
+        }
         if (statusChipHider == null) {
             statusChipHider = new StatusChipHider(context);
         }

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/clock/ClockColorResolver.java

@@ -7,40 +7,66 @@ import java.util.Locale;
 
 import se.ajpanton.statusbartweak.shell.settings.BatteryBarStyle;
 
-final class ClockColorResolver {
+public final class ClockColorResolver {
     private static final int CHANNEL_ALPHA = 0;
     private static final int CHANNEL_RED = 1;
     private static final int CHANNEL_GREEN = 2;
     private static final int CHANNEL_BLUE = 3;
     private static final int CHANNEL_COUNT = 4;
 
-    String resolveColorHex(
+    public String resolveColorHex(
             Context context,
             String expression,
             int referenceColor,
             int fallbackColor
     ) {
         int resolved = resolveColor(context, expression, referenceColor, fallbackColor);
+        return colorHex(resolved);
+    }
+
+    public String resolveColorHex(
+            Context context,
+            String expression,
+            int referenceColor,
+            int fallbackColor,
+            Options options
+    ) {
+        int resolved = resolveColor(context, expression, referenceColor, fallbackColor, options);
+        return colorHex(resolved);
+    }
+
+    private String colorHex(int resolved) {
         if (alpha(resolved) >= 255) {
             return String.format(Locale.ROOT, "#%06X", resolved & 0xFFFFFF);
         }
         return String.format(Locale.ROOT, "#%08X", resolved);
     }
 
-    int resolveColor(
+    public int resolveColor(
             Context context,
             String expression,
             int referenceColor,
             int fallbackColor
+    ) {
+        return resolveColor(context, expression, referenceColor, fallbackColor, Options.clock());
+    }
+
+    public int resolveColor(
+            Context context,
+            String expression,
+            int referenceColor,
+            int fallbackColor,
+            Options options
     ) {
         if (isEmpty(expression)) {
             return fallbackColor;
         }
+        Options resolvedOptions = options != null ? options : Options.clock();
         VariantExpressions variants = splitVariants(expression);
-        Value bright = evaluateExpression(context, variants.brightExpression, null, fallbackColor);
+        Value bright = evaluateExpression(context, variants.brightExpression, null, fallbackColor, resolvedOptions);
         Value dark = variants.darkExpression.isEmpty()
                 ? bright
-                : evaluateExpression(context, variants.darkExpression, bright, fallbackColor);
+                : evaluateExpression(context, variants.darkExpression, bright, fallbackColor, resolvedOptions);
         return toColor(isDark(referenceColor) ? dark : bright);
     }
 
@@ -48,7 +74,8 @@ final class ClockColorResolver {
             Context context,
             String expression,
             Value inherited,
-            int fallbackColor
+            int fallbackColor,
+            Options options
     ) {
         ArrayList<String> tokens = tokenize(expression);
         ArrayList<Value> stack = new ArrayList<>();
@@ -56,7 +83,7 @@ final class ClockColorResolver {
             stack.add(inherited.copy());
         }
         for (String token : tokens) {
-            applyToken(context, stack, token, fallbackColor);
+            applyToken(context, stack, token, fallbackColor, options);
         }
         if (stack.isEmpty()) {
             throw new IllegalArgumentException("Empty colour expression");
@@ -64,7 +91,13 @@ final class ClockColorResolver {
         return top(stack).copy();
     }
 
-    private void applyToken(Context context, ArrayList<Value> stack, String token, int fallbackColor) {
+    private void applyToken(
+            Context context,
+            ArrayList<Value> stack,
+            String token,
+            int fallbackColor,
+            Options options
+    ) {
         if (isEmpty(token)) {
             return;
         }
@@ -73,7 +106,7 @@ final class ClockColorResolver {
             applyOperation(stack, operation);
             return;
         }
-        stack.add(parseOperand(context, token, fallbackColor));
+        stack.add(parseOperand(context, token, fallbackColor, options));
     }
 
     private Operation parseOperation(String token) {
@@ -244,12 +277,15 @@ final class ClockColorResolver {
         stack.add(Value.vector(result));
     }
 
-    private Value parseOperand(Context context, String token, int fallbackColor) {
+    private Value parseOperand(Context context, String token, int fallbackColor, Options options) {
         String value = token != null ? token.trim() : "";
         if (value.isEmpty()) {
             throw new IllegalArgumentException("Empty colour token");
         }
         if ("#batterybar".equalsIgnoreCase(value)) {
+            if (options == null || !options.allowBatteryBarOperand) {
+                throw new IllegalArgumentException("#batterybar is not supported here");
+            }
             return Value.vector(vectorForColor(BatteryBarStyle.resolveCurrentColor(context, fallbackColor, fallbackColor)));
         }
         if (value.charAt(0) == '#') {
@@ -258,6 +294,9 @@ final class ClockColorResolver {
         if (value.charAt(0) == '[') {
             return Value.vector(parseVector(value));
         }
+        if (options != null && options.allowBareHexOperand && looksLikeBareHex(value)) {
+            return Value.vector(vectorForColor(parseHexColor("#" + value)));
+        }
         try {
             return Value.number(Double.parseDouble(value));
         } catch (NumberFormatException e) {
@@ -265,6 +304,22 @@ final class ClockColorResolver {
         }
     }
 
+    private boolean looksLikeBareHex(String value) {
+        int length = value != null ? value.length() : 0;
+        if (length != 3 && length != 4 && length != 6 && length != 8) {
+            return false;
+        }
+        boolean hasHexLetter = false;
+        for (int i = 0; i < length; i++) {
+            char c = value.charAt(i);
+            if (!isHexDigit(c)) {
+                return false;
+            }
+            hasHexLetter |= (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+        }
+        return length != 3 || hasHexLetter;
+    }
+
     private double[] parseVector(String token) {
         String value = token != null ? token.trim() : "";
         if (!value.startsWith("[") || !value.endsWith("]")) {
@@ -608,4 +663,22 @@ final class ClockColorResolver {
             return Math.max(0d, Math.min(255d, value));
         }
     }
+
+    public static final class Options {
+        private final boolean allowBatteryBarOperand;
+        private final boolean allowBareHexOperand;
+
+        private Options(boolean allowBatteryBarOperand, boolean allowBareHexOperand) {
+            this.allowBatteryBarOperand = allowBatteryBarOperand;
+            this.allowBareHexOperand = allowBareHexOperand;
+        }
+
+        public static Options clock() {
+            return new Options(true, false);
+        }
+
+        public static Options batteryBar() {
+            return new Options(false, true);
+        }
+    }
 }

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/clock/ClockMarkupSupport.java

@@ -1,7 +1,5 @@
 package se.ajpanton.statusbartweak.runtime.features.clock;
 
-import android.text.TextUtils;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -94,7 +92,7 @@ final class ClockMarkupSupport {
     }
 
     static void applyParsedTag(StringBuilder out, TagState state, ParsedTag parsedTag) {
-        if (TextUtils.isEmpty(parsedTag.name)) {
+        if (isEmpty(parsedTag.name)) {
             return;
         }
         if (parsedTag.selfClosing) {
@@ -125,7 +123,7 @@ final class ClockMarkupSupport {
             String literal,
             TagCategory category
     ) {
-        if (TextUtils.isEmpty(name) || TextUtils.isEmpty(literal)) {
+        if (isEmpty(name) || isEmpty(literal)) {
             return;
         }
         if (category == TagCategory.FONT_COLOR) {
@@ -140,7 +138,7 @@ final class ClockMarkupSupport {
     }
 
     private static void closeTag(StringBuilder out, TagState state, String name) {
-        if (TextUtils.isEmpty(name)) {
+        if (isEmpty(name)) {
             return;
         }
         String normalized = name.toLowerCase(Locale.ROOT);
@@ -187,7 +185,7 @@ final class ClockMarkupSupport {
     }
 
     static ParsedTag parseTagLiteral(String literal) {
-        if (TextUtils.isEmpty(literal)) {
+        if (isEmpty(literal)) {
             return null;
         }
         String trimmed = literal.trim();
@@ -232,7 +230,7 @@ final class ClockMarkupSupport {
     }
 
     static List<Integer> findPipePositions(String markup) {
-        if (TextUtils.isEmpty(markup)) {
+        if (isEmpty(markup)) {
             return Collections.emptyList();
         }
         ArrayList<Integer> positions = new ArrayList<>();
@@ -262,7 +260,7 @@ final class ClockMarkupSupport {
     }
 
     static boolean containsSecondsPattern(String pattern) {
-        if (TextUtils.isEmpty(pattern)) {
+        if (isEmpty(pattern)) {
             return false;
         }
         boolean insideTag = false;
@@ -300,4 +298,8 @@ final class ClockMarkupSupport {
         }
         return false;
     }
+
+    private static boolean isEmpty(CharSequence value) {
+        return value == null || value.length() == 0;
+    }
 }

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/clock/ClockPatternParser.java

@@ -1,7 +1,5 @@
 package se.ajpanton.statusbartweak.runtime.features.clock;
 
-import android.text.TextUtils;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
@@ -42,6 +40,13 @@ final class ClockPatternParser {
                 rowMarkup = new StringBuilder();
                 ClockMarkupSupport.appendOpenTags(rowMarkup, carriedState);
                 rowSyntaxError = false;
+                if (!isEmpty(lineBreak.trailingShorthand)) {
+                    try {
+                        appendShorthandBlock(rowMarkup, rowState, lineBreak.trailingShorthand);
+                    } catch (IllegalArgumentException e) {
+                        rowSyntaxError = true;
+                    }
+                }
                 gapBeforePx = lineBreak.gapBeforePx;
                 index = lineBreak.endIndex;
                 continue;
@@ -111,7 +116,7 @@ final class ClockPatternParser {
     }
 
     private ClockParsedPattern.ClockParsedRow buildParsedRow(String markup, int gapBeforePx) {
-        if (TextUtils.isEmpty(markup)) {
+        if (isEmpty(markup)) {
             return ClockParsedPattern.ClockParsedRow.plain("", gapBeforePx);
         }
         List<Integer> pipePositions = ClockMarkupSupport.findPipePositions(markup);
@@ -153,7 +158,7 @@ final class ClockPatternParser {
         }
         ArrayList<String> tokens = tokenizeShorthand(trimmed);
         for (String token : tokens) {
-            if (TextUtils.isEmpty(token)) {
+            if (isEmpty(token)) {
                 continue;
             }
             if ("/font".equalsIgnoreCase(token)) {
@@ -260,6 +265,10 @@ final class ClockPatternParser {
                 && value.endsWith(")");
     }
 
+    private boolean isEmpty(CharSequence value) {
+        return value == null || value.length() == 0;
+    }
+
     private void openClockColorTag(
             StringBuilder out,
             ClockMarkupSupport.TagState tagState,
@@ -281,7 +290,7 @@ final class ClockPatternParser {
 
     private LineBreakToken tryParseLineBreak(String pattern, int index) {
         if (pattern.startsWith("\\n", index)) {
-            return new LineBreakToken(index + 2, false, ROW_GAP_AUTO);
+            return new LineBreakToken(index + 2, false, ROW_GAP_AUTO, "");
         }
         if (pattern.charAt(index) != '{') {
             return null;
@@ -296,10 +305,11 @@ final class ClockPatternParser {
             resetPropagation = true;
             body = body.substring(1).trim();
         }
-        if (!body.startsWith("\\n")) {
+        ArrayList<String> tokens = tokenizeShorthand(body);
+        if (tokens.isEmpty() || !tokens.get(0).startsWith("\\n")) {
             return null;
         }
-        String gapText = body.substring(2).trim();
+        String gapText = tokens.get(0).substring(2).trim();
         int gapBeforePx = ROW_GAP_AUTO;
         if (!gapText.isEmpty()) {
             try {
@@ -308,18 +318,27 @@ final class ClockPatternParser {
                 throw new IllegalArgumentException("Invalid row gap", e);
             }
         }
-        return new LineBreakToken(end + 1, resetPropagation, gapBeforePx);
+        StringBuilder trailingShorthand = new StringBuilder();
+        for (int i = 1; i < tokens.size(); i++) {
+            if (trailingShorthand.length() > 0) {
+                trailingShorthand.append(' ');
+            }
+            trailingShorthand.append(tokens.get(i));
+        }
+        return new LineBreakToken(end + 1, resetPropagation, gapBeforePx, trailingShorthand.toString());
     }
 
     private static final class LineBreakToken {
         final int endIndex;
         final boolean resetPropagation;
         final int gapBeforePx;
+        final String trailingShorthand;
 
-        LineBreakToken(int endIndex, boolean resetPropagation, int gapBeforePx) {
+        LineBreakToken(int endIndex, boolean resetPropagation, int gapBeforePx, String trailingShorthand) {
             this.endIndex = endIndex;
             this.resetPropagation = resetPropagation;
             this.gapBeforePx = gapBeforePx;
+            this.trailingShorthand = trailingShorthand != null ? trailingShorthand : "";
         }
     }
 }

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/clock/ClockPatternPreviewRenderer.java

@@ -0,0 +1,45 @@
+package se.ajpanton.statusbartweak.runtime.features.clock;
+
+import android.content.Context;
+import android.text.SpannableStringBuilder;
+import android.text.TextUtils;
+
+import java.util.ArrayList;
+
+public final class ClockPatternPreviewRenderer {
+    public static final int ROW_GAP_AUTO = ClockPatternParser.ROW_GAP_AUTO;
+    private static final ClockPatternParser PATTERN_PARSER = new ClockPatternParser();
+    private static final ClockTextRenderer TEXT_RENDERER = new ClockTextRenderer();
+
+    private ClockPatternPreviewRenderer() {
+    }
+
+    public static Result render(Context context, String pattern, int referenceColor) {
+        if (context == null || TextUtils.isEmpty(pattern)) {
+            return new Result(new ArrayList<>(), "", false);
+        }
+        ClockParsedPattern parsedPattern = PATTERN_PARSER.parse(pattern);
+        ArrayList<ClockTextRenderer.LayoutRowResult> renderedRows =
+                TEXT_RENDERER.renderLayoutRows(context, parsedPattern, referenceColor);
+        ArrayList<Row> rows = new ArrayList<>();
+        StringBuilder description = new StringBuilder();
+        for (int i = 0; i < renderedRows.size(); i++) {
+            ClockTextRenderer.LayoutRowResult row = renderedRows.get(i);
+            if (i > 0) {
+                description.append('\n');
+            }
+            description.append(row.contentDescription);
+            rows.add(new Row(row.text, row.leftText, row.rightText, row.pipeCount, row.gapBeforePx));
+        }
+        if (rows.isEmpty()) {
+            return new Result(new ArrayList<>(), "", parsedPattern.containsSeconds);
+        }
+        return new Result(rows, description.toString(), parsedPattern.containsSeconds);
+    }
+
+    public record Result(ArrayList<Row> rows, String contentDescription, boolean containsSeconds) {
+    }
+
+    public record Row(CharSequence text, CharSequence leftText, CharSequence rightText, int pipeCount, int gapBeforePx) {
+    }
+}

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/clock/DrawerClockTextController.java

@@ -28,6 +28,7 @@ import se.ajpanton.statusbartweak.runtime.mode.SceneKey;
 import se.ajpanton.statusbartweak.runtime.mode.SurfaceMode;
 import se.ajpanton.statusbartweak.runtime.settings.BroadcastReceiverSupport;
 import se.ajpanton.statusbartweak.runtime.settings.RuntimeSettingsCache;
+import se.ajpanton.statusbartweak.R;
 import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
 
 final class DrawerClockTextController {
@@ -204,6 +205,7 @@ final class DrawerClockTextController {
             return;
         }
         Role previous = trackedRoles.put(textView, role);
+        textView.setTag(R.id.sbt_debug_drawer_clock_container, role.name());
         if (previous == null || previous != role || !stockSnapshots.containsKey(textView)) {
             captureSnapshot(textView);
         }
@@ -214,6 +216,9 @@ final class DrawerClockTextController {
         stockSnapshots.remove(textView);
         renderCache.remove(textView);
         ownedTexts.remove(textView);
+        if (textView != null) {
+            textView.setTag(R.id.sbt_debug_drawer_clock_container, null);
+        }
         stopTicker(textView);
     }
 

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/clock/StockClockController.java

@@ -38,8 +38,10 @@ import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
 
 final class StockClockController {
 
-    private static final String CLOCK_CLASS_NAME =
-            "com.android.systemui.statusbar.policy.QSClockIndicatorView";
+    private static final String[] CLOCK_CLASS_NAMES = {
+            "com.android.systemui.statusbar.policy.QSClockIndicatorView",
+            "com.android.systemui.statusbar.policy.Clock"
+    };
 
     private final RuntimeContext runtimeContext;
     private final Set<TextView> trackedClocks =
@@ -64,8 +66,25 @@ final class StockClockController {
             return;
         }
         registerLayoutModeListenerIfNeeded();
-        Class<?> clockClass = ReflectionSupport.requireClass(CLOCK_CLASS_NAME, classLoader);
+        ArrayList<Class<?>> clockClasses = new ArrayList<>();
+        for (String className : CLOCK_CLASS_NAMES) {
+            Class<?> clockClass = ReflectionSupport.findClassIfExists(className, classLoader);
+            if (clockClass != null) {
+                clockClasses.add(clockClass);
+            }
+        }
+        if (clockClasses.isEmpty()) {
+            hooksInstalled = true;
+            return;
+        }
         XposedInterface framework = runtimeContext.getFramework();
+        for (Class<?> clockClass : clockClasses) {
+            hookClockClass(framework, clockClass);
+        }
+        hooksInstalled = true;
+    }
+
+    private void hookClockClass(XposedInterface framework, Class<?> clockClass) {
         XposedHookSupport.hookAllMethodsIfExists(framework, clockClass, "onAttachedToWindow", chain -> {
             Object result = chain.proceed();
             Object target = chain.getThisObject();
@@ -104,7 +123,7 @@ final class StockClockController {
             }
             return result;
         });
-        XposedHookSupport.hookAllMethods(framework, clockClass, "notifyTimeChanged", chain -> {
+        XposedHookSupport.hookAllMethodsIfExists(framework, clockClass, "notifyTimeChanged", chain -> {
             Object result = chain.proceed();
             Object target = chain.getThisObject();
             if (!(target instanceof TextView)) {
@@ -123,6 +142,14 @@ final class StockClockController {
             trackAndApply(clockView, bellSound);
             return result;
         });
+        XposedHookSupport.hookAllMethodsIfExists(framework, clockClass, "updateClock", chain -> {
+            Object result = chain.proceed();
+            Object target = chain.getThisObject();
+            if (target instanceof TextView clockView) {
+                trackAndApply(clockView, null);
+            }
+            return result;
+        });
         XposedHookSupport.hookAllMethodsIfExists(framework, clockClass, "setTextColor", chain -> {
             Object result = chain.proceed();
             if (chain.getThisObject() instanceof TextView clockView) {
@@ -137,7 +164,6 @@ final class StockClockController {
             }
             return result;
         });
-        hooksInstalled = true;
     }
 
     private void reapplyClockIfCustomOrOwned(TextView clockView) {
@@ -153,7 +179,7 @@ final class StockClockController {
         }
         runtimeContext.getModeStateRepository().addLayoutEnabledListener(enabled -> {
             if (enabled) {
-                restoreAllOwnedClocks();
+                suspendOwnedClockTickers();
             } else {
                 refreshAllClocks();
             }
@@ -162,6 +188,9 @@ final class StockClockController {
     }
 
     private void trackAndApply(TextView clockView, Object bellSound) {
+        if (isNotificationShadeDescendant(clockView)) {
+            return;
+        }
         trackedClocks.add(clockView);
         registerReceiverIfNeeded(clockView.getContext());
         if (bellSound != null) {
@@ -212,23 +241,26 @@ final class StockClockController {
         }
     }
 
-    private void removeAllRowOverlays() {
-        for (TextView clockView : new ArrayList<>(trackedClocks)) {
-            removeRowOverlay(clockView);
+    private void suspendOwnedClockTickers() {
+        for (TextView clockView : new ArrayList<>(ownedClocks)) {
+            stopTicker(clockView);
         }
     }
 
-    private void restoreAllOwnedClocks() {
-        for (TextView clockView : new ArrayList<>(trackedClocks)) {
-            restoreOwnedClock(clockView);
-        }
-        removeAllRowOverlays();
-    }
-
     private void applyClockText(TextView clockView) {
+        if (isNotificationShadeDescendant(clockView)) {
+            restoreOwnedClock(clockView);
+            return;
+        }
         SbtSettings settings = RuntimeSettingsCache.get(clockView.getContext());
         boolean layoutEnabled = settings.clockEnabled;
-        if (layoutEnabled || !hasCustomClockTextEnabled(settings)) {
+        if (layoutEnabled) {
+            if (ownedClocks.contains(clockView)) {
+                stopTicker(clockView);
+            }
+            return;
+        }
+        if (!hasCustomClockTextEnabled(settings)) {
             restoreOwnedClock(clockView);
             return;
         }
@@ -331,6 +363,18 @@ final class StockClockController {
                 || (settings.clockCustomFormatEnabled && !pattern.isEmpty());
     }
 
+    private boolean isNotificationShadeDescendant(View view) {
+        View current = view;
+        while (current != null) {
+            if (current.getClass().getName().contains("NotificationShadeWindowView")) {
+                return true;
+            }
+            Object parent = current.getParent();
+            current = parent instanceof View ? (View) parent : null;
+        }
+        return false;
+    }
+
     private void applyClockLineMode(TextView clockView) {
         clockView.setSingleLine(true);
         clockView.setHorizontallyScrolling(false);

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/misc/MiscFeature.java

@@ -1,6 +1,7 @@
 package se.ajpanton.statusbartweak.runtime.features.misc;
 
 import io.github.libxposed.api.XposedModuleInterface;
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.runtime.features.RuntimeContext;
 import se.ajpanton.statusbartweak.runtime.features.RuntimeFeature;
 
@@ -31,6 +32,9 @@ public final class MiscFeature implements RuntimeFeature {
     }
 
     private void installControllers(RuntimeContext context, ClassLoader classLoader) {
+        if (!SystemUiCapabilities.supportsSamsungAodMiscControllers()) {
+            return;
+        }
         if (aodCallVisibilityController == null) {
             aodCallVisibilityController = new AodCallVisibilityController(context);
         }

app/src/main/java/se/ajpanton/statusbartweak/runtime/features/notifications/StockUnlockedNotificationIconsController.java

@@ -43,8 +43,11 @@ final class StockUnlockedNotificationIconsController {
         if (hooksInstalled || classLoader == null) {
             return;
         }
-        Class<?> containerClass = ReflectionSupport.requireClass(CONTAINER_CLASS_NAME, classLoader);
-        XposedHookSupport.hookAllMethods(runtimeContext.getFramework(), containerClass, "onAttachedToWindow", chain -> {
+        Class<?> containerClass = ReflectionSupport.findClassIfExists(CONTAINER_CLASS_NAME, classLoader);
+        if (containerClass == null) {
+            return;
+        }
+        XposedHookSupport.hookAllMethodsIfExists(runtimeContext.getFramework(), containerClass, "onAttachedToWindow", chain -> {
             Object result = chain.proceed();
             if (chain.getThisObject() instanceof View view) {
                 if (shouldManageContainer(view)) {
@@ -54,7 +57,7 @@ final class StockUnlockedNotificationIconsController {
             }
             return result;
         });
-        XposedHookSupport.hookAllMethods(runtimeContext.getFramework(), containerClass, "calculateIconXTranslations", chain -> {
+        XposedHookSupport.hookAllMethodsIfExists(runtimeContext.getFramework(), containerClass, "calculateIconXTranslations", chain -> {
             if (chain.getThisObject() instanceof View view) {
                 if (shouldManageContainer(view)) {
                     trackContainer(view);
@@ -63,7 +66,7 @@ final class StockUnlockedNotificationIconsController {
             }
             return chain.proceed();
         });
-        XposedHookSupport.hookAllMethods(runtimeContext.getFramework(), containerClass, "onLayout", chain -> {
+        XposedHookSupport.hookAllMethodsIfExists(runtimeContext.getFramework(), containerClass, "onLayout", chain -> {
             Object result = chain.proceed();
             if (chain.getThisObject() instanceof View view) {
                 if (shouldManageContainer(view)) {
@@ -75,7 +78,7 @@ final class StockUnlockedNotificationIconsController {
             }
             return result;
         });
-        XposedHookSupport.hookAllMethods(runtimeContext.getFramework(), containerClass, "shouldForceOverflow", chain -> {
+        XposedHookSupport.hookAllMethodsIfExists(runtimeContext.getFramework(), containerClass, "shouldForceOverflow", chain -> {
             if (!(chain.getThisObject() instanceof View view)) {
                 return chain.proceed();
             }
@@ -237,6 +240,9 @@ final class StockUnlockedNotificationIconsController {
     }
 
     private boolean shouldManageContainer(View view) {
+        if (!isFeatureEnabled(view.getContext())) {
+            return false;
+        }
         if (!isUnlockedScene()) {
             return false;
         }

app/src/main/java/se/ajpanton/statusbartweak/runtime/hooks/XposedHookSupport.java

@@ -2,6 +2,7 @@ package se.ajpanton.statusbartweak.runtime.hooks;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
@@ -34,6 +35,9 @@ public final class XposedHookSupport {
             if (!methodName.equals(method.getName())) {
                 continue;
             }
+            if (Modifier.isAbstract(method.getModifiers())) {
+                continue;
+            }
             method.setAccessible(true);
             handles.add(framework.hook(method).intercept(hooker));
         }
@@ -59,6 +63,9 @@ public final class XposedHookSupport {
             if (!methodName.equals(method.getName())) {
                 continue;
             }
+            if (Modifier.isAbstract(method.getModifiers())) {
+                continue;
+            }
             method.setAccessible(true);
             handles.add(framework.hook(method).intercept(hooker));
         }
@@ -83,4 +90,20 @@ public final class XposedHookSupport {
         }
         return handles;
     }
+
+    public static List<XposedInterface.HookHandle> hookAllConstructorsIfExists(
+            XposedInterface framework,
+            Class<?> type,
+            XposedInterface.Hooker hooker
+    ) {
+        Objects.requireNonNull(framework, "framework");
+        Objects.requireNonNull(type, "type");
+        Objects.requireNonNull(hooker, "hooker");
+        List<XposedInterface.HookHandle> handles = new ArrayList<>();
+        for (Constructor<?> constructor : type.getDeclaredConstructors()) {
+            constructor.setAccessible(true);
+            handles.add(framework.hook(constructor).intercept(hooker));
+        }
+        return handles;
+    }
 }

app/src/main/java/se/ajpanton/statusbartweak/runtime/layout/DarkIconDispatcherGuard.java

@@ -33,7 +33,7 @@ final class DarkIconDispatcherGuard {
     }
 
     void install(Class<?> darkIconDispatcherClass) {
-        XposedHookSupport.hookAllConstructors(
+        XposedHookSupport.hookAllConstructorsIfExists(
                 runtimeContext.getFramework(),
                 darkIconDispatcherClass,
                 chain -> {

app/src/main/java/se/ajpanton/statusbartweak/runtime/layout/StockLayoutCanvasController.java

@@ -10,8 +10,10 @@ import android.graphics.drawable.Drawable;
 import android.os.Looper;
 import android.os.PowerManager;
 import android.service.notification.StatusBarNotification;
+import android.telecom.TelecomManager;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.WindowInsets;
 import android.widget.ImageView;
 import android.widget.TextView;
 
@@ -33,7 +35,9 @@ import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.function.Function;
 
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.runtime.NotificationKeyReflection;
+import se.ajpanton.statusbartweak.runtime.RuntimeMutationGuard;
 import se.ajpanton.statusbartweak.runtime.ViewIdNames;
 import se.ajpanton.statusbartweak.runtime.features.RuntimeContext;
 import se.ajpanton.statusbartweak.runtime.hooks.ReflectionSupport;
@@ -77,6 +81,7 @@ final class StockLayoutCanvasController {
             "entries"
     };
     private static final Set<String> TARGET_ID_NAMES = Set.of(
+            "clock",
             "left_clock_container",
             "notification_icon_area",
             "notification_icon_area_inner",
@@ -91,10 +96,12 @@ final class StockLayoutCanvasController {
 
     private static final Set<String> TARGET_CLASS_SUBSTRINGS = Set.of(
             "QSClockIndicatorView",
+            "statusbar.policy.Clock",
             "SecShelfNotificationIconContainer"
     );
 
     private static final Set<String> LAYOUT_OFF_UNLOCKED_ONLY_IDS = Set.of(
+            "clock",
             "left_clock_container",
             "notification_icon_area",
             "notification_icon_area_inner",
@@ -134,8 +141,14 @@ final class StockLayoutCanvasController {
     private final Map<View, Integer> aodBeforeDrawSignatureByRoot = new WeakHashMap<>();
     private final Set<View> trackedUnlockedStockSurfaces =
             Collections.newSetFromMap(new WeakHashMap<>());
+    private final Set<View> suppressedHiddenStatusBarRoots =
+            Collections.newSetFromMap(new WeakHashMap<>());
+    private final Set<View> privacyOverlayHiddenStatusBarRoots =
+            Collections.newSetFromMap(new WeakHashMap<>());
     private final Set<View> trackedLockedStatusBarIconSurfaces =
             Collections.newSetFromMap(new WeakHashMap<>());
+    private final Set<View> lockedStatusBarIconSurfaceReadyRoots =
+            Collections.newSetFromMap(new WeakHashMap<>());
     private final Set<View> pendingUnlockedAppearanceRefreshRoots =
             Collections.newSetFromMap(new WeakHashMap<>());
     private final Set<View> pendingUnlockedClockTextRefreshRoots =
@@ -185,6 +198,8 @@ final class StockLayoutCanvasController {
     private int notificationDrawerCloseGeneration;
     private boolean notificationDrawerClosePending;
     private int aodVisualAlphaGeneration;
+    private int systemBarRequestedVisibleTypes = WindowInsets.Type.statusBars();
+    private boolean statusBarTransientShown;
 
     StockLayoutCanvasController(RuntimeContext runtimeContext) {
         this.runtimeContext = runtimeContext;
@@ -213,10 +228,124 @@ final class StockLayoutCanvasController {
         statusIconModelTracker.installHooks(classLoader);
         installShadeExpansionHooks(classLoader);
         installShadeHeaderAnimationGuardHook(classLoader);
+        installSystemBarAttributeListener(classLoader);
+        installTransientBarListener(classLoader);
         installViewRootHook(classLoader);
         hooksInstalled = true;
     }
 
+    private void installSystemBarAttributeListener(ClassLoader classLoader) {
+        Class<?> commandQueueClass = ReflectionSupport.findClassIfExists(
+                "com.android.systemui.statusbar.CommandQueue",
+                classLoader);
+        if (commandQueueClass == null) {
+            return;
+        }
+        XposedHookSupport.hookAllMethodsIfExists(
+                runtimeContext.getFramework(),
+                commandQueueClass,
+                "onSystemBarAttributesChanged",
+                chain -> {
+                    Object result = chain.proceed();
+                    updateSystemBarRequestedVisibleTypes(chain.getArgs());
+                    return result;
+                });
+    }
+
+    private void updateSystemBarRequestedVisibleTypes(List<Object> args) {
+        if (args == null || args.size() <= 5) {
+            return;
+        }
+        Integer displayId = asInteger(args.get(0));
+        Integer requestedVisibleTypes = asInteger(args.get(5));
+        if (displayId == null || displayId != 0 || requestedVisibleTypes == null) {
+            return;
+        }
+        if (systemBarRequestedVisibleTypes == requestedVisibleTypes) {
+            return;
+        }
+        systemBarRequestedVisibleTypes = requestedVisibleTypes;
+        if (statusBarsRequestedVisible()) {
+            releaseSuppressedHiddenStatusBarRoots();
+            privacyOverlayHiddenStatusBarRoots.clear();
+        }
+    }
+
+    private void installTransientBarListener(ClassLoader classLoader) {
+        Class<?> commandQueueClass = ReflectionSupport.findClassIfExists(
+                "com.android.systemui.statusbar.CommandQueue",
+                classLoader);
+        if (commandQueueClass != null) {
+            XposedHookSupport.hookAllMethodsIfExists(
+                    runtimeContext.getFramework(),
+                    commandQueueClass,
+                    "showTransient",
+                    chain -> {
+                        Object result = chain.proceed();
+                        updateTransientBarState(chain.getArgs(), true);
+                        return result;
+                    });
+            XposedHookSupport.hookAllMethodsIfExists(
+                    runtimeContext.getFramework(),
+                    commandQueueClass,
+                    "abortTransient",
+                    chain -> {
+                        Object result = chain.proceed();
+                        updateTransientBarState(chain.getArgs(), false);
+                        return result;
+                    });
+        }
+        installStatusBarAutoHideElementListener(classLoader);
+    }
+
+    private void installStatusBarAutoHideElementListener(ClassLoader classLoader) {
+        Class<?> statusBarAutoHideElementClass = ReflectionSupport.findClassIfExists(
+                "com.android.systemui.statusbar.phone.CentralSurfacesImpl$5",
+                classLoader);
+        if (statusBarAutoHideElementClass == null) {
+            return;
+        }
+        XposedHookSupport.hookAllMethodsIfExists(
+                runtimeContext.getFramework(),
+                statusBarAutoHideElementClass,
+                "hide",
+                chain -> {
+                    Object result = chain.proceed();
+                    updateStatusBarTransientShown(false);
+                    return result;
+                });
+    }
+
+    private void updateTransientBarState(List<Object> args, boolean visible) {
+        Integer displayId = args != null && !args.isEmpty() ? asInteger(args.get(0)) : null;
+        boolean statusBarsAffected = transientArgsIncludeStatusBars(args);
+        if (displayId == null || displayId != 0 || !statusBarsAffected) {
+            return;
+        }
+        updateStatusBarTransientShown(visible);
+    }
+
+    private void updateStatusBarTransientShown(boolean shown) {
+        statusBarTransientShown = shown;
+    }
+
+    private boolean transientArgsIncludeStatusBars(List<Object> args) {
+        if (args == null || args.size() < 2) {
+            return true;
+        }
+        Object typesArg = args.get(1);
+        if (!(typesArg instanceof int[] types)) {
+            return true;
+        }
+        int statusBars = WindowInsets.Type.statusBars();
+        for (int type : types) {
+            if ((type & statusBars) != 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     private void installNotificationCollectionHooks(ClassLoader classLoader) {
         for (String className : List.of(
                 "com.android.systemui.statusbar.notification.collection.NotifCollection",
@@ -405,6 +534,13 @@ final class StockLayoutCanvasController {
             Object target = chain.getThisObject();
             Object alphaArg = firstArg(chain.getArgs());
             if (target instanceof View view && alphaArg instanceof Float alpha) {
+                rememberPrivacyOverlayHiddenStatusBarRoot(view);
+                if (shouldSuppressHiddenStatusBarRootAlpha(view, alpha)) {
+                    return null;
+                }
+                if (shouldSuppressPrivacyOverlayStatusBarAlpha(view, alpha)) {
+                    return null;
+                }
                 if (shouldSuppressConflictingShadeHeaderAlpha(view, alpha)) {
                     return null;
                 }
@@ -414,16 +550,26 @@ final class StockLayoutCanvasController {
                 if (shouldSuppressTrackedStatusChipAlpha(view, alpha)) {
                     return null;
                 }
+                if (shouldSuppressSamsungBatteryStatusChipAlpha(view, alpha)) {
+                    return null;
+                }
                 if (shouldCaptureAodVisualAlpha(view)) {
                     rememberAodPluginVisualAlpha(view, alpha);
                 }
             }
-            return chain.proceed();
+            Object result = chain.proceed();
+            if (target instanceof View view) {
+                syncUnlockedHostsFromStockStatusBar(view);
+            }
+            return result;
         });
         XposedHookSupport.hookAllMethodsIfExists(runtimeContext.getFramework(), viewClass, "setVisibility", chain -> {
             Object target = chain.getThisObject();
             Object visibilityArg = firstArg(chain.getArgs());
             if (target instanceof View view && visibilityArg instanceof Integer visibility) {
+                if (shouldSuppressSamsungBatteryStatusChipVisibility(view, visibility)) {
+                    return null;
+                }
                 if (shouldSuppressTrackedStatusChipVisibility(view, visibility)) {
                     return null;
                 }
@@ -431,6 +577,7 @@ final class StockLayoutCanvasController {
             Object result = chain.proceed();
             if (target instanceof View view && visibilityArg instanceof Integer visibility) {
                 scheduleStatusChipRefreshIfContentChanged(view);
+                syncUnlockedHostsFromStockStatusBar(view);
             }
             return result;
         });
@@ -442,7 +589,26 @@ final class StockLayoutCanvasController {
                     return null;
                 }
             }
-            return chain.proceed();
+            Object result = chain.proceed();
+            if (target instanceof View view) {
+                syncUnlockedHostsFromStockStatusBar(view);
+            }
+            return result;
+        });
+        XposedHookSupport.hookAllMethodsIfExists(runtimeContext.getFramework(), viewClass, "setTranslationX", chain -> {
+            Object target = chain.getThisObject();
+            Object translationArg = firstArg(chain.getArgs());
+            if (target instanceof View view && translationArg instanceof Float translationX) {
+                rememberPrivacyOverlayHiddenStatusBarRoot(view);
+                if (shouldSuppressPrivacyOverlayStatusBarTranslationX(view, translationX)) {
+                    return null;
+                }
+            }
+            Object result = chain.proceed();
+            if (target instanceof View view) {
+                syncUnlockedHostsFromStockStatusBar(view);
+            }
+            return result;
         });
         XposedHookSupport.hookAllMethodsIfExists(runtimeContext.getFramework(), viewClass, "layout", chain -> {
             Object target = chain.getThisObject();
@@ -459,15 +625,21 @@ final class StockLayoutCanvasController {
                         right,
                         bottom);
                 if (override != null) {
-                    return chain.proceed(new Object[]{
+                    Object result = chain.proceed(new Object[]{
                             override.left,
                             override.top,
                             override.right,
                             override.bottom
                     });
+                    syncUnlockedHostsFromStockStatusBar(view);
+                    return result;
                 }
             }
-            return chain.proceed();
+            Object result = chain.proceed();
+            if (target instanceof View view) {
+                syncUnlockedHostsFromStockStatusBar(view);
+            }
+            return result;
         });
     }
 
@@ -560,13 +732,19 @@ final class StockLayoutCanvasController {
                     });
         }
 
-        Class<?> clockClass = ReflectionSupport.findClassIfExists(
+        String[] clockClassNames = {
                 "com.android.systemui.statusbar.policy.QSClockIndicatorView",
-                classLoader);
-        if (clockClass != null) {
+                "com.android.systemui.statusbar.policy.Clock"
+        };
+        for (String className : clockClassNames) {
+            Class<?> clockClass = ReflectionSupport.findClassIfExists(className, classLoader);
+            if (clockClass == null) {
+                continue;
+            }
             hookViewAppearanceInvalidation(clockClass, "onDarkChanged");
             hookViewAppearanceInvalidation(clockClass, "setTextColor");
             hookClockTextInvalidation(clockClass, "notifyTimeChanged");
+            hookClockTextInvalidation(clockClass, "updateClock");
             hookClockTextInvalidation(clockClass, "setText");
             hookViewLayoutInvalidation(clockClass, "onLayout");
         }
@@ -1346,7 +1524,7 @@ final class StockLayoutCanvasController {
             }
             hideLockscreenCardsNotificationHost(root);
             if (activeScene.notificationDisplayStyle() == NotificationDisplayStyle.CARDS
-                    && isAodLayoutRoot(root)) {
+                    && isAodLayoutRoot(root, activeScene)) {
                 renderAodCardsNotificationStripIfNeeded(root, settings, activeScene);
             } else {
                 removeAodCardsNotificationHost(root);
@@ -1485,6 +1663,9 @@ final class StockLayoutCanvasController {
     }
 
     private void markStatusChipLifecycleDirtyIfNeeded(View view, View fallbackRoot) {
+        if (RuntimeMutationGuard.isSnapshotRenderMutation()) {
+            return;
+        }
         if (view == null || !isStatusChipCandidate(view)) {
             View root = view != null ? unlockedStatusBarRootFor(view) : fallbackRoot;
             if (deferDrawerStatusChipRefresh(root)) {
@@ -1913,12 +2094,15 @@ final class StockLayoutCanvasController {
         if (current.isUnlocked() && !previous.isUnlocked()) {
             darkIconDispatcherGuard.restoreForcedStates();
             trackedLockedStatusBarIconSurfaces.clear();
+            lockedStatusBarIconSurfaceReadyRoots.clear();
         } else if (previous.isLockscreen() && current.isAod()) {
             darkIconDispatcherGuard.restoreForcedStates();
             hideTrackedLockedStatusBarIconSurfaces(null);
+            lockedStatusBarIconSurfaceReadyRoots.clear();
         } else if (previous.isLockscreen() && !current.isLockscreen()) {
             darkIconDispatcherGuard.restoreForcedStates();
             restoreTrackedLockedStatusBarIconSurfaces(null);
+            lockedStatusBarIconSurfaceReadyRoots.clear();
         }
         boolean lockscreenEntry = current.isLockscreen();
         if (lockscreenEntry) {
@@ -1959,6 +2143,7 @@ final class StockLayoutCanvasController {
         }
         unlockedIconRenderController.clearRoot(root);
         dirtyUnlockedLayoutRoots.add(root);
+        lockedStatusBarIconSurfaceReadyRoots.remove(root);
         if (isViewThread(root)) {
             applyToRoot(root);
         } else {
@@ -2107,6 +2292,87 @@ final class StockLayoutCanvasController {
         debugBoundsOverlayController.bringToFront(root);
     }
 
+    private void syncUnlockedHostsFromStockStatusBar(View view) {
+        if (!isPhoneStatusBarRoot(view)) {
+            return;
+        }
+        View root = unlockedStatusBarRootWithUnlockedHostsFor(view);
+        if (root == null) {
+            return;
+        }
+        syncUnlockedHostsToStockStatusBar(
+                root,
+                runtimeContext.getModeStateRepository().getActiveScene());
+    }
+
+    private void syncUnlockedHostsToStockStatusBar(View root, SceneKey activeScene) {
+        if (root == null || !hasDirectUnlockedLayoutHost(root)) {
+            return;
+        }
+        if (!statusBarsRequestedVisible() && !statusBarTransientShown) {
+            ownedIconHostManager.setUnlockedHostsTransform(root, 0f, 0f, 0f);
+            return;
+        }
+        if (activeScene == null || !activeScene.isUnlocked()) {
+            ownedIconHostManager.setUnlockedHostsTransform(root, 1f, 0f, 0f);
+            return;
+        }
+        View stockStatusBar = phoneStatusBarRootIn(root);
+        if (stockStatusBar == null || stockStatusBar == root) {
+            ownedIconHostManager.setUnlockedHostsTransform(root, 1f, 0f, 0f);
+            return;
+        }
+        float alpha = stockStatusBar.getVisibility() == View.VISIBLE
+                ? clampAlpha(stockStatusBar.getAlpha())
+                : 0f;
+        float translationX = stockStatusBar.getLeft() + stockStatusBar.getTranslationX();
+        float translationY = stockStatusBar.getTop() + stockStatusBar.getTranslationY();
+        ownedIconHostManager.setUnlockedHostsTransform(
+                root,
+                alpha,
+                translationX,
+                translationY);
+    }
+
+    private View unlockedStatusBarRootWithUnlockedHostsFor(View view) {
+        View current = view;
+        while (current != null) {
+            if (isUnlockedStatusBarRoot(current) && hasDirectUnlockedLayoutHost(current)) {
+                return current;
+            }
+            Object parent = current.getParent();
+            current = parent instanceof View parentView ? parentView : null;
+        }
+        View root = view.getRootView();
+        return isUnlockedStatusBarRoot(root) && hasDirectUnlockedLayoutHost(root) ? root : null;
+    }
+
+    private View phoneStatusBarRootIn(View root) {
+        if (root == null) {
+            return null;
+        }
+        if (isPhoneStatusBarRoot(root)) {
+            return root;
+        }
+        if (!(root instanceof ViewGroup group)) {
+            return null;
+        }
+        ArrayDeque<View> queue = new ArrayDeque<>();
+        queue.add(group);
+        while (!queue.isEmpty()) {
+            View current = queue.removeFirst();
+            if (current != root && isPhoneStatusBarRoot(current)) {
+                return current;
+            }
+            if (current instanceof ViewGroup childGroup) {
+                for (int i = 0; i < childGroup.getChildCount(); i++) {
+                    queue.addLast(childGroup.getChildAt(i));
+                }
+            }
+        }
+        return null;
+    }
+
     private void applyToRootInternal(View root) {
         if (root == null) {
             return;
@@ -2114,31 +2380,29 @@ final class StockLayoutCanvasController {
         Context context = root.getContext();
         SbtSettings settings = RuntimeSettingsCache.get(context);
         boolean layoutEnabled = settings.clockEnabled;
-        boolean statusBarRoot = isUnlockedStatusBarRoot(root);
-        markDirtyIfSettingsChanged(root, settings, statusBarRoot);
-        markDirtyIfClockTimeChanged(root, settings, statusBarRoot);
         runtimeContext.getModeStateRepository().setLayoutEnabled(layoutEnabled);
-        if (!layoutEnabled) {
         updateActiveScene(root, context);
         SceneKey activeScene = runtimeContext.getModeStateRepository().getActiveScene();
+        boolean statusBarRoot = isStatusBarLayoutRoot(root, activeScene);
+        markDirtyIfSettingsChanged(root, settings, statusBarRoot);
+        markDirtyIfClockTimeChanged(root, settings, statusBarRoot);
+        if (!layoutEnabled) {
             statusIconModelTracker.updateActiveSlots(false, activeScene);
             applyLayoutOffRoot(root, settings, statusBarRoot, activeScene);
             return;
         }
         installPendingPluginClassLoaderHooks();
         layoutOffCleanedRoots.remove(root);
-        updateActiveScene(root, context);
         if (statusIconModelTracker.updateActiveSlots(
                 true,
-                runtimeContext.getModeStateRepository().getActiveScene())) {
+                activeScene)) {
             unlockedIconRenderController.clearRoot(root);
             dirtyUnlockedLayoutRoots.add(root);
         }
-        SceneKey activeScene = runtimeContext.getModeStateRepository().getActiveScene();
         boolean unlockedScene = activeScene != null && activeScene.isUnlocked();
         boolean aodScene = activeScene != null && activeScene.isAod();
         boolean rootDirty = dirtyUnlockedLayoutRoots.remove(root);
-        boolean aodLayoutRoot = aodScene && isAodLayoutRoot(root);
+        boolean aodLayoutRoot = aodScene && isAodLayoutRoot(root, activeScene);
         boolean hasAodLayoutPlan = aodScene && unlockedIconRenderController.hasLayoutPlan(root);
         boolean layoutRoot = aodScene ? aodLayoutRoot : statusBarRoot;
         if (aodScene
@@ -2219,11 +2483,14 @@ final class StockLayoutCanvasController {
                         activeScene,
                         rootDirty,
                         lockedCarrierTextSource());
-                boolean shouldShowUnlockedHosts = unlockedScene || aodScene || renderResult.shouldOwnLockscreen();
+                boolean shouldShowUnlockedHosts = unlockedScene
+                        || aodScene
+                        || (!unlockedScene && renderResult.shouldOwnLockscreen());
                 ownedIconHostManager.setUnlockedHostsVisible(root, shouldShowUnlockedHosts);
                 if (shouldShowUnlockedHosts) {
                     bringUnlockedHostsAndDebugOverlayToFront(root);
                 }
+                syncUnlockedHostsToStockStatusBar(root, activeScene);
                 syncAodOwnedHostVisualState(root, unlockedHosts);
             }
         }
@@ -2254,6 +2521,7 @@ final class StockLayoutCanvasController {
                 renderResult.layoutChanged(),
                 false,
                 activeScene);
+        hideTrackedUnlockedStockSurfaces(root);
         hideTrackedStatusChipSources(root);
         if (renderResult.chipSourcesChanged()
                 && !scanTree
@@ -2283,6 +2551,35 @@ final class StockLayoutCanvasController {
         });
     }
 
+    private void hideTrackedUnlockedStockSurfaces(View root) {
+        if (root == null || trackedUnlockedStockSurfaces.isEmpty()) {
+            return;
+        }
+        ArrayDeque<View> staleViews = new ArrayDeque<>();
+        for (View view : trackedUnlockedStockSurfaces) {
+            if (view == null || !view.isAttachedToWindow()) {
+                staleViews.add(view);
+                continue;
+            }
+            if (!isDescendantOf(view, root)) {
+                continue;
+            }
+            if (ownedIconHostManager.isOwnedHost(view)) {
+                staleViews.add(view);
+                continue;
+            }
+            if (isTrackableStatusChipSurface(view)) {
+                hideStatusChipSurface(root, view);
+            } else if (shouldHideNonChipView(view)) {
+                hideView(view, true);
+            } else {
+                restoreView(view);
+                staleViews.add(view);
+            }
+        }
+        removeStaleViews(trackedUnlockedStockSurfaces, staleViews);
+    }
+
     private void applyLayoutOffRoot(
             View root,
             SbtSettings settings,
@@ -2323,6 +2620,17 @@ final class StockLayoutCanvasController {
                 || findDirectOwnedHost(group, OwnedIconHostManager.TAG_AOD_CARDS_NOTIFICATION_HOST) != null;
     }
 
+    private boolean hasDirectUnlockedLayoutHost(View root) {
+        if (!(root instanceof ViewGroup group)) {
+            return false;
+        }
+        return findDirectOwnedHost(group, OwnedIconHostManager.TAG_UNLOCKED_STATUS_HOST) != null
+                || findDirectOwnedHost(group, OwnedIconHostManager.TAG_UNLOCKED_NOTIFICATION_HOST) != null
+                || findDirectOwnedHost(group, OwnedIconHostManager.TAG_UNLOCKED_CLOCK_HOST) != null
+                || findDirectOwnedHost(group, OwnedIconHostManager.TAG_UNLOCKED_CARRIER_HOST) != null
+                || findDirectOwnedHost(group, OwnedIconHostManager.TAG_UNLOCKED_CHIP_HOST) != null;
+    }
+
     private boolean hasLockscreenCardsNotificationHost(View root) {
         return root instanceof ViewGroup group
                 && findDirectOwnedHost(
@@ -2431,8 +2739,7 @@ final class StockLayoutCanvasController {
             }
             if (!isTrackableStatusChipSurface(view)
                     && !isTrackedHiddenStatusChipSource(root, view)) {
-                hiddenViewStates.remove(view);
-                trackedUnlockedStockSurfaces.remove(view);
+                forgetTrackedStatusChipState(view);
                 staleViews.add(view);
                 continue;
             }
@@ -2912,9 +3219,16 @@ final class StockLayoutCanvasController {
     }
 
     private void hideOrDiscoverLockedStatusBarIconSurfaces(View root) {
-        hideTrackedLockedStatusBarIconSurfaces(root);
-        if (root != null) {
-            trackAndHideLockedStatusBarIconSurfaces(root);
+        if (root != null && lockedStatusBarIconSurfaceReadyRoots.contains(root)) {
+            return;
+        }
+        boolean hasTrackedSurfacesInRoot = hideTrackedLockedStatusBarIconSurfaces(root);
+        int discovered = 0;
+        if (!hasTrackedSurfacesInRoot && root != null) {
+            discovered = trackAndHideLockedStatusBarIconSurfaces(root);
+        }
+        if (root != null && (hasTrackedSurfacesInRoot || discovered > 0)) {
+            lockedStatusBarIconSurfaceReadyRoots.add(root);
         }
     }
 
@@ -2922,30 +3236,29 @@ final class StockLayoutCanvasController {
         if (trackedLockedStatusBarIconSurfaces.isEmpty()) {
             return false;
         }
-        boolean foundInRoot = false;
+        boolean foundActiveInRoot = false;
         ArrayDeque<View> staleViews = new ArrayDeque<>();
         for (View view : trackedLockedStatusBarIconSurfaces) {
             if (view == null || !view.isAttachedToWindow()) {
                 staleViews.add(view);
                 continue;
             }
-            if (root == null || isDescendantOf(view, root)) {
-                foundInRoot = true;
-                if (isAlreadySuppressedHiddenView(view)) {
-                    continue;
-                }
-            }
+            boolean inRoot = root == null || isDescendantOf(view, root);
             if (!isLockedStatusBarIconSurface(view)) {
                 restoreView(view);
                 staleViews.add(view);
                 continue;
             }
-            if (root == null || isDescendantOf(view, root)) {
+            if (inRoot) {
+                foundActiveInRoot = true;
+                if (isAlreadySuppressedHiddenView(view)) {
+                    continue;
+                }
                 hideView(view, isCarrierView(view));
             }
         }
         removeStaleViews(trackedLockedStatusBarIconSurfaces, staleViews);
-        return foundInRoot;
+        return foundActiveInRoot;
     }
 
     private boolean isAlreadySuppressedHiddenView(View view) {
@@ -2983,6 +3296,7 @@ final class StockLayoutCanvasController {
     private boolean isTrackedStatusChipWriteTarget(View view) {
         if (view == null
                 || ownHiddenViewAlphaWriteDepth > 0
+                || RuntimeMutationGuard.isSnapshotRenderMutation()
                 || !trackedStatusChipSources.contains(view)
                 || !hiddenViewStates.containsKey(view)
                 || !view.isAttachedToWindow()
@@ -3002,6 +3316,7 @@ final class StockLayoutCanvasController {
     private boolean isStatusChipShellWriteTarget(View view) {
         if (view == null
                 || ownHiddenViewAlphaWriteDepth > 0
+                || RuntimeMutationGuard.isSnapshotRenderMutation()
                 || !view.isAttachedToWindow()
                 || !isLayoutEnabled(view.getContext())
                 || !isStatusChipShell(view)) {
@@ -3105,6 +3420,11 @@ final class StockLayoutCanvasController {
             }
         }
         removeStaleViews(trackedLockedStatusBarIconSurfaces, restoredViews);
+        if (root != null) {
+            lockedStatusBarIconSurfaceReadyRoots.remove(root);
+        } else {
+            lockedStatusBarIconSurfaceReadyRoots.clear();
+        }
     }
 
     private boolean hasTrackedStatusChipSources(View root) {
@@ -3286,6 +3606,9 @@ final class StockLayoutCanvasController {
         if (confirmedAodPluginViews.contains(view)) {
             return true;
         }
+        if (isSamsungBatteryStatusChipSurface(view)) {
+            return true;
+        }
         String idName = ViewIdNames.idName(view);
         if (TARGET_ID_NAMES.contains(idName)) {
             return true;
@@ -3300,6 +3623,164 @@ final class StockLayoutCanvasController {
         return containsAny(className, TARGET_CLASS_SUBSTRINGS);
     }
 
+    private boolean isSamsungBatteryStatusChipSurface(View view) {
+        return view != null && view.getClass().getName().contains("SamsungBatteryStatusChip");
+    }
+
+    private boolean shouldSuppressSamsungBatteryStatusChipAlpha(View view, float alpha) {
+        if (alpha <= 0f || ownHiddenViewAlphaWriteDepth > 0 || !isSamsungBatteryStatusChipSurface(view)) {
+            return false;
+        }
+        if (!shouldSuppressSamsungBatteryStatusChip(view)) {
+            return false;
+        }
+        hideView(view, true);
+        return true;
+    }
+
+    private boolean shouldSuppressSamsungBatteryStatusChipVisibility(View view, int visibility) {
+        if (visibility != View.VISIBLE
+                || ownHiddenViewAlphaWriteDepth > 0
+                || !isSamsungBatteryStatusChipSurface(view)) {
+            return false;
+        }
+        if (!shouldSuppressSamsungBatteryStatusChip(view)) {
+            return false;
+        }
+        hideView(view, true);
+        return true;
+    }
+
+    private boolean shouldSuppressSamsungBatteryStatusChip(View view) {
+        if (view == null || !view.isAttachedToWindow() || !isLayoutEnabled(view.getContext())) {
+            return false;
+        }
+        return true;
+    }
+
+    private boolean shouldSuppressHiddenStatusBarRootAlpha(View view, float alpha) {
+        boolean privacyOverlayRoot = privacyOverlayHiddenStatusBarRoots.contains(view);
+        boolean suppress = alpha > 0f
+                && ownHiddenViewAlphaWriteDepth <= 0
+                && isPhoneStatusBarRoot(view)
+                && view.isAttachedToWindow()
+                && isLayoutEnabled(view.getContext())
+                && !statusBarsRequestedVisible()
+                && (privacyOverlayRoot || !statusBarTransientShown);
+        if (suppress) {
+            suppressedHiddenStatusBarRoots.add(view);
+        }
+        return suppress;
+    }
+
+    private void rememberPrivacyOverlayHiddenStatusBarRoot(View view) {
+        if (view == null
+                || !isPhoneStatusBarRoot(view)
+                || !view.isAttachedToWindow()
+                || statusBarsRequestedVisible()
+                || !isLayoutEnabled(view.getContext())
+                || ongoingPrivacyChipInRoot(view) == null) {
+            return;
+        }
+        privacyOverlayHiddenStatusBarRoots.add(view);
+    }
+
+    private void releaseSuppressedHiddenStatusBarRoots() {
+        if (suppressedHiddenStatusBarRoots.isEmpty()) {
+            return;
+        }
+        ArrayDeque<View> staleRoots = new ArrayDeque<>();
+        for (View root : suppressedHiddenStatusBarRoots) {
+            if (root == null || !root.isAttachedToWindow()) {
+                staleRoots.add(root);
+                continue;
+            }
+            if (!isLayoutEnabled(root.getContext())) {
+                staleRoots.add(root);
+                continue;
+            }
+            Runnable restore = () -> {
+                if (root.isAttachedToWindow()
+                        && statusBarsRequestedVisible()
+                        && root.getAlpha() <= 0f) {
+                    root.setAlpha(1f);
+                }
+            };
+            if (root.getHandler() != null) {
+                root.post(restore);
+            } else {
+                restore.run();
+            }
+            staleRoots.add(root);
+        }
+        removeStaleViews(suppressedHiddenStatusBarRoots, staleRoots);
+    }
+
+    private boolean shouldSuppressPrivacyOverlayStatusBarAlpha(View view, float alpha) {
+        if (alpha >= 0.99f
+                || ownHiddenViewAlphaWriteDepth > 0
+                || !isPhoneStatusBarRoot(view)
+                || !isLayoutEnabled(view.getContext())
+                || ongoingPrivacyChipInRoot(view) == null) {
+            return false;
+        }
+        if (alpha <= 0f && !statusBarsRequestedVisible()) {
+            return false;
+        }
+        return true;
+    }
+
+    private boolean shouldSuppressPrivacyOverlayStatusBarTranslationX(View view, float translationX) {
+        if (Math.abs(translationX) < 0.5f
+                || ownHiddenViewAlphaWriteDepth > 0
+                || !isPhoneStatusBarRoot(view)
+                || !isLayoutEnabled(view.getContext())
+                || ongoingPrivacyChipInRoot(view) == null) {
+            return false;
+        }
+        return true;
+    }
+
+    private boolean statusBarsRequestedVisible() {
+        return (systemBarRequestedVisibleTypes & WindowInsets.Type.statusBars()) != 0;
+    }
+
+    private static Integer asInteger(Object value) {
+        return value instanceof Integer integer ? integer : null;
+    }
+
+    private boolean isPhoneStatusBarRoot(View view) {
+        return view != null
+                && view.getClass().getName().contains("PhoneStatusBarView");
+    }
+
+    private boolean isOngoingPrivacyChip(View view) {
+        return view != null
+                && view.getClass().getName().contains("OngoingPrivacyChip")
+                && "privacy_chip".equals(ViewIdNames.idName(view));
+    }
+
+    private View ongoingPrivacyChipInRoot(View view) {
+        View root = view != null ? view.getRootView() : null;
+        if (!(root instanceof ViewGroup group)) {
+            return null;
+        }
+        ArrayDeque<View> queue = new ArrayDeque<>();
+        queue.add(group);
+        while (!queue.isEmpty()) {
+            View current = queue.removeFirst();
+            if (isOngoingPrivacyChip(current)) {
+                return current;
+            }
+            if (current instanceof ViewGroup childGroup) {
+                for (int i = 0; i < childGroup.getChildCount(); i++) {
+                    queue.addLast(childGroup.getChildAt(i));
+                }
+            }
+        }
+        return null;
+    }
+
     private boolean isStatusChipSource(View view) {
         if (view == null || view.getVisibility() != View.VISIBLE) {
             return false;
@@ -3340,6 +3821,9 @@ final class StockLayoutCanvasController {
         if (view == null || ownedIconHostManager.isOwnedHost(view)) {
             return false;
         }
+        if (view.getVisibility() != View.VISIBLE) {
+            return false;
+        }
         String idName = ViewIdNames.idName(view);
         if (!"ongoing_activity_capsule".equals(idName)) {
             return false;
@@ -3368,9 +3852,26 @@ final class StockLayoutCanvasController {
                 || !isStatusChipCandidate(view)) {
             return false;
         }
+        if (isCallStatusChip(view)
+                && view.getVisibility() != View.VISIBLE
+                && !isPhoneCallActive(view)) {
+            return false;
+        }
         return hasVisibleStatusChipContent(view);
     }
 
+    private boolean isPhoneCallActive(View view) {
+        if (view == null || view.getContext() == null) {
+            return false;
+        }
+        try {
+            TelecomManager telecomManager = view.getContext().getSystemService(TelecomManager.class);
+            return telecomManager != null && telecomManager.isInCall();
+        } catch (RuntimeException ignored) {
+            return false;
+        }
+    }
+
     private boolean hasVisibleStatusChipContent(View source) {
         if (!(source instanceof ViewGroup group)) {
             return false;
@@ -4186,11 +4687,19 @@ final class StockLayoutCanvasController {
                 || isStatusChipShell(view)) {
             return false;
         }
-        hiddenViewStates.remove(view);
+        forgetTrackedStatusChip(view);
+        return true;
+    }
+
+    private void forgetTrackedStatusChip(View view) {
+        forgetTrackedStatusChipState(view);
         trackedStatusChipSources.remove(view);
+    }
+
+    private void forgetTrackedStatusChipState(View view) {
+        hiddenViewStates.remove(view);
         trackedUnlockedStockSurfaces.remove(view);
         statusChipLifecycleLayoutSignatureByView.remove(view);
-        return true;
     }
 
     private void cleanupLayoutOffRoot(View root, SceneKey activeScene) {
@@ -4200,6 +4709,7 @@ final class StockLayoutCanvasController {
         }
         clearTrackedStatusChipState();
         trackedLockedStatusBarIconSurfaces.clear();
+        lockedStatusBarIconSurfaceReadyRoots.clear();
         trackedUnlockedStockSurfaces.clear();
         confirmedAodPluginViews.clear();
         aodPluginVisualAlphaByView.clear();
@@ -4637,8 +5147,9 @@ final class StockLayoutCanvasController {
             View root,
             SceneKey activeScene
     ) {
-        if (!isUnlockedStatusBarRoot(root)
-                && !(activeScene != null && activeScene.isAod() && isAodLayoutRoot(root))) {
+        if (!isStatusBarLayoutRoot(root, activeScene)
+                && !(activeScene != null && activeScene.isAod()
+                && isAodLayoutRoot(root, activeScene))) {
             return null;
         }
         if (activeScene != null
@@ -4694,11 +5205,30 @@ final class StockLayoutCanvasController {
                 || className.contains("StatusBarWindowView");
     }
 
+    private boolean isStatusBarLayoutRoot(View root, SceneKey activeScene) {
+        return isUnlockedStatusBarRoot(root)
+                || (activeScene != null
+                && activeScene.isLockscreen()
+                && isNotificationShadeWindowRoot(root)
+                && SystemUiCapabilities.supportsLockscreenShadeWindowRoot());
+    }
+
     private void updateActiveScene(View root, Context context) {
         if (root == null) {
             return;
         }
         if (runtimeContext.getModeStateRepository().hasSystemUiStatusBarState()) {
+            if (isNotificationShadeWindowRoot(root)
+                    && isKeyguardLocked(context)
+                    && !runtimeContext.getModeStateRepository().isKeyguardGoingAway()) {
+                NotificationDisplayStyle notificationStyle =
+                        SystemNotificationDisplayStyleDetector.read(context);
+                if (isInteractive(context)) {
+                    runtimeContext.getModeStateRepository().setLockscreen(notificationStyle);
+                } else {
+                    runtimeContext.getModeStateRepository().setAod(notificationStyle);
+                }
+            }
             return;
         }
         NotificationDisplayStyle notificationStyle =
@@ -4721,7 +5251,24 @@ final class StockLayoutCanvasController {
     }
 
     private boolean isAodLayoutRoot(View root) {
-        return isAodRoot(root) || hasConfirmedAodPluginDescendant(root);
+        return isAodLayoutRoot(root, null);
+    }
+
+    private boolean isAodLayoutRoot(View root, SceneKey activeScene) {
+        return isAodRoot(root)
+                || hasConfirmedAodPluginDescendant(root)
+                || isExperimentalAodStatusBarRoot(root, activeScene);
+    }
+
+    private boolean isExperimentalAodStatusBarRoot(View root, SceneKey activeScene) {
+        if (root == null
+                || activeScene == null
+                || !activeScene.isAod()
+                || !isUnlockedStatusBarRoot(root)) {
+            return false;
+        }
+        SbtSettings settings = RuntimeSettingsCache.get(root.getContext());
+        return SystemUiCapabilities.supportsExperimentalGenericAodStatusbarRoot(settings);
     }
 
     private boolean hasConfirmedAodPluginDescendant(View root) {

app/src/main/java/se/ajpanton/statusbartweak/runtime/mode/ModeStateRepository.java

@@ -10,6 +10,7 @@ public final class ModeStateRepository {
     private SceneKey activeScene = SceneKey.unlocked();
     private boolean systemUiStatusBarStateKnown;
     private int systemUiStatusBarState;
+    private boolean keyguardGoingAway;
     private boolean layoutEnabled;
     private final List<LayoutEnabledListener> layoutEnabledListeners = new ArrayList<>();
     private final List<SceneListener> sceneListeners = new ArrayList<>();
@@ -27,6 +28,14 @@ public final class ModeStateRepository {
         return systemUiStatusBarStateKnown && systemUiStatusBarState == 2;
     }
 
+    public synchronized boolean isKeyguardGoingAway() {
+        return keyguardGoingAway;
+    }
+
+    public synchronized void setKeyguardGoingAway(boolean goingAway) {
+        keyguardGoingAway = goingAway;
+    }
+
     public synchronized boolean isLayoutEnabled() {
         return layoutEnabled;
     }

app/src/main/java/se/ajpanton/statusbartweak/runtime/mode/SystemUiStatusBarStateFeature.java

@@ -23,8 +23,10 @@ public final class SystemUiStatusBarStateFeature implements RuntimeFeature {
             "com.android.systemui.statusbar.StatusBarStateControllerImpl";
     private static final String CLASS_KEYGUARD_STATE_CONTROLLER =
             "com.android.systemui.statusbar.policy.KeyguardStateControllerImpl";
+    private static final int STATE_SHADE = 0;
 
     private boolean installed;
+    private boolean keyguardGoingAway;
 
     @Override
     public String getName() {
@@ -78,8 +80,14 @@ public final class SystemUiStatusBarStateFeature implements RuntimeFeature {
                 "notifyKeyguardGoingAway",
                 chain -> {
                     Object result = chain.proceed();
-                    if (firstBooleanArg(chain.getArgs())) {
+                    Boolean goingAway = firstBooleanArg(chain.getArgs());
+                    if (Boolean.TRUE.equals(goingAway)) {
+                        keyguardGoingAway = true;
+                        context.getModeStateRepository().setKeyguardGoingAway(true);
                         context.getModeStateRepository().setUnlocked();
+                    } else if (Boolean.FALSE.equals(goingAway)) {
+                        keyguardGoingAway = false;
+                        context.getModeStateRepository().setKeyguardGoingAway(false);
                     }
                     return result;
                 });
@@ -92,14 +100,24 @@ public final class SystemUiStatusBarStateFeature implements RuntimeFeature {
         Object rawState = ReflectionSupport.getFieldValue(controller, "mState");
         int state = rawState instanceof Integer integer ? integer : 0;
         boolean dozing = ReflectionSupport.getBooleanField(controller, "mIsDozing", false);
+        if (keyguardGoingAway && !dozing) {
+            if (state == STATE_SHADE) {
+                keyguardGoingAway = false;
+                context.getModeStateRepository().setKeyguardGoingAway(false);
+            } else {
+                state = STATE_SHADE;
+            }
+        }
         context.getModeStateRepository().setSystemUiStatusBarState(
                 state,
                 dozing,
                 SystemNotificationDisplayStyleDetector.read(systemContext(controller)));
     }
 
-    private boolean firstBooleanArg(List<Object> args) {
-        return args != null && !args.isEmpty() && Boolean.TRUE.equals(args.get(0));
+    private Boolean firstBooleanArg(List<Object> args) {
+        return args != null && !args.isEmpty() && args.get(0) instanceof Boolean bool
+                ? bool
+                : null;
     }
 
     private Context systemContext(Object controller) {

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/DebugBoundsOverlayController.java

@@ -94,6 +94,12 @@ public final class DebugBoundsOverlayController {
                     OwnedIconHostManager.TAG_UNLOCKED_CLOCK_HOST,
                     COLOR_CLOCK,
                     specs);
+            addTaggedDescendantSpecs(
+                    root,
+                    parent,
+                    R.id.sbt_debug_drawer_clock_container,
+                    COLOR_CLOCK,
+                    specs);
         }
         if (layoutEnabled && settings.debugVisualizeChipContainer) {
             addHostContainerSpecs(
@@ -148,6 +154,9 @@ public final class DebugBoundsOverlayController {
         result = 31 * result + hostSignature(root, OwnedIconHostManager.TAG_UNLOCKED_NOTIFICATION_HOST);
         result = 31 * result + hostSignature(root, OwnedIconHostManager.TAG_UNLOCKED_STATUS_HOST);
         result = 31 * result + hostSignature(root, OwnedIconHostManager.TAG_UNLOCKED_CLOCK_HOST);
+        if (settings.debugVisualizeClockContainer) {
+            result = 31 * result + taggedDescendantSignature(root, root, R.id.sbt_debug_drawer_clock_container);
+        }
         result = 31 * result + hostSignature(root, OwnedIconHostManager.TAG_UNLOCKED_CHIP_HOST);
         return result;
     }
@@ -403,6 +412,30 @@ public final class DebugBoundsOverlayController {
         }
     }
 
+    private void addTaggedDescendantSpecs(
+            View root,
+            View view,
+            int tagKey,
+            int color,
+            ArrayList<OverlaySpec> specs
+    ) {
+        if (root == null || view == null || specs == null) {
+            return;
+        }
+        if (view.getTag(tagKey) != null && view.getVisibility() != View.GONE) {
+            Bounds bounds = boundsRelativeTo(root, view);
+            if (bounds != null && bounds.width > 0 && bounds.height > 0) {
+                specs.add(new OverlaySpec(bounds, color));
+            }
+        }
+        if (!(view instanceof ViewGroup group)) {
+            return;
+        }
+        for (int i = 0; i < group.getChildCount(); i++) {
+            addTaggedDescendantSpecs(root, group.getChildAt(i), tagKey, color, specs);
+        }
+    }
+
     private OverlayView ensureOverlay(ViewGroup parent) {
         View existing = findDirectTaggedChild(parent, TAG_OVERLAY_HOST);
         if (existing instanceof OverlayView overlayView) {
@@ -493,6 +526,24 @@ public final class DebugBoundsOverlayController {
         return result;
     }
 
+    private int taggedDescendantSignature(View root, View view, int tagKey) {
+        if (root == null || view == null) {
+            return 0;
+        }
+        int result = 17;
+        Object tag = view.getTag(tagKey);
+        if (tag != null && view.getVisibility() != View.GONE) {
+            result = 31 * result + signature(boundsRelativeTo(root, view));
+            result = 31 * result + tag.hashCode();
+        }
+        if (view instanceof ViewGroup group) {
+            for (int i = 0; i < group.getChildCount(); i++) {
+                result = 31 * result + taggedDescendantSignature(root, group.getChildAt(i), tagKey);
+            }
+        }
+        return result;
+    }
+
     private Bounds boundsRelativeTo(View root, View view) {
         if (root == null || view == null) {
             return null;

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/EffectiveCutoutSupport.java

@@ -0,0 +1,85 @@
+package se.ajpanton.statusbartweak.runtime.render;
+
+import android.graphics.Rect;
+import android.view.DisplayCutout;
+import android.view.View;
+import android.view.WindowInsets;
+
+import java.util.Objects;
+import java.util.WeakHashMap;
+
+import se.ajpanton.statusbartweak.shell.settings.ClockCameraTypeSupport;
+import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
+
+final class EffectiveCutoutSupport {
+    private static final WeakHashMap<View, CameraTypeCache> CAMERA_TYPE_BY_ROOT = new WeakHashMap<>();
+
+    private EffectiveCutoutSupport() {
+    }
+
+    static Rect middleCutout(View root, SbtSettings settings, boolean ignoreUnderDisplayCamera) {
+        Rect cutout = ViewGeometry.middleCutout(root);
+        if (cutout == null || !ignoreUnderDisplayCamera) {
+            return cutout;
+        }
+        String effectiveType = effectiveCameraType(root, cutout, settings);
+        return ClockCameraTypeSupport.TYPE_UDC.equals(effectiveType) ? null : cutout;
+    }
+
+    static Rect layoutMiddleCutout(View root, SbtSettings settings) {
+        return middleCutout(
+                root,
+                settings,
+                settings != null && settings.layoutIgnoreUnderDisplayCameras);
+    }
+
+    static Rect clockMiddleCutout(View root, SbtSettings settings) {
+        return middleCutout(
+                root,
+                settings,
+                settings != null && settings.clockIgnoreUnderDisplayCameras);
+    }
+
+    private static String effectiveCameraType(View root, Rect cutout, SbtSettings settings) {
+        int signature = cameraTypeSignature(root, cutout, settings);
+        CameraTypeCache cached = CAMERA_TYPE_BY_ROOT.get(root);
+        if (cached != null && cached.signature == signature) {
+            return cached.effectiveType;
+        }
+        WindowInsets insets = root != null ? root.getRootWindowInsets() : null;
+        DisplayCutout displayCutout = insets != null ? insets.getDisplayCutout() : null;
+        ClockCameraTypeSupport.CameraInfo cameraInfo =
+                ClockCameraTypeSupport.resolveCameraInfo(root, displayCutout, settings);
+        String effectiveType = cameraInfo.effectiveType;
+        if (root != null) {
+            SbtSettings.setClockCameraDebugState(
+                    root.getContext(),
+                    cameraInfo.cameraId,
+                    cameraInfo.automaticType,
+                    cameraInfo.effectiveType);
+        }
+        CAMERA_TYPE_BY_ROOT.put(root, new CameraTypeCache(signature, effectiveType));
+        return effectiveType;
+    }
+
+    private static int cameraTypeSignature(View root, Rect cutout, SbtSettings settings) {
+        return Objects.hash(
+                root != null ? root.getWidth() : 0,
+                root != null ? root.getHeight() : 0,
+                cutout != null ? cutout.left : 0,
+                cutout != null ? cutout.top : 0,
+                cutout != null ? cutout.right : 0,
+                cutout != null ? cutout.bottom : 0,
+                settings != null ? settings.clockCameraTypeOverrides : null);
+    }
+
+    private static final class CameraTypeCache {
+        final int signature;
+        final String effectiveType;
+
+        CameraTypeCache(int signature, String effectiveType) {
+            this.signature = signature;
+            this.effectiveType = effectiveType;
+        }
+    }
+}

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/OwnedIconHostManager.java

@@ -119,6 +119,17 @@ public final class OwnedIconHostManager {
         }
     }
 
+    public void setUnlockedHostsTransform(
+            View root,
+            float alpha,
+            float translationX,
+            float translationY
+    ) {
+        for (String tag : UNLOCKED_HOST_ORDER) {
+            setHostTransform(root, tag, alpha, translationX, translationY);
+        }
+    }
+
     public void bringUnlockedHostsToFront(View root) {
         if (!(root instanceof ViewGroup parent)) {
             return;
@@ -169,6 +180,31 @@ public final class OwnedIconHostManager {
         }
     }
 
+    private void setHostTransform(
+            View root,
+            String tag,
+            float alpha,
+            float translationX,
+            float translationY
+    ) {
+        if (!(root instanceof ViewGroup parent) || tag == null) {
+            return;
+        }
+        FrameLayout host = findDirectHost(parent, tag);
+        if (host == null) {
+            return;
+        }
+        if (host.getAlpha() != alpha) {
+            host.setAlpha(alpha);
+        }
+        if (host.getTranslationX() != translationX) {
+            host.setTranslationX(translationX);
+        }
+        if (host.getTranslationY() != translationY) {
+            host.setTranslationY(translationY);
+        }
+    }
+
     private ArrayList<View> unlockedHosts(ViewGroup parent) {
         ArrayList<View> hosts = new ArrayList<>();
         for (String tag : UNLOCKED_HOST_ORDER) {

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/SnapshotIconFilter.java

@@ -34,6 +34,10 @@ final class SnapshotIconFilter {
         }
         ArrayList<SnapshotPlacement> filtered = new ArrayList<>(placements.size());
         for (SnapshotPlacement placement : placements) {
+            if (isChargingBatteryChipPlacement(placement)) {
+                filtered.add(placement);
+                continue;
+            }
             if (!isStatusBlocked(placement, settings.systemIconBlockedModes, mode)) {
                 filtered.add(placement);
             }
@@ -109,6 +113,11 @@ final class SnapshotIconFilter {
         return false;
     }
 
+    private static boolean isChargingBatteryChipPlacement(SnapshotPlacement placement) {
+        return placement != null
+                && SnapshotKeys.CHARGING_BATTERY_CHIP.equals(placement.key);
+    }
+
     private static AppIconRules.ExceptionRule matchingExceptionRule(
             SnapshotPlacement placement,
             ArrayList<AppIconRules.ExceptionRule> rules

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/SnapshotModels.java

@@ -36,6 +36,7 @@ final class SnapshotKeys {
     static final String OVERFLOW_DOT = "statusbartweak:overflow_dot";
     static final String EMPTY_CHIP = "statusbartweak:empty_chip";
     static final String EMPTY_ICON_CONTAINER = "statusbartweak:empty_icon_container";
+    static final String CHARGING_BATTERY_CHIP = "statusbartweak:charging_battery_chip";
 
     private SnapshotKeys() {
     }

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/SnapshotRenderer.java

@@ -1,15 +1,20 @@
 package se.ajpanton.statusbartweak.runtime.render;
 
 import android.content.Context;
+import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
+import android.graphics.Path;
 import android.graphics.PorterDuff;
 import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.AnimationDrawable;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
+import android.os.BatteryManager;
 import android.text.TextUtils;
 import android.os.SystemClock;
 import android.view.View;
@@ -31,9 +36,11 @@ import java.util.Objects;
 import java.util.WeakHashMap;
 
 import se.ajpanton.statusbartweak.runtime.NotificationKeyReflection;
+import se.ajpanton.statusbartweak.runtime.RuntimeMutationGuard;
 import se.ajpanton.statusbartweak.runtime.ViewIdNames;
 import se.ajpanton.statusbartweak.runtime.hooks.ReflectionSupport;
 import se.ajpanton.statusbartweak.runtime.layoutsolver.StatusBarLayoutSolver.Bounds;
+import se.ajpanton.statusbartweak.runtime.settings.BroadcastReceiverSupport;
 
 final class SnapshotRenderer {
     private static final long TRANSITION_SIGNAL_HOLD_MS = 700L;
@@ -233,9 +240,24 @@ final class SnapshotRenderer {
                 proxy.setTag(key);
                 proxyChanged = true;
             }
+            SnapshotRenderState desiredState = renderStateFor(placement);
+            Drawable animatedDrawable = animatedNotificationDrawable(placement);
+            if (animatedDrawable != null) {
+                SnapshotRenderState currentState = statesByProxy.get(proxy);
+                boolean drawableChanged = !(proxy.getDrawable() instanceof AnimationDrawable)
+                        || !canReuseAnimatedProxy(currentState, desiredState);
+                if (drawableChanged) {
+                    Drawable proxyDrawable = newDrawableInstance(animatedDrawable);
+                    proxy.setImageDrawable(proxyDrawable);
+                    proxyChanged = true;
+                }
+                startAnimationIfNeeded(proxy.getDrawable());
+                if (!desiredState.equals(currentState)) {
+                    statesByProxy.put(proxy, desiredState);
+                }
+            } else {
                 BitmapResult bitmapResult = bitmapFor(proxy, bounds);
                 Bitmap bitmap = bitmapResult.bitmap();
-            SnapshotRenderState desiredState = renderStateFor(placement);
                 boolean bitmapChanged = bitmapResult.created()
                         || !desiredState.equals(statesByProxy.get(proxy));
                 if (bitmapChanged) {
@@ -263,6 +285,7 @@ final class SnapshotRenderer {
                     proxy.setImageBitmap(bitmap);
                     proxyChanged = true;
                 }
+            }
             if (proxy.getAlpha() != 1f) {
                 proxy.setAlpha(1f);
                 proxyChanged = true;
@@ -299,6 +322,52 @@ final class SnapshotRenderer {
         return renderedBounds;
     }
 
+    private boolean canReuseAnimatedProxy(
+            SnapshotRenderState currentState,
+            SnapshotRenderState desiredState
+    ) {
+        return currentState != null
+                && desiredState != null
+                && Objects.equals(currentState.key(), desiredState.key())
+                && currentState.width() == desiredState.width()
+                && currentState.height() == desiredState.height()
+                && currentState.signal() == desiredState.signal()
+                && currentState.overflowDot() == desiredState.overflowDot()
+                && currentState.overflowDotColor() == desiredState.overflowDotColor()
+                && currentState.sourceOffsetX() == desiredState.sourceOffsetX()
+                && currentState.sourceRenderBoundsSignature() == desiredState.sourceRenderBoundsSignature()
+                && Objects.equals(currentState.heldSignalKey(), desiredState.heldSignalKey())
+                && currentState.heldBitmapId() == desiredState.heldBitmapId()
+                && currentState.sourceMode() == desiredState.sourceMode()
+                && currentState.tintSignature() == desiredState.tintSignature();
+    }
+
+    private Drawable animatedNotificationDrawable(SnapshotPlacement placement) {
+        if (placement == null
+                || placement.source() == null
+                || placement.source().mode() != SnapshotMode.NOTIFICATION_DRAWABLE
+                || !(placement.source().view() instanceof ImageView imageView)) {
+            return null;
+        }
+        Drawable drawable = imageView.getDrawable();
+        return drawable instanceof AnimationDrawable ? drawable : null;
+    }
+
+    private Drawable newDrawableInstance(Drawable drawable) {
+        Drawable.ConstantState constantState = drawable != null ? drawable.getConstantState() : null;
+        if (constantState != null) {
+            return constantState.newDrawable().mutate();
+        }
+        return drawable != null ? drawable.mutate() : null;
+    }
+
+    private void startAnimationIfNeeded(Drawable drawable) {
+        if (drawable instanceof AnimationDrawable animationDrawable && !animationDrawable.isRunning()) {
+            animationDrawable.setVisible(true, true);
+            animationDrawable.start();
+        }
+    }
+
     void clear(ViewGroup host) {
         LinkedHashMap<String, ImageView> proxies = proxiesByHost.remove(host);
         if (proxies == null) {
@@ -336,6 +405,7 @@ final class SnapshotRenderer {
     private boolean shouldTrimContent(SnapshotSource source) {
         return trimViewContentForCollision
                 && source != null
+                && !SnapshotKeys.CHARGING_BATTERY_CHIP.equals(source.keyHint())
                 && (source.mode() == SnapshotMode.VIEW || source.mode() == SnapshotMode.STATUS_CHIP);
     }
 
@@ -713,6 +783,10 @@ final class SnapshotRenderer {
         if (offsetX != 0) {
             canvas.translate(-offsetX, 0);
         }
+        if (isChargingBatteryChipSource(source)) {
+            drawChargingBatteryChip(source, bitmap);
+            return;
+        }
         View sourceView = source.view();
         if (sourceView == null) {
             return;
@@ -738,6 +812,8 @@ final class SnapshotRenderer {
                             bitmap.getHeight())) {
                 return;
             }
+            RuntimeMutationGuard.enterSnapshotRenderMutation();
+            try {
                 sourceView.setVisibility(View.VISIBLE);
                 sourceView.setAlpha(1f);
                 if (source.mode() == SnapshotMode.STATUS_CHIP) {
@@ -746,8 +822,16 @@ final class SnapshotRenderer {
                     sourceView.draw(canvas);
                 }
             } finally {
+                RuntimeMutationGuard.exitSnapshotRenderMutation();
+            }
+        } finally {
+            RuntimeMutationGuard.enterSnapshotRenderMutation();
+            try {
                 sourceView.setAlpha(oldAlpha);
                 sourceView.setVisibility(oldVisibility);
+            } finally {
+                RuntimeMutationGuard.exitSnapshotRenderMutation();
+            }
         }
     }
 
@@ -823,6 +907,152 @@ final class SnapshotRenderer {
                 && source.mode() != SnapshotMode.STATUS_CHIP;
     }
 
+    private boolean isChargingBatteryChipSource(SnapshotSource source) {
+        return source != null && SnapshotKeys.CHARGING_BATTERY_CHIP.equals(source.keyHint());
+    }
+
+    private void drawChargingBatteryChip(SnapshotSource source, Bitmap bitmap) {
+        if (source == null
+                || bitmap == null
+                || bitmap.isRecycled()
+                || bitmap.getWidth() <= 0
+                || bitmap.getHeight() <= 0) {
+            return;
+        }
+        bitmap.eraseColor(Color.TRANSPARENT);
+        int width = bitmap.getWidth();
+        int height = bitmap.getHeight();
+        float inset = Math.max(1f, height * 0.05f);
+        RectF pill = new RectF(inset, inset, width - inset, height - inset);
+        float radius = pill.height() / 2f;
+        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
+        paint.setColor(Color.argb(235, 42, 45, 49));
+        Canvas canvas = new Canvas(bitmap);
+        canvas.drawRoundRect(pill, radius, radius, paint);
+
+        int level = chargingBatteryLevel(source.view());
+        float gaugeWidth = Math.min(pill.width(), Math.max(height * 1.35f, pill.width() * 0.42f));
+        float fillRight = pill.left + gaugeWidth * Math.max(0f, Math.min(100f, level)) / 100f;
+        if (fillRight > pill.left) {
+            Path clip = new Path();
+            clip.addRoundRect(pill, radius, radius, Path.Direction.CW);
+            int save = canvas.save();
+            canvas.clipPath(clip);
+            paint.setColor(Color.rgb(42, 220, 103));
+            canvas.drawRect(pill.left, pill.top, fillRight, pill.bottom, paint);
+            canvas.restoreToCount(save);
+        }
+
+        paint.setStyle(Paint.Style.STROKE);
+        paint.setStrokeWidth(Math.max(1f, height * 0.035f));
+        paint.setColor(Color.argb(120, 255, 255, 255));
+        canvas.drawRoundRect(pill, radius, radius, paint);
+        paint.setStyle(Paint.Style.FILL);
+
+        drawChargingBolt(canvas, paint, pill.left + height * 0.48f, height / 2f, height * 0.55f);
+
+        String text = chargingBatteryText(source.view(), level);
+        paint.setTextAlign(Paint.Align.RIGHT);
+        paint.setFakeBoldText(true);
+        paint.setColor(Color.WHITE);
+        paint.setTextSize(Math.max(1f, height * 0.42f));
+        Paint.FontMetrics metrics = paint.getFontMetrics();
+        float baseline = height / 2f - (metrics.ascent + metrics.descent) / 2f;
+        canvas.drawText(text, pill.right - Math.max(2f, height * 0.18f), baseline, paint);
+        paint.setFakeBoldText(false);
+    }
+
+    private void drawChargingBolt(Canvas canvas, Paint paint, float centerX, float centerY, float size) {
+        float half = size / 2f;
+        Path bolt = new Path();
+        bolt.moveTo(centerX + half * 0.10f, centerY - half);
+        bolt.lineTo(centerX - half * 0.42f, centerY + half * 0.08f);
+        bolt.lineTo(centerX - half * 0.04f, centerY + half * 0.08f);
+        bolt.lineTo(centerX - half * 0.18f, centerY + half);
+        bolt.lineTo(centerX + half * 0.44f, centerY - half * 0.18f);
+        bolt.lineTo(centerX + half * 0.04f, centerY - half * 0.18f);
+        bolt.close();
+        paint.setColor(Color.WHITE);
+        paint.setStyle(Paint.Style.FILL);
+        canvas.drawPath(bolt, paint);
+    }
+
+    private String chargingBatteryText(View source, int fallbackLevel) {
+        CharSequence text = findChargingBatteryText(source);
+        if (text != null && text.length() > 0) {
+            return text.toString();
+        }
+        return Math.max(0, Math.min(100, fallbackLevel)) + "%";
+    }
+
+    private int chargingBatteryLevel(View source) {
+        CharSequence text = findChargingBatteryText(source);
+        int parsed = parsePercent(text);
+        if (parsed >= 0) {
+            return parsed;
+        }
+        Integer stickyLevel = stickyBatteryLevel(source != null ? source.getContext() : null);
+        return stickyLevel != null ? stickyLevel : 100;
+    }
+
+    private Integer stickyBatteryLevel(Context context) {
+        if (context == null) {
+            return null;
+        }
+        Intent intent = BroadcastReceiverSupport.readExportedSticky(
+                context,
+                BroadcastReceiverSupport.filter(Intent.ACTION_BATTERY_CHANGED));
+        if (intent == null) {
+            return null;
+        }
+        int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
+        int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100);
+        if (level < 0 || scale <= 0) {
+            return null;
+        }
+        return Math.max(0, Math.min(100, Math.round(level * 100f / scale)));
+    }
+
+    private CharSequence findChargingBatteryText(View source) {
+        if (source == null) {
+            return null;
+        }
+        if (source instanceof TextView textView) {
+            CharSequence text = textView.getText();
+            if (parsePercent(text) >= 0) {
+                return text;
+            }
+        }
+        if (!(source instanceof ViewGroup group)) {
+            return null;
+        }
+        for (int i = 0; i < group.getChildCount(); i++) {
+            CharSequence text = findChargingBatteryText(group.getChildAt(i));
+            if (text != null && text.length() > 0) {
+                return text;
+            }
+        }
+        return null;
+    }
+
+    private int parsePercent(CharSequence text) {
+        if (text == null) {
+            return -1;
+        }
+        int value = 0;
+        boolean found = false;
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+            if (c >= '0' && c <= '9') {
+                value = value * 10 + c - '0';
+                found = true;
+            } else if (found) {
+                break;
+            }
+        }
+        return found ? Math.max(0, Math.min(100, value)) : -1;
+    }
+
     private boolean isTintableMonochrome(Bitmap bitmap) {
         int coloredPixels = 0;
         int monochromePixels = 0;
@@ -1027,7 +1257,9 @@ final class SnapshotRenderer {
                 view.getRight(),
                 view.getBottom(),
                 view.getMeasuredWidth(),
-                view.getMeasuredHeight()));
+                view.getMeasuredHeight(),
+                view.getVisibility(),
+                view.getAlpha()));
         if (view instanceof ViewGroup group) {
             for (int i = 0; i < group.getChildCount(); i++) {
                 captureFrameState(group.getChildAt(i), state);
@@ -1051,6 +1283,12 @@ final class SnapshotRenderer {
                         View.MeasureSpec.makeMeasureSpec(frame.measuredHeight, View.MeasureSpec.EXACTLY));
             }
             view.layout(frame.left, frame.top, frame.right, frame.bottom);
+            if (view.getAlpha() != frame.alpha) {
+                view.setAlpha(frame.alpha);
+            }
+            if (view.getVisibility() != frame.visibility) {
+                view.setVisibility(frame.visibility);
+            }
         }
     }
 
@@ -1065,7 +1303,9 @@ final class SnapshotRenderer {
             int right,
             int bottom,
             int measuredWidth,
-            int measuredHeight
+            int measuredHeight,
+            int visibility,
+            float alpha
     ) {
     }
 

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/UnlockedChipPlacementController.java

@@ -21,6 +21,10 @@ final class UnlockedChipPlacementController {
     }
 
     void clear() {
+        resetMissingChipFallback();
+    }
+
+    private void resetMissingChipFallback() {
         heldPlacements = null;
         lastCollisionBounds = null;
         lastRootWidth = 0;
@@ -47,10 +51,11 @@ final class UnlockedChipPlacementController {
             return rawPlacements;
         }
 
-        ArrayList<SnapshotPlacement> placements = isAnyChipHidingEnabled(settings)
+        boolean hasMetricSources = metricSources != null && !metricSources.isEmpty();
+        ArrayList<SnapshotPlacement> placements = isAnyChipHidingEnabled(settings) || !hasMetricSources
                 ? new ArrayList<>()
                 : heldPlacements(root);
-        if (placements.isEmpty()) {
+        if (placements.isEmpty() && hasMetricSources) {
             placements = emptyPlacement(root, metricSources);
         }
         return placements;

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/UnlockedIconSnapshotRenderController.java

@@ -1,5 +1,7 @@
 package se.ajpanton.statusbartweak.runtime.render;
 
+import android.app.KeyguardManager;
+import android.content.Context;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.TextView;
@@ -8,6 +10,7 @@ import java.util.ArrayList;
 import java.util.Objects;
 import java.util.WeakHashMap;
 
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.runtime.features.clock.ClockLayoutTextFactory;
 import se.ajpanton.statusbartweak.runtime.layoutsolver.StatusBarLayoutSolver.Bounds;
 import se.ajpanton.statusbartweak.runtime.mode.NotificationDisplayStyle;
@@ -71,6 +74,11 @@ public final class UnlockedIconSnapshotRenderController {
             clearAll();
             return new RenderResult(true, true, true);
         }
+        if (scene.isUnlocked() && isKeyguardLocked(root.getContext())) {
+            clearLockscreenHosts(clockHost, carrierHost, chipHost, statusHost, notificationHost);
+            clearRoot(root);
+            return new RenderResult(true, true, true);
+        }
         SbtSettings settings = RuntimeSettingsCache.get(root.getContext());
         setStatusBarTintTargetEnabled(scene.isUnlocked());
         layoutHostToRoot(root, clockHost);
@@ -96,7 +104,7 @@ public final class UnlockedIconSnapshotRenderController {
                 root,
                 settings,
                 scene,
-                ViewGeometry.middleCutout(root),
+                EffectiveCutoutSupport.layoutMiddleCutout(root, settings),
                 anchors,
                 previousIcons);
         LayoutInputSignature previousSignature = lastLayoutSignatureByRoot.get(root);
@@ -154,12 +162,12 @@ public final class UnlockedIconSnapshotRenderController {
                     root,
                     currentClockLayout,
                     settings,
-                    UnlockedLayoutPlanner.cutoutBounds(ViewGeometry.middleCutout(root), settings.clockMiddleCutoutGapPx));
+                    clockCutoutBounds(root, settings));
             ClockPlacement textPlacement = clockTextPlacementForPrevious(
                     root,
                     currentClockLayout,
                     settings,
-                    UnlockedLayoutPlanner.cutoutBounds(ViewGeometry.middleCutout(root), settings.clockMiddleCutoutGapPx),
+                    clockCutoutBounds(root, settings),
                     previousPlan != null ? previousPlan.clockPlacement : null);
             ClockPlacement updatedClock = clockPlacementWithUpdatedText(
                     previousPlan != null ? previousPlan.clockPlacement : null,
@@ -193,7 +201,7 @@ public final class UnlockedIconSnapshotRenderController {
                     root,
                     currentClockLayout,
                     settings,
-                    UnlockedLayoutPlanner.cutoutBounds(ViewGeometry.middleCutout(root), settings.clockMiddleCutoutGapPx));
+                    clockCutoutBounds(root, settings));
         }
         if (scene.isLockscreen() && clockEnabledForScene(settings, scene) && currentClockLayout == null) {
             clearLockscreenHosts(clockHost, carrierHost, chipHost, statusHost, notificationHost);
@@ -392,6 +400,14 @@ public final class UnlockedIconSnapshotRenderController {
         notificationRenderer.clear(notificationHost);
     }
 
+    private boolean isKeyguardLocked(Context context) {
+        if (context == null) {
+            return false;
+        }
+        KeyguardManager keyguardManager = context.getSystemService(KeyguardManager.class);
+        return keyguardManager != null && keyguardManager.isKeyguardLocked();
+    }
+
     private void layoutHostToRoot(View root, ViewGroup host) {
         if (root == null || host == null || root.getWidth() <= 0 || root.getHeight() <= 0) {
             return;
@@ -449,7 +465,9 @@ public final class UnlockedIconSnapshotRenderController {
             NotificationDisplayStyle style = scene.notificationDisplayStyle();
             return settings.layoutNotifEnabledAod
                     && (style == NotificationDisplayStyle.ICONS
-                    || style == NotificationDisplayStyle.DOT);
+                    || style == NotificationDisplayStyle.DOT
+                    || (style == NotificationDisplayStyle.UNKNOWN
+                    && SystemUiCapabilities.treatsUnknownAodNotificationStyleAsIcons(settings)));
         }
         return settings.layoutNotifEnabledUnlocked;
     }
@@ -724,7 +742,13 @@ public final class UnlockedIconSnapshotRenderController {
                 anchors,
                 settings,
                 scene,
-                UnlockedLayoutPlanner.cutoutBounds(ViewGeometry.middleCutout(root), settings != null ? settings.clockMiddleCutoutGapPx : 0));
+                clockCutoutBounds(root, settings));
+    }
+
+    private Bounds clockCutoutBounds(View root, SbtSettings settings) {
+        return UnlockedLayoutPlanner.cutoutBounds(
+                EffectiveCutoutSupport.clockMiddleCutout(root, settings),
+                settings != null ? settings.clockMiddleCutoutGapPx : 0);
     }
 
     private ClockLayout buildClockLayout(

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/UnlockedLayoutPlanner.java

@@ -11,6 +11,7 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.R;
 import se.ajpanton.statusbartweak.runtime.layoutsolver.StatusBarLayoutSolver.AnchorSide;
 import se.ajpanton.statusbartweak.runtime.layoutsolver.StatusBarLayoutSolver.Bounds;
@@ -68,13 +69,14 @@ final class UnlockedLayoutPlanner {
             aodInitialStatusbarHeightByRoot.remove(root);
         }
         ArrayList<UnlockedLayoutBand> bands = new ArrayList<>();
-        Rect cutout = ViewGeometry.middleCutout(root);
+        Rect layoutCutout = EffectiveCutoutSupport.layoutMiddleCutout(root, settings);
+        Rect clockCutout = EffectiveCutoutSupport.clockMiddleCutout(root, settings);
         Bounds layoutCutoutBounds = scene != null && scene.isAod()
-                ? aodCutoutBounds(root, cutout, settings.layoutPaddingCutoutPx)
-                : cutoutBounds(cutout, settings.layoutPaddingCutoutPx);
+                ? aodCutoutBounds(root, layoutCutout, settings.layoutPaddingCutoutPx)
+                : cutoutBounds(layoutCutout, settings.layoutPaddingCutoutPx);
         Bounds clockCutoutBounds = scene != null && scene.isAod()
-                ? aodCutoutBounds(root, cutout, settings.clockMiddleCutoutGapPx)
-                : cutoutBounds(cutout, settings.clockMiddleCutoutGapPx);
+                ? aodCutoutBounds(root, clockCutout, settings.clockMiddleCutoutGapPx)
+                : cutoutBounds(clockCutout, settings.clockMiddleCutoutGapPx);
         Bounds aodStatusAnchorBounds = scene != null && scene.isAod()
                 ? aodStatusAnchorBounds(root, anchors, scene)
                 : null;
@@ -87,7 +89,13 @@ final class UnlockedLayoutPlanner {
         Bounds aodStatusbarBounds = scene != null && scene.isAod()
                 ? aodStatusbarBounds(root, settings, aodNotificationBounds, aodStatusAnchorBounds)
                 : null;
-        LayoutEdges edges = layoutEdges(root, settings, anchors, scene, aodStatusAnchorBounds);
+        LayoutEdges edges = layoutEdges(
+                root,
+                settings,
+                anchors,
+                collectedIcons,
+                scene,
+                aodStatusAnchorBounds);
         int statusbarHeight = statusbarHeight(root, anchors, scene, aodStatusContentBounds);
         if (clockEnabledForScene(settings, scene) && clockLayout != null && clockLayout.width() > 0) {
             bands.add(UnlockedLayoutBand.clock(
@@ -849,7 +857,9 @@ final class UnlockedLayoutPlanner {
             if (style == NotificationDisplayStyle.DOT) {
                 return settings.layoutNotifEnabledAod ? 1 : 0;
             }
-            if (style != NotificationDisplayStyle.ICONS) {
+            if (style != NotificationDisplayStyle.ICONS
+                    && !(style == NotificationDisplayStyle.UNKNOWN
+                    && isExperimentalGenericAod(settings))) {
                 return 0;
             }
             return settings.layoutNotifEnabledAod ? settings.layoutNotifAodCount : 0;
@@ -863,6 +873,10 @@ final class UnlockedLayoutPlanner {
                 && scene.notificationDisplayStyle() == NotificationDisplayStyle.DOT;
     }
 
+    private boolean isExperimentalGenericAod(SbtSettings settings) {
+        return SystemUiCapabilities.supportsExperimentalGenericAodStatusbarRoot(settings);
+    }
+
     private ArrayList<SnapshotPlacement> unreadNotificationPlacements(
             ArrayList<SnapshotPlacement> placements
     ) {
@@ -1112,7 +1126,9 @@ final class UnlockedLayoutPlanner {
             if (bounds == null || bounds.height <= 0) {
                 continue;
             }
-            int width = Math.max(1, Math.round((float) bounds.width * targetHeight / bounds.height));
+            int width = isChargingBatteryChipPlacement(placement)
+                    ? chargingBatteryChipWidth(targetHeight)
+                    : Math.max(1, Math.round((float) bounds.width * targetHeight / bounds.height));
             int bottom = bounds.top + bounds.height;
             Bounds resized = new Bounds(bounds.left, bottom - targetHeight, width, targetHeight);
             result.add(new SnapshotPlacement(
@@ -1130,6 +1146,15 @@ final class UnlockedLayoutPlanner {
         return result;
     }
 
+    private boolean isChargingBatteryChipPlacement(SnapshotPlacement placement) {
+        return placement != null
+                && SnapshotKeys.CHARGING_BATTERY_CHIP.equals(placement.key);
+    }
+
+    private int chargingBatteryChipWidth(int height) {
+        return Math.max(1, Math.round(Math.max(1, height) * 2.7f));
+    }
+
     private Bounds sourceRenderBoundsForResize(SnapshotPlacement placement) {
         if (placement == null || placement.source == null || placement.bounds == null) {
             return placement != null ? placement.sourceRenderBounds : null;
@@ -1381,6 +1406,7 @@ final class UnlockedLayoutPlanner {
             View root,
             SbtSettings settings,
             RootAnchors anchors,
+            CollectedIcons collectedIcons,
             SceneKey scene,
             Bounds aodStatusAnchorBounds
     ) {
@@ -1407,11 +1433,29 @@ final class UnlockedLayoutPlanner {
         if (settings.layoutPaddingRightAddStock) {
             right -= stockInsets.right;
         }
+        if (scene != null && scene.isUnlocked() && hasStatusChipSources(collectedIcons)) {
+            LayoutEdges recentEdges = recentNonAodEdgesByRootWidth.get(rootWidth);
+            if (isReusableUnlockedEdge(left, recentEdges)) {
+                left = recentEdges.left();
+            }
+        }
         LayoutEdges edges = new LayoutEdges(left, right);
         rememberNonAodEdges(rootWidth, scene, edges);
         return edges;
     }
 
+    private boolean hasStatusChipSources(CollectedIcons icons) {
+        return icons != null
+                && ((icons.statusChips != null && !icons.statusChips.isEmpty())
+                || (icons.statusChipMetrics != null && !icons.statusChipMetrics.isEmpty()));
+    }
+
+    private boolean isReusableUnlockedEdge(int currentLeft, LayoutEdges recentEdges) {
+        return recentEdges != null
+                && recentEdges.right() > recentEdges.left()
+                && Math.abs(currentLeft - recentEdges.left()) <= 8;
+    }
+
     private LayoutEdges stableAodEdges(int rootWidth, LayoutEdges aodEdges) {
         if (rootWidth <= 0) {
             return aodEdges;

app/src/main/java/se/ajpanton/statusbartweak/runtime/render/UnlockedStockSourceCollector.java

@@ -1,7 +1,10 @@
 package se.ajpanton.statusbartweak.runtime.render;
 
+import android.content.Context;
+import android.content.Intent;
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
+import android.os.BatteryManager;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ImageView;
@@ -15,6 +18,7 @@ import java.util.Locale;
 import java.util.Objects;
 import java.util.WeakHashMap;
 
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.runtime.NotificationKeyReflection;
 import se.ajpanton.statusbartweak.runtime.ViewIdNames;
 import se.ajpanton.statusbartweak.runtime.hooks.ReflectionSupport;
@@ -23,6 +27,7 @@ import se.ajpanton.statusbartweak.runtime.mode.NotificationDisplayStyle;
 import se.ajpanton.statusbartweak.runtime.mode.SceneKey;
 import se.ajpanton.statusbartweak.runtime.notifications.NotificationActiveKeyStore;
 import se.ajpanton.statusbartweak.runtime.notifications.NotificationUnreadTracker;
+import se.ajpanton.statusbartweak.runtime.settings.BroadcastReceiverSupport;
 import se.ajpanton.statusbartweak.shell.settings.SbtDefaults;
 import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
 
@@ -59,7 +64,7 @@ final class UnlockedStockSourceCollector {
         ArrayList<SnapshotSource> statusChips = new ArrayList<>();
         ArrayList<SnapshotSource> statusChipMetrics = new ArrayList<>();
         if (scene != null && scene.isAod()) {
-            collectAodStatusSnapshotViews(root, statusIcons, scene);
+            collectAodStatusSnapshotViews(root, statusIcons, scene, settings);
         }
         if (statusIcons.isEmpty()) {
             if (anchors.statusRoot != null) {
@@ -74,11 +79,11 @@ final class UnlockedStockSourceCollector {
         if (anchors.battery != null && !ViewGeometry.isDescendantOf(anchors.battery, anchors.statusRoot)) {
             collectStatusSnapshotViews(anchors.battery, statusIcons);
         }
+        addSamsungBatteryStatusChipSource(root, statusIcons, settings);
         selectDualSimStatusSignals(statusIcons, settings);
         normalizeStatusIconSourceBounds(root, statusIcons);
         if (scene != null && scene.isAod()) {
-            if (scene.notificationDisplayStyle() == NotificationDisplayStyle.ICONS
-                    || scene.notificationDisplayStyle() == NotificationDisplayStyle.DOT) {
+            if (isAodIconNotificationStyle(scene, settings)) {
                 notificationIcons.addAll(
                         LockscreenCardsNotificationIconSourceStore.snapshotSourcesForAodIconsRoot(root));
                 if (notificationIcons.isEmpty()
@@ -87,6 +92,12 @@ final class UnlockedStockSourceCollector {
                             LockscreenCardsNotificationIconSourceStore
                                     .snapshotAodNotificationPackageSources(root));
                 }
+                if (notificationIcons.isEmpty() && isExperimentalGenericAod(settings)) {
+                    View notificationRoot = anchors != null && anchors.notificationRoot != null
+                            ? anchors.notificationRoot
+                            : root;
+                    collectNotificationSnapshotViews(notificationRoot, notificationIcons);
+                }
             }
         } else if (anchors.notificationRoot != null) {
             collectNotificationSnapshotViews(anchors.notificationRoot, notificationIcons);
@@ -106,14 +117,14 @@ final class UnlockedStockSourceCollector {
     private void collectAodStatusSnapshotViews(
             View root,
             ArrayList<SnapshotSource> out,
-            SceneKey scene
+            SceneKey scene,
+            SbtSettings settings
     ) {
         if (root == null || out == null) {
             return;
         }
         boolean iconMode = scene != null
-                && (scene.notificationDisplayStyle() == NotificationDisplayStyle.ICONS
-                || scene.notificationDisplayStyle() == NotificationDisplayStyle.DOT);
+                && isAodIconNotificationStyle(scene, settings);
         View excludedNotificationContainer = iconMode
                 ? LockscreenCardsNotificationIconSourceStore.sourceContainerForAodIconsRoot(root)
                 : LockscreenCardsNotificationIconSourceStore.sourceContainerForRoot(root);
@@ -124,6 +135,21 @@ final class UnlockedStockSourceCollector {
         }
     }
 
+    private boolean isAodIconNotificationStyle(SceneKey scene, SbtSettings settings) {
+        if (scene == null || !scene.isAod()) {
+            return false;
+        }
+        NotificationDisplayStyle style = scene.notificationDisplayStyle();
+        return style == NotificationDisplayStyle.ICONS
+                || style == NotificationDisplayStyle.DOT
+                || (style == NotificationDisplayStyle.UNKNOWN
+                && SystemUiCapabilities.treatsUnknownAodNotificationStyleAsIcons(settings));
+    }
+
+    private boolean isExperimentalGenericAod(SbtSettings settings) {
+        return SystemUiCapabilities.supportsExperimentalGenericAodStatusbarRoot(settings);
+    }
+
     private String reflectString(View view, String methodName, String... fieldNames) {
         Object methodValue = ReflectionSupport.invokeMethod(view, methodName);
         if (methodValue != null) {
@@ -185,9 +211,10 @@ final class UnlockedStockSourceCollector {
                 : 0;
         int statusSourceSignature = sourceLayoutListSignature(
                 previousIcons != null ? previousIcons.statusIcons : null);
+        statusSourceSignature = 31 * statusSourceSignature + batteryChargingSignature(root);
         if (scene != null && scene.isAod()) {
             statusSourceSignature = 31 * statusSourceSignature
-                    + aodLayoutAnchorSignature(root, anchors, scene);
+                    + aodLayoutAnchorSignature(root, anchors, scene, settings);
         }
         int notificationSourceSignature = sourceLayoutListSignature(
                 previousIcons != null ? previousIcons.notificationIcons : null);
@@ -232,13 +259,17 @@ final class UnlockedStockSourceCollector {
                 chipSourceSignature);
     }
 
-    private int aodLayoutAnchorSignature(View root, RootAnchors anchors, SceneKey scene) {
+    private int aodLayoutAnchorSignature(
+            View root,
+            RootAnchors anchors,
+            SceneKey scene,
+            SbtSettings settings
+    ) {
         if (root == null) {
             return 0;
         }
         boolean iconMode = scene != null
-                && (scene.notificationDisplayStyle() == NotificationDisplayStyle.ICONS
-                || scene.notificationDisplayStyle() == NotificationDisplayStyle.DOT);
+                && isAodIconNotificationStyle(scene, settings);
         View notificationContainer = iconMode
                 ? LockscreenCardsNotificationIconSourceStore.sourceContainerForAodIconsRoot(root)
                 : LockscreenCardsNotificationIconSourceStore.sourceContainerForRoot(root);
@@ -283,7 +314,7 @@ final class UnlockedStockSourceCollector {
                     return;
                 }
                 if (isStatusChipMetricCandidate(root, source.view(), true)
-                        && hasVisibleStatusChipContent(source.view())) {
+                        && hasRenderableStatusChipContent(source.view())) {
                     metricOut.add(source);
                     return;
                 }
@@ -311,7 +342,7 @@ final class UnlockedStockSourceCollector {
             }
             if (clockView == null
                     && view instanceof TextView textView
-                    && view.getClass().getName().contains("QSClockIndicatorView")) {
+                    && isStatusbarClockView(textView)) {
                 clockView = textView;
             }
             if (statusEndContent == null && idName.equals("status_bar_end_side_content")) {
@@ -364,6 +395,12 @@ final class UnlockedStockSourceCollector {
                 carrierView);
     }
 
+    private boolean isStatusbarClockView(TextView view) {
+        String className = view.getClass().getName();
+        return className.contains("QSClockIndicatorView")
+                || className.equals("com.android.systemui.statusbar.policy.Clock");
+    }
+
     private boolean isCarrierTextView(TextView view) {
         if (view == null) {
             return false;
@@ -880,6 +917,132 @@ final class UnlockedStockSourceCollector {
         }
     }
 
+    private void addSamsungBatteryStatusChipSource(
+            View root,
+            ArrayList<SnapshotSource> sources,
+            SbtSettings settings
+    ) {
+        if (root == null
+                || sources == null
+                || settings == null
+                || settings.statusChipsHideAll
+                || settings.statusChipsHideBattery
+                || !isDevicePlugged(root.getContext())) {
+            return;
+        }
+        View chip = samsungBatteryStatusChip(root);
+        if (chip == null) {
+            return;
+        }
+        removeBatteryStatusSources(sources);
+        Bounds bounds = ViewGeometry.boundsRelativeTo(root, chip);
+        sources.add(new SnapshotSource(
+                chip,
+                SnapshotMode.STATUS_CHIP,
+                SnapshotKeys.CHARGING_BATTERY_CHIP,
+                validBounds(bounds) ? bounds : null));
+    }
+
+    private View samsungBatteryStatusChip(View root) {
+        if (root == null) {
+            return null;
+        }
+        ArrayDeque<View> queue = new ArrayDeque<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            View view = queue.removeFirst();
+            if (isSamsungBatteryStatusChip(view) && hasUsableSamsungBatteryStatusChipBounds(root, view)) {
+                return view;
+            }
+            if (view instanceof ViewGroup group) {
+                for (int i = 0; i < group.getChildCount(); i++) {
+                    View child = group.getChildAt(i);
+                    if (child != null) {
+                        queue.addLast(child);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private boolean hasUsableSamsungBatteryStatusChipBounds(View root, View view) {
+        if (root == null
+                || view == null
+                || view == root
+                || !view.isAttachedToWindow()
+                || view.getVisibility() != View.VISIBLE
+                || (view.getAlpha() <= 0f && !hasVisibleStatusChipContent(view))) {
+            return false;
+        }
+        Bounds bounds = ViewGeometry.boundsRelativeTo(root, view);
+        return validBounds(bounds)
+                && bounds.top >= 0
+                && bounds.top <= root.getHeight()
+                && bounds.width < root.getWidth() / 2;
+    }
+
+    private boolean validBounds(Bounds bounds) {
+        return bounds != null && bounds.width > 0 && bounds.height > 0;
+    }
+
+    private void removeBatteryStatusSources(ArrayList<SnapshotSource> sources) {
+        if (sources == null || sources.isEmpty()) {
+            return;
+        }
+        for (int i = sources.size() - 1; i >= 0; i--) {
+            SnapshotSource source = sources.get(i);
+            if (isBatteryStatusSource(source)) {
+                sources.remove(i);
+            }
+        }
+    }
+
+    private boolean isBatteryStatusSource(SnapshotSource source) {
+        View view = source != null ? source.view() : null;
+        StringBuilder sb = new StringBuilder();
+        append(sb, source != null ? source.keyHint() : null);
+        append(sb, reflectString(view, "getSlot", "mSlot", "slot"));
+        append(sb, view != null ? ViewIdNames.idName(view) : null);
+        append(sb, view != null ? view.getClass().getName() : null);
+        return sb.toString().toLowerCase(Locale.ROOT).contains("battery");
+    }
+
+    private boolean isSamsungBatteryStatusChip(View view) {
+        return view != null && view.getClass().getName().contains("SamsungBatteryStatusChip");
+    }
+
+    private int batteryChargingSignature(View root) {
+        return root != null && isDevicePlugged(root.getContext()) ? 1 : 0;
+    }
+
+    private boolean isDevicePlugged(Context context) {
+        Intent intent = batteryIntent(context);
+        if (intent == null) {
+            return false;
+        }
+        int status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
+        return intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) != 0
+                || status == BatteryManager.BATTERY_STATUS_CHARGING
+                || status == BatteryManager.BATTERY_STATUS_FULL;
+    }
+
+    private Intent batteryIntent(Context context) {
+        if (context == null) {
+            return null;
+        }
+        return BroadcastReceiverSupport.readExportedSticky(
+                context,
+                BroadcastReceiverSupport.filter(Intent.ACTION_BATTERY_CHANGED));
+    }
+
+    private void append(StringBuilder sb, String value) {
+        if (sb == null || value == null || value.isEmpty()) {
+            return;
+        }
+        sb.append(';').append(value);
+    }
+
     private int normalizedStatusIconWidth(int drawableWidth, int iconHeight) {
         return Math.max(1, drawableWidth + statusIconHorizontalPadding(iconHeight));
     }
@@ -1056,11 +1219,12 @@ final class UnlockedStockSourceCollector {
         View view = source.view();
         if (view == null
                 || view == root
+                || view.getVisibility() != View.VISIBLE
                 || !view.isAttachedToWindow()
                 || !ViewGeometry.isDescendantOf(view, root)
                 || ReflectionSupport.getBooleanField(view, "sbtStatusChipForcedHidden", false)
                 || !isStatusChipCandidate(view)
-                || !hasVisibleStatusChipContent(view)) {
+                || !hasRenderableStatusChipContent(view)) {
             return false;
         }
         Bounds bounds = source.boundsOverride() != null
@@ -1078,7 +1242,7 @@ final class UnlockedStockSourceCollector {
         if (view == null || view == root || view.getVisibility() != View.VISIBLE) {
             return false;
         }
-        if (!allowHidden && view.getAlpha() <= 0f && !hasVisibleStatusChipContent(view)) {
+        if (!allowHidden && view.getAlpha() <= 0f && !hasRenderableStatusChipContent(view)) {
             return false;
         }
         if (ReflectionSupport.getBooleanField(view, "sbtStatusChipForcedHidden", false)) {
@@ -1093,7 +1257,7 @@ final class UnlockedStockSourceCollector {
         if (bounds == null || bounds.top < 0 || bounds.top > root.getHeight()) {
             return false;
         }
-        if (!isStatusChipCandidate(view)) {
+        if (!isStatusChipCandidate(view) || !hasRenderableStatusChipContent(view)) {
             return false;
         }
         Object parent = view.getParent();
@@ -1106,6 +1270,39 @@ final class UnlockedStockSourceCollector {
         return true;
     }
 
+    private boolean hasRenderableStatusChipContent(View source) {
+        if (!(source instanceof ViewGroup group)) {
+            return false;
+        }
+        ArrayDeque<View> queue = new ArrayDeque<>();
+        for (int i = 0; i < group.getChildCount(); i++) {
+            queue.addLast(group.getChildAt(i));
+        }
+        while (!queue.isEmpty()) {
+            View view = queue.removeFirst();
+            if (view == null) {
+                continue;
+            }
+            if (view instanceof TextView textView
+                    && view.getVisibility() == View.VISIBLE
+                    && view.getAlpha() > 0f
+                    && textView.getText() != null
+                    && textView.getText().length() > 0) {
+                int width = view.getWidth() > 0 ? view.getWidth() : view.getMeasuredWidth();
+                int height = view.getHeight() > 0 ? view.getHeight() : view.getMeasuredHeight();
+                if (width > 0 && height > 0) {
+                    return true;
+                }
+            }
+            if (view instanceof ViewGroup childGroup) {
+                for (int i = 0; i < childGroup.getChildCount(); i++) {
+                    queue.addLast(childGroup.getChildAt(i));
+                }
+            }
+        }
+        return false;
+    }
+
     private boolean hasVisibleStatusChipContent(View source) {
         if (!(source instanceof ViewGroup group)) {
             return false;
@@ -1136,10 +1333,10 @@ final class UnlockedStockSourceCollector {
     }
 
     private boolean isStatusChipMetricCandidate(View root, View view, boolean allowHidden) {
-        if (view == null || view == root || root == null) {
+        if (view == null || view == root || root == null || view.getVisibility() != View.VISIBLE) {
             return false;
         }
-        if (!allowHidden && view.getAlpha() <= 0f && !hasVisibleStatusChipContent(view)) {
+        if (!allowHidden && view.getAlpha() <= 0f && !hasRenderableStatusChipContent(view)) {
             return false;
         }
         int width = view.getWidth() > 0 ? view.getWidth() : view.getMeasuredWidth();
@@ -1151,7 +1348,7 @@ final class UnlockedStockSourceCollector {
         if (bounds == null || bounds.top < 0 || bounds.top > root.getHeight()) {
             return false;
         }
-        if (!isStatusChipCandidate(view)) {
+        if (!isStatusChipCandidate(view) || !hasRenderableStatusChipContent(view)) {
             return false;
         }
         Object parent = view.getParent();
@@ -1350,7 +1547,7 @@ final class UnlockedStockSourceCollector {
         queue.add(root);
         while (!queue.isEmpty()) {
             View view = queue.removeFirst();
-            if (view != root && isStatusChipCandidate(view) && hasVisibleStatusChipContent(view)) {
+            if (view != root && isStatusChipCandidate(view) && hasRenderableStatusChipContent(view)) {
                 result = 31 * result + chipViewLayoutSignature(view);
             }
             if (view instanceof ViewGroup group) {
@@ -1370,7 +1567,7 @@ final class UnlockedStockSourceCollector {
         result = 31 * result + sources.size();
         for (SnapshotSource source : sources) {
             result = 31 * result + source.mode().ordinal();
-            result = 31 * result + (hasVisibleStatusChipContent(source.view()) ? 1 : 0);
+            result = 31 * result + (hasRenderableStatusChipContent(source.view()) ? 1 : 0);
             result = 31 * result + chipViewLayoutSignature(source.view());
         }
         return result;
@@ -1494,6 +1691,7 @@ final class UnlockedStockSourceCollector {
                 settings.clockCustomFormatEnabled,
                 settings.clockCustomFormat,
                 settings.clockIgnoreUnderDisplayCameras,
+                settings.clockCameraTypeOverrides,
                 settings.layoutPaddingCutoutPx,
                 settings.layoutPaddingLeftPx,
                 settings.layoutPaddingRightPx,
@@ -1556,7 +1754,8 @@ final class UnlockedStockSourceCollector {
                 settings.statusChipsHideAll,
                 settings.statusChipsHideMediaUnlocked,
                 settings.statusChipsHideNavUnlocked,
-                settings.statusChipsHideCallUnlocked);
+                settings.statusChipsHideCallUnlocked,
+                settings.statusChipsHideBattery);
     }
 
 }

app/src/main/java/se/ajpanton/statusbartweak/shell/settings/AppIconRules.java

@@ -17,7 +17,7 @@ import java.util.regex.Pattern;
 
 public final class AppIconRules {
     private static final Pattern PACKAGE_NAME_PATTERN =
-            Pattern.compile("^[a-z][a-z0-9_]*(\\.[a-z][a-z0-9_]*)+$");
+            Pattern.compile("^[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)+$");
 
     public static final String PREF_KEY_BLOCKED_MODES = "app_icon_blocked_modes";
     public static final String PREF_KEY_EXCEPTION_RULES = "app_icon_exception_rules";
@@ -417,7 +417,7 @@ public final class AppIconRules {
                 continue;
             }
             String[] parts = entry.split("\\|", -1);
-            if (parts.length != 2 && parts.length != 4) {
+            if (parts.length != 4) {
                 continue;
             }
             String pkg = parts[0];
@@ -429,13 +429,8 @@ public final class AppIconRules {
             int lastSeenOffsetMinutes;
             try {
                 firstSeen = Long.parseLong(parts[1]);
-                if (parts.length == 4) {
                 lastSeen = Long.parseLong(parts[2]);
                 lastSeenOffsetMinutes = Integer.parseInt(parts[3]);
-                } else {
-                    lastSeen = firstSeen;
-                    lastSeenOffsetMinutes = currentTimezoneOffsetMinutes();
-                }
             } catch (NumberFormatException ignored) {
                 continue;
             }

app/src/main/java/se/ajpanton/statusbartweak/shell/settings/BatteryBarGeometry.java

@@ -21,11 +21,28 @@ public final class BatteryBarGeometry {
     public final String position;
     public final String alignment;
     public final int thicknessDp;
+    public final int edgeOffsetDp;
+    public final String curvedGeometryMode;
 
     public BatteryBarGeometry(
             String position,
             String alignment,
             int thicknessDp
+    ) {
+        this(
+                position,
+                alignment,
+                thicknessDp,
+                SbtDefaults.BATTERY_BAR_EDGE_OFFSET_DP_DEFAULT,
+                SbtDefaults.BATTERY_BAR_CURVED_GEOMETRY_MODE_DEFAULT);
+    }
+
+    public BatteryBarGeometry(
+            String position,
+            String alignment,
+            int thicknessDp,
+            int edgeOffsetDp,
+            String curvedGeometryMode
     ) {
         this.position = sanitizePosition(position);
         this.alignment = sanitizeAlignment(alignment);
@@ -33,6 +50,11 @@ public final class BatteryBarGeometry {
                 thicknessDp,
                 SbtDefaults.BATTERY_BAR_THICKNESS_DP_MIN,
                 SbtDefaults.BATTERY_BAR_THICKNESS_DP_MAX);
+        this.edgeOffsetDp = clamp(
+                edgeOffsetDp,
+                SbtDefaults.BATTERY_BAR_EDGE_OFFSET_DP_MIN,
+                SbtDefaults.BATTERY_BAR_EDGE_OFFSET_DP_MAX);
+        this.curvedGeometryMode = sanitizeCurvedGeometryMode(curvedGeometryMode);
     }
 
     public static BatteryBarGeometry global(SbtSettings settings) {
@@ -45,7 +67,9 @@ public final class BatteryBarGeometry {
         return new BatteryBarGeometry(
                 settings.batteryBarPosition,
                 settings.batteryBarAlignment,
-                settings.batteryBarThicknessDp);
+                settings.batteryBarThicknessDp,
+                settings.batteryBarEdgeOffsetDp,
+                settings.batteryBarCurvedGeometryMode);
     }
 
     public static BatteryBarGeometry resolve(
@@ -68,17 +92,19 @@ public final class BatteryBarGeometry {
             return safeFallback;
         }
         String[] parts = value.split("\\|", -1);
-        if (parts.length != 3 && parts.length != 4) {
+        if (parts.length != 5) {
             return safeFallback;
         }
         return new BatteryBarGeometry(
                 parts[0],
                 parts[1],
-                parseInt(parts[2], safeFallback.thicknessDp));
+                parseInt(parts[2], safeFallback.thicknessDp),
+                parseInt(parts[3], safeFallback.edgeOffsetDp),
+                parts[4]);
     }
 
     public String encode() {
-        return position + "|" + alignment + "|" + thicknessDp;
+        return position + "|" + alignment + "|" + thicknessDp + "|" + edgeOffsetDp + "|" + curvedGeometryMode;
     }
 
     public String signature() {
@@ -104,6 +130,13 @@ public final class BatteryBarGeometry {
         return "ltr";
     }
 
+    private static String sanitizeCurvedGeometryMode(String mode) {
+        if ("length".equals(mode)) {
+            return "length";
+        }
+        return "off";
+    }
+
     private static int parseInt(String value, int fallback) {
         try {
             return Integer.parseInt(value);

app/src/main/java/se/ajpanton/statusbartweak/shell/settings/ClockCameraTypeSupport.java

@@ -29,6 +29,9 @@ public final class ClockCameraTypeSupport {
     public static final class CameraInfo {
         public int semDisplayDeviceType = Integer.MIN_VALUE;
         public int fillUdcDisplayCutout = Integer.MIN_VALUE;
+        public int rootWidth = Integer.MIN_VALUE;
+        public int rootHeight = Integer.MIN_VALUE;
+        public int rotation = Integer.MIN_VALUE;
         public boolean isUdcMainDisplay;
         public String cutoutType;
         public String cutoutString;
@@ -59,8 +62,15 @@ public final class ClockCameraTypeSupport {
                 : "blocking cutout";
     }
 
-    public static String buildCameraId(int semDisplayDeviceType, String cutoutType, String cutoutString) {
+    private static String buildCameraId(int semDisplayDeviceType,
+                                        int rootWidth,
+                                        int rootHeight,
+                                        int rotation,
+                                        String cutoutType,
+                                        String cutoutString) {
         String descriptor = semDisplayDeviceType + "|"
+                + rootWidth + "x" + rootHeight + "|"
+                + rotation + "|"
                 + safe(cutoutType) + "|"
                 + safe(cutoutString);
         return "cam_" + shortSha1(descriptor);
@@ -78,6 +88,20 @@ public final class ClockCameraTypeSupport {
             finalizeCameraInfo(info, settings);
             return info;
         }
+        Display display = root.getDisplay();
+        if (display != null) {
+            info.rotation = display.getRotation();
+        }
+        int width = root.getWidth();
+        if (width <= 0 && root.getRootView() != null) {
+            width = root.getRootView().getWidth();
+        }
+        info.rootWidth = width;
+        int height = root.getHeight();
+        if (height <= 0 && root.getRootView() != null) {
+            height = root.getRootView().getHeight();
+        }
+        info.rootHeight = height;
         info.semDisplayDeviceType = readSemDisplayDeviceType(context);
         info.fillUdcDisplayCutout = readGlobalInt(context, "fill_udc_display_cutout");
         Object displayLifecycle = resolveDisplayLifecycle(context);
@@ -93,15 +117,9 @@ public final class ClockCameraTypeSupport {
                 finalizeCameraInfo(info, settings);
                 return info;
             }
-
             Object input = newInstance(inputClass, context);
-            Display display = root.getDisplay();
             if (display != null) {
-                setIntField(input, "rotation", display.getRotation());
-            }
-            int width = root.getWidth();
-            if (width <= 0 && root.getRootView() != null) {
-                width = root.getRootView().getWidth();
+                setIntField(input, "rotation", info.rotation);
             }
             if (width > 0) {
                 setIntField(input, "statusBarWidth", width);
@@ -196,6 +214,9 @@ public final class ClockCameraTypeSupport {
         }
         info.cameraId = buildCameraId(
                 info.semDisplayDeviceType,
+                info.rootWidth,
+                info.rootHeight,
+                info.rotation,
                 info.cutoutType,
                 info.cutoutString);
         boolean explicitUdc = info.isUdcMainDisplay || "UDC".equals(info.cutoutType);

app/src/main/java/se/ajpanton/statusbartweak/shell/settings/ColourExpressionSupport.java

@@ -1,394 +1,105 @@
 package se.ajpanton.statusbartweak.shell.settings;
 
 import android.graphics.Color;
-import android.text.TextUtils;
 
-import java.util.Locale;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
+import se.ajpanton.statusbartweak.runtime.features.clock.ClockColorResolver;
 
 public final class ColourExpressionSupport {
-    private static final Pattern OPERATION_PATTERN =
-            Pattern.compile("([+\\-*/])\\s*(" + hexOperandPattern() + "|\\d+(?:\\.\\d+)?|\\.\\d+)");
-    private static final Pattern LEADING_HEX_PATTERN =
-            Pattern.compile("(?i)^#?(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{4}|[0-9a-f]{3})");
+    private static final ClockColorResolver RESOLVER = new ClockColorResolver();
+    private static final ClockColorResolver.Options OPTIONS = ClockColorResolver.Options.batteryBar();
 
     private ColourExpressionSupport() {
     }
 
     public static String normaliseExpression(String raw, boolean assumeHashPrefix) {
-        if (raw == null) {
-            return "";
-        }
-        String value = raw.trim();
+        String value = normaliseSeparators(raw);
         if (value.isEmpty()) {
             return "";
         }
-        int variantSplit = findVariantSplit(value);
-        String left = value;
-        String right = null;
-        if (variantSplit >= 0) {
-            left = value.substring(0, variantSplit).trim();
-            right = value.substring(variantSplit + 1).trim();
-        }
-        if (!isValidSegment(left, assumeHashPrefix, false, Color.WHITE)) {
+        try {
+            RESOLVER.resolveColor(null, value, Color.WHITE, Color.WHITE, OPTIONS);
+            RESOLVER.resolveColor(null, value, Color.BLACK, Color.WHITE, OPTIONS);
+            return value;
+        } catch (IllegalArgumentException ignored) {
             return "";
         }
-        if (right != null && !isValidSegment(right, assumeHashPrefix, true, Color.WHITE)) {
-            return "";
-        }
-        if (right == null) {
-            return left;
-        }
-        return left + "|" + right;
     }
 
-    public static int resolveColor(String raw,
+    public static int resolveColor(
+            String raw,
             int referenceColor,
             int fallbackColor,
-                                   boolean assumeHashPrefix) {
-        String value = normaliseExpression(raw, assumeHashPrefix);
+            boolean assumeHashPrefix
+    ) {
+        String value = normaliseSeparators(raw);
         if (value.isEmpty()) {
             return fallbackColor;
         }
-        int variantSplit = findVariantSplit(value);
-        if (variantSplit < 0) {
-            return resolveSegment(value, fallbackColor, assumeHashPrefix, false);
+        try {
+            return RESOLVER.resolveColor(null, value, referenceColor, fallbackColor, OPTIONS);
+        } catch (IllegalArgumentException ignored) {
+            return fallbackColor;
         }
-        String left = value.substring(0, variantSplit).trim();
-        String right = value.substring(variantSplit + 1).trim();
-        int brightVariant = resolveSegment(left, fallbackColor, assumeHashPrefix, false);
-        if (!isDark(referenceColor)) {
-            return brightVariant;
-        }
-        return resolveSegment(right, brightVariant, assumeHashPrefix, true);
     }
 
-    public static String resolveColorHex(String raw,
+    public static String resolveColorHex(
+            String raw,
             int referenceColor,
             int fallbackColor,
-                                         boolean assumeHashPrefix) {
-        int resolved = resolveColor(raw, referenceColor, fallbackColor, assumeHashPrefix);
-        int alpha = Color.alpha(resolved);
-        if (alpha >= 255) {
-            return String.format(Locale.ROOT, "#%06X", resolved & 0xFFFFFF);
-        }
-        return String.format(Locale.ROOT, "#%08X", resolved);
-    }
-
-    private static boolean isValidSegment(String segment,
-                                          boolean assumeHashPrefix,
-                                          boolean allowInheritedBase,
-                                          int baseColor) {
-        if (TextUtils.isEmpty(segment)) {
-            return false;
+            boolean assumeHashPrefix
+    ) {
+        String value = normaliseSeparators(raw);
+        if (value.isEmpty()) {
+            return hexFor(fallbackColor);
         }
         try {
-            resolveSegment(segment, baseColor, assumeHashPrefix, allowInheritedBase);
-            return true;
+            return RESOLVER.resolveColorHex(null, value, referenceColor, fallbackColor, OPTIONS);
         } catch (IllegalArgumentException ignored) {
-            return false;
+            return hexFor(fallbackColor);
         }
     }
 
-    private static int resolveSegment(String segment,
-                                      int baseColor,
-                                      boolean assumeHashPrefix,
-                                      boolean allowInheritedBase) {
-        String value = segment != null ? segment.trim() : "";
-        if (value.isEmpty()) {
-            throw new IllegalArgumentException("Empty colour segment");
-        }
-        int index = 0;
-        boolean invert = false;
-        if (value.regionMatches(true, 0, "inv", 0, 3)) {
-            invert = true;
-            index = 3;
-        }
-        double[] channels;
-        double alpha;
-        String remainder;
-        if (startsWithOperator(value, index)) {
-            if (!allowInheritedBase) {
-                throw new IllegalArgumentException("Missing starting colour");
-            }
-            channels = channelsFor(baseColor);
-            alpha = Color.alpha(baseColor);
-            remainder = value.substring(index).trim();
-        } else {
-            LeadingColour leading = parseLeadingColour(value, index, assumeHashPrefix);
-            channels = channelsFor(leading.color);
-            alpha = Color.alpha(leading.color);
-            remainder = value.substring(leading.endIndex).trim();
-        }
-        if (invert) {
-            invertChannels(channels);
-        }
-        alpha = applyOperations(channels, alpha, remainder);
-        return colorFromChannels(channels, alpha);
-    }
-
-    private static LeadingColour parseLeadingColour(String value,
-                                                    int start,
-                                                    boolean assumeHashPrefix) {
-        String remainder = value.substring(start).trim();
-        Matcher matcher = LEADING_HEX_PATTERN.matcher(remainder);
-        if (!matcher.find()) {
-            throw new IllegalArgumentException("Missing starting colour");
-        }
-        String token = matcher.group();
-        if (assumeHashPrefix && token.charAt(0) != '#') {
-            token = "#" + token;
-        }
-        int color = parseHexColor(token, assumeHashPrefix);
-        return new LeadingColour(color, start + matcher.end());
-    }
-
-    private static double applyOperations(double[] channels, double alpha, String remainder) {
-        int index = 0;
-        while (index < remainder.length()) {
-            while (index < remainder.length() && Character.isWhitespace(remainder.charAt(index))) {
-                index++;
-            }
-            if (index >= remainder.length()) {
-                break;
-            }
-            Matcher matcher = OPERATION_PATTERN.matcher(remainder);
-            matcher.region(index, remainder.length());
-            if (!matcher.lookingAt()) {
-                throw new IllegalArgumentException("Invalid colour operation");
-            }
-            char operator = matcher.group(1).charAt(0);
-            String operandText = matcher.group(2);
-            alpha = applyOperation(channels, alpha, operator, operandText);
-            index = matcher.end();
-        }
-        return alpha;
-    }
-
-    private static double applyOperation(double[] channels, double alpha, char operator, String operandText) {
-        Operand operand = parseOperand(operandText);
-        for (int i = 0; i < 3; i++) {
-            double value = channels[i];
-            double rhs = operand.rgb[i];
-            if (operand.isHex && (operator == '*' || operator == '/')) {
-                rhs = rhs / 255d;
-            }
-            switch (operator) {
-                case '+':
-                    channels[i] = value + rhs;
-                    break;
-                case '-':
-                    channels[i] = value - rhs;
-                    break;
-                case '*':
-                    channels[i] = value * rhs;
-                    break;
-                case '/':
-                    channels[i] = rhs == 0d ? value : value / rhs;
-                    break;
-                default:
-                    throw new IllegalArgumentException("Unknown operator");
-            }
-        }
-        if (operand.hasAlpha) {
-            double rhs = operand.alpha;
-            if (operand.isHex && (operator == '*' || operator == '/')) {
-                rhs = rhs / 255d;
-            }
-            switch (operator) {
-                case '+':
-                    alpha = alpha + rhs;
-                    break;
-                case '-':
-                    alpha = alpha - rhs;
-                    break;
-                case '*':
-                    alpha = alpha * rhs;
-                    break;
-                case '/':
-                    alpha = rhs == 0d ? alpha : alpha / rhs;
-                    break;
-                default:
-                    throw new IllegalArgumentException("Unknown operator");
-            }
-        }
-        return alpha;
-    }
-
-    private static Operand parseOperand(String operandText) {
-        String value = operandText != null ? operandText.trim() : "";
-        if (value.isEmpty()) {
-            throw new IllegalArgumentException("Missing operand");
-        }
-        if (value.charAt(0) == '#') {
-            return parseHexOperand(value);
-        }
-        double scalar;
-        try {
-            scalar = Double.parseDouble(value);
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("Invalid operand", e);
-        }
-        return new Operand(new double[] { scalar, scalar, scalar }, 0d, false, false);
-    }
-
-    private static int parseHexColor(String raw, boolean assumeHashPrefix) {
+    private static String normaliseSeparators(String raw) {
         String value = raw != null ? raw.trim() : "";
         if (value.isEmpty()) {
-            throw new IllegalArgumentException("Empty colour");
+            return "";
         }
-        if (assumeHashPrefix && value.charAt(0) != '#') {
-            value = "#" + value;
-        }
-        if (value.charAt(0) != '#') {
-            throw new IllegalArgumentException("Expected colour literal");
-        }
-        String hex = value.substring(1);
-        if (hex.length() == 3) {
-            hex = expandShortHex(hex);
-        } else if (hex.length() == 4) {
-            hex = expandShortHex(hex);
-        } else if (hex.length() != 6 && hex.length() != 8) {
-            throw new IllegalArgumentException("Unsupported colour length");
-        }
-        try {
-            return Color.parseColor("#" + hex);
-        } catch (IllegalArgumentException e) {
-            throw new IllegalArgumentException("Invalid colour", e);
+        int split = findTopLevelPipe(value);
+        if (split < 0) {
+            return value;
         }
+        return value.substring(0, split).trim() + " ; " + value.substring(split + 1).trim();
     }
 
-    private static String expandShortHex(String hex) {
-        StringBuilder out = new StringBuilder(hex.length() * 2);
-        for (int i = 0; i < hex.length(); i++) {
-            char c = hex.charAt(i);
-            out.append(c).append(c);
-        }
-        return out.toString();
-    }
-
-    private static double[] channelsFor(int color) {
-        return new double[] {
-                Color.red(color),
-                Color.green(color),
-                Color.blue(color)
-        };
-    }
-
-    private static void invertChannels(double[] channels) {
-        for (int i = 0; i < 3; i++) {
-            channels[i] = 255d - channels[i];
-        }
-    }
-
-    private static int colorFromChannels(double[] channels, double alpha) {
-        int red = clampChannel(channels[0]);
-        int green = clampChannel(channels[1]);
-        int blue = clampChannel(channels[2]);
-        return Color.argb(clampChannel(alpha), red, green, blue);
-    }
-
-    private static Operand parseHexOperand(String raw) {
-        String value = raw != null ? raw.trim() : "";
-        if (value.isEmpty() || value.charAt(0) != '#') {
-            throw new IllegalArgumentException("Expected colour literal");
-        }
-        String hex = value.substring(1);
-        if (hex.length() == 3 || hex.length() == 4) {
-            hex = expandShortHex(hex);
-        } else if (hex.length() != 6 && hex.length() != 8) {
-            throw new IllegalArgumentException("Unsupported colour length");
-        }
-        boolean hasAlpha = hex.length() == 8;
-        int offset = hasAlpha ? 2 : 0;
-        double alpha = 0d;
-        if (hasAlpha) {
-            alpha = parseHexByte(hex.substring(0, 2));
-        }
-        double[] rgb = new double[] {
-                parseHexByte(hex.substring(offset, offset + 2)),
-                parseHexByte(hex.substring(offset + 2, offset + 4)),
-                parseHexByte(hex.substring(offset + 4, offset + 6))
-        };
-        return new Operand(rgb, alpha, hasAlpha, true);
-    }
-
-    private static double parseHexByte(String value) {
-        return Integer.parseInt(value, 16);
-    }
-
-    private static int clampChannel(double value) {
-        if (Double.isNaN(value) || Double.isInfinite(value)) {
-            return 0;
-        }
-        if (value <= 0d) {
-            return 0;
-        }
-        if (value >= 255d) {
-            return 255;
-        }
-        return (int) Math.round(value);
-    }
-
-    private static boolean startsWithOperator(String value, int start) {
-        if (start < 0 || start >= value.length()) {
-            return false;
-        }
-        char c = value.charAt(start);
-        return c == '+' || c == '-' || c == '*' || c == '/';
-    }
-
-    private static int findVariantSplit(String value) {
-        if (TextUtils.isEmpty(value)) {
-            return -1;
-        }
-        boolean quoted = false;
+    private static int findTopLevelPipe(String value) {
+        boolean inVector = false;
+        int split = -1;
         for (int i = 0; i < value.length(); i++) {
             char c = value.charAt(i);
-            if (c == '\'') {
-                quoted = !quoted;
+            if (inVector) {
+                if (c == ']') {
+                    inVector = false;
+                }
                 continue;
             }
-            if (!quoted && c == '|') {
-                return i;
-            }
+            if (c == '[') {
+                inVector = true;
+                continue;
             }
+            if (c == '|') {
+                if (split >= 0) {
                     return -1;
                 }
-
-    private static boolean isDark(int color) {
-        double brightness = (Color.red(color) * 299d
-                + Color.green(color) * 587d
-                + Color.blue(color) * 114d) / 1000d;
-        return brightness < 128d;
+                split = i;
+            }
+        }
+        return split;
     }
 
-    private static String hexOperandPattern() {
-        return "#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{4}|[0-9a-fA-F]{3})";
-    }
-
-    private static final class LeadingColour {
-        final int color;
-        final int endIndex;
-
-        LeadingColour(int color, int endIndex) {
-            this.color = color;
-            this.endIndex = endIndex;
-        }
-    }
-
-    private static final class Operand {
-        final double[] rgb;
-        final double alpha;
-        final boolean hasAlpha;
-        final boolean isHex;
-
-        Operand(double[] rgb, double alpha, boolean hasAlpha, boolean isHex) {
-            this.rgb = rgb;
-            this.alpha = alpha;
-            this.hasAlpha = hasAlpha;
-            this.isHex = isHex;
+    private static String hexFor(int color) {
+        if (Color.alpha(color) >= 255) {
+            return String.format(java.util.Locale.ROOT, "#%06X", color & 0xFFFFFF);
         }
+        return String.format(java.util.Locale.ROOT, "#%08X", color);
     }
 }

app/src/main/java/se/ajpanton/statusbartweak/shell/settings/SbtDefaults.java

@@ -51,7 +51,7 @@ public final class SbtDefaults {
     public static final boolean AOD_KEEP_VISIBLE_DURING_CALL_DEFAULT = false;
     public static final boolean BATTERY_LOCKSCREEN_UNPLUGGED_PERCENT_DEFAULT = true;
     public static final boolean BATTERY_AOD_UNPLUGGED_PERCENT_DEFAULT = true;
-    public static final boolean BATTERY_BAR_ENABLED_DEFAULT = false;
+    public static final boolean BATTERY_BAR_ENABLED_DEFAULT = true;
     public static final String BATTERY_BAR_POSITION_DEFAULT = "top";
     public static final String BATTERY_BAR_ALIGNMENT_DEFAULT = "ltr";
     public static final int BATTERY_BAR_THICKNESS_DP_DEFAULT = 2;
@@ -99,6 +99,7 @@ public final class SbtDefaults {
     public static final boolean DEBUG_VISUALIZE_CHIP_CONTAINER_DEFAULT = false;
     public static final boolean DEBUG_VISUALIZE_CAMERA_CUTOUT_DEFAULT = false;
     public static final boolean DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT = false;
+    public static final boolean DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT_DEFAULT = false;
 
     public static final int LAYOUT_PADDING_CUTOUT_PX_DEFAULT = 0;
     public static final int LAYOUT_PADDING_LEFT_PX_DEFAULT = 0;

app/src/main/java/se/ajpanton/statusbartweak/shell/settings/SbtSettings.java

@@ -39,6 +39,8 @@ public final class SbtSettings {
             "debug_visualize_camera_cutout";
     public static final String KEY_DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS =
             "debug_visualize_aod_stock_containers";
+    public static final String KEY_DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT =
+            "debug_experimental_aod_statusbar_root";
     public static final String KEY_LOCKED_NOTIFICATION_MODE =
             "locked_notification_mode";
     public static final String KEY_UNLOCKED_MAX_ICONS_PER_ROW = "unlocked_max_icons_per_row";
@@ -64,6 +66,7 @@ public final class SbtSettings {
     public static final String KEY_STATUS_CHIPS_HIDE_MEDIA_UNLOCKED = "status_chips_hide_media_unlocked";
     public static final String KEY_STATUS_CHIPS_HIDE_NAV_UNLOCKED = "status_chips_hide_nav_unlocked";
     public static final String KEY_STATUS_CHIPS_HIDE_CALL = "status_chips_hide_call";
+    public static final String KEY_STATUS_CHIPS_HIDE_BATTERY = "status_chips_hide_battery";
     public static final String KEY_AOD_KEEP_VISIBLE_DURING_CALL = "aod_keep_visible_during_call";
     public static final String KEY_BATTERY_LOCKSCREEN_UNPLUGGED_PERCENT = "battery_lockscreen_unplugged_percent";
     public static final String KEY_BATTERY_AOD_UNPLUGGED_PERCENT = "battery_aod_unplugged_percent";
@@ -77,13 +80,14 @@ public final class SbtSettings {
     public static final String KEY_BATTERY_BAR_GEOMETRY_OVERRIDE_ENABLED_PREFIX =
             "battery_bar_geometry_override_enabled_";
     public static final String KEY_BATTERY_BAR_GEOMETRY_PREFIX = "battery_bar_geometry_";
+    public static final String KEY_BATTERY_BAR_SCENARIO_ENABLED_PREFIX =
+            "battery_bar_scenario_enabled_";
     public static final String KEY_BATTERY_BAR_MIN_LEVEL = "battery_bar_min_level";
     public static final String KEY_BATTERY_BAR_MAX_LEVEL = "battery_bar_max_level";
     public static final String KEY_BATTERY_BAR_DEFAULT_DISCHARGE_COLOR = "battery_bar_default_discharge_color";
     public static final String KEY_BATTERY_BAR_DEFAULT_CHARGE_COLOR = "battery_bar_default_charge_color";
     public static final String KEY_BATTERY_BAR_THRESHOLDS = "battery_bar_thresholds";
     public static final String BATTERY_BAR_CURVED_GEOMETRY_OFF = "off";
-    public static final String BATTERY_BAR_CURVED_GEOMETRY_HORIZONTAL = "horizontal";
     public static final String BATTERY_BAR_CURVED_GEOMETRY_LENGTH = "length";
     public static final String KEY_CLOCK_ENABLED = "clock_enabled";
     public static final String KEY_CLOCK_ENABLED_LOCKSCREEN = "clock_enabled_lockscreen";
@@ -106,6 +110,7 @@ public final class SbtSettings {
     public static final String KEY_DRAWER_DATE_CUSTOM_FORMAT_ENABLED =
             "drawer_date_custom_format_enabled";
     public static final String KEY_DRAWER_DATE_CUSTOM_FORMAT = "drawer_date_custom_format";
+    public static final String KEY_CLOCK_STORED_PATTERNS = "clock_stored_patterns";
     public static final String KEY_CLOCK_IGNORE_UNDER_DISPLAY_CAMERAS = "clock_ignore_under_display_cameras";
     public static final String KEY_CLOCK_CAMERA_TYPE_OVERRIDES = "clock_camera_type_overrides";
     public static final String KEY_LAYOUT_PADDING_CUTOUT_PX = "layout_padding_cutout_px";
@@ -171,7 +176,6 @@ public final class SbtSettings {
     public static final String KEY_LAYOUT_STATUS_VERTICAL_OFFSET_PX = "layout_status_vertical_offset_px";
     public static final String KEY_LAYOUT_STATUS_ICON_HEIGHT_STEPS = "layout_status_icon_height_steps";
     public static final String KEY_SYSTEM_ICON_BLOCKED_MODES = SystemIconRules.PREF_KEY_BLOCKED_MODES;
-    public static final String KEY_SYSTEM_ICON_HIDE_SLOTS = "system_icon_hide_slots";
     public static final String KEY_SYSTEM_ICON_DUAL_SIM_SIGNAL_MODE = "system_icon_dual_sim_signal_mode";
     public static final String SYSTEM_ICON_DUAL_SIM_SEPARATE = "separate";
     public static final String SYSTEM_ICON_DUAL_SIM_FIRST = "first";
@@ -283,6 +287,10 @@ public final class SbtSettings {
         return KEY_BATTERY_BAR_GEOMETRY_PREFIX + scenarioId;
     }
 
+    public static String batteryBarScenarioEnabledKey(String scenarioId) {
+        return KEY_BATTERY_BAR_SCENARIO_ENABLED_PREFIX + scenarioId;
+    }
+
     private static String suffixedKey(String base, int index) {
         return indexedKey(base, index);
     }
@@ -316,6 +324,7 @@ public final class SbtSettings {
     public final String batteryBarCurvedGeometryMode;
     public final Set<String> batteryBarGeometryOverrideEnabledScenarios;
     public final Map<String, String> batteryBarGeometryOverrides;
+    public final Map<String, Boolean> batteryBarScenarioEnabled;
     public final int batteryBarMinLevel;
     public final int batteryBarMaxLevel;
     public final String batteryBarDefaultDischargeColor;
@@ -408,6 +417,7 @@ public final class SbtSettings {
     public final boolean statusChipsHideMediaUnlocked;
     public final boolean statusChipsHideNavUnlocked;
     public final boolean statusChipsHideCallUnlocked;
+    public final boolean statusChipsHideBattery;
     public final Map<String, Integer> appIconBlockedModes;
     public final Map<String, ArrayList<AppIconRules.ExceptionRule>> appIconExceptionRules;
     public final String lockedNotificationMode;
@@ -417,6 +427,7 @@ public final class SbtSettings {
     public final boolean debugVisualizeChipContainer;
     public final boolean debugVisualizeCameraCutout;
     public final boolean debugVisualizeAodStockContainers;
+    public final boolean debugExperimentalAodStatusbarRoot;
 
     private SbtSettings(boolean enableAodCutoutLimit,
                         boolean enableLockCutoutLimit,
@@ -448,6 +459,7 @@ public final class SbtSettings {
                         String batteryBarCurvedGeometryMode,
                         Set<String> batteryBarGeometryOverrideEnabledScenarios,
                         Map<String, String> batteryBarGeometryOverrides,
+                        Map<String, Boolean> batteryBarScenarioEnabled,
                         int batteryBarMinLevel,
                         int batteryBarMaxLevel,
                         String batteryBarDefaultDischargeColor,
@@ -540,6 +552,7 @@ public final class SbtSettings {
                         boolean statusChipsHideMediaUnlocked,
                         boolean statusChipsHideNavUnlocked,
                         boolean statusChipsHideCallUnlocked,
+                        boolean statusChipsHideBattery,
                         Map<String, Integer> appIconBlockedModes,
                         Map<String, ArrayList<AppIconRules.ExceptionRule>> appIconExceptionRules,
                         String lockedNotificationMode,
@@ -548,7 +561,8 @@ public final class SbtSettings {
                         boolean debugVisualizeClockContainer,
                         boolean debugVisualizeChipContainer,
                         boolean debugVisualizeCameraCutout,
-                        boolean debugVisualizeAodStockContainers) {
+                        boolean debugVisualizeAodStockContainers,
+                        boolean debugExperimentalAodStatusbarRoot) {
         this.enableAodCutoutLimit = enableAodCutoutLimit;
         this.enableLockCutoutLimit = enableLockCutoutLimit;
         this.unlockedMaxIconsPerRow = unlockedMaxIconsPerRow;
@@ -591,6 +605,7 @@ public final class SbtSettings {
         this.batteryBarGeometryOverrideEnabledScenarios =
                 sanitizeBatteryBarScenarioSet(batteryBarGeometryOverrideEnabledScenarios);
         this.batteryBarGeometryOverrides = sanitizeBatteryBarScenarioMap(batteryBarGeometryOverrides);
+        this.batteryBarScenarioEnabled = sanitizeBatteryBarScenarioEnabledMap(batteryBarScenarioEnabled);
         int clampedMinLevel = clampInt(
                 batteryBarMinLevel,
                 SbtDefaults.BATTERY_BAR_MIN_LEVEL_MIN,
@@ -827,6 +842,7 @@ public final class SbtSettings {
         this.statusChipsHideMediaUnlocked = statusChipsHideMediaUnlocked;
         this.statusChipsHideNavUnlocked = statusChipsHideNavUnlocked;
         this.statusChipsHideCallUnlocked = statusChipsHideCallUnlocked;
+        this.statusChipsHideBattery = statusChipsHideBattery;
         this.appIconBlockedModes = appIconBlockedModes != null
                 ? Collections.unmodifiableMap(new HashMap<>(appIconBlockedModes))
                 : Collections.emptyMap();
@@ -849,6 +865,7 @@ public final class SbtSettings {
         this.debugVisualizeChipContainer = debugVisualizeChipContainer;
         this.debugVisualizeCameraCutout = debugVisualizeCameraCutout;
         this.debugVisualizeAodStockContainers = debugVisualizeAodStockContainers;
+        this.debugExperimentalAodStatusbarRoot = debugExperimentalAodStatusbarRoot;
     }
 
     public static SbtSettings defaults() {
@@ -883,6 +900,7 @@ public final class SbtSettings {
                 SbtDefaults.BATTERY_BAR_CURVED_GEOMETRY_MODE_DEFAULT,
                 Collections.emptySet(),
                 Collections.emptyMap(),
+                Collections.emptyMap(),
                 SbtDefaults.BATTERY_BAR_MIN_LEVEL_DEFAULT,
                 SbtDefaults.BATTERY_BAR_MAX_LEVEL_DEFAULT,
                 SbtDefaults.BATTERY_BAR_DEFAULT_DISCHARGE_COLOR_DEFAULT,
@@ -975,6 +993,7 @@ public final class SbtSettings {
                 false,
                 false,
                 false,
+                false,
                 Collections.emptyMap(),
                 Collections.emptyMap(),
                 "dot",
@@ -983,7 +1002,8 @@ public final class SbtSettings {
                 SbtDefaults.DEBUG_VISUALIZE_CLOCK_CONTAINER_DEFAULT,
                 SbtDefaults.DEBUG_VISUALIZE_CHIP_CONTAINER_DEFAULT,
                 SbtDefaults.DEBUG_VISUALIZE_CAMERA_CUTOUT_DEFAULT,
-                SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT
+                SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT,
+                SbtDefaults.DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT_DEFAULT
         );
     }
 
@@ -1011,8 +1031,7 @@ public final class SbtSettings {
     }
 
     public static String readBatteryBarCurvedGeometryMode(String mode) {
-        if (BATTERY_BAR_CURVED_GEOMETRY_HORIZONTAL.equals(mode)
-                || BATTERY_BAR_CURVED_GEOMETRY_LENGTH.equals(mode)) {
+        if (BATTERY_BAR_CURVED_GEOMETRY_LENGTH.equals(mode)) {
             return mode;
         }
         return BATTERY_BAR_CURVED_GEOMETRY_OFF;
@@ -1124,6 +1143,29 @@ public final class SbtSettings {
         }
     }
 
+    public static void setClockCameraDebugState(Context context,
+                                                String cameraId,
+                                                String autoType,
+                                                String effectiveType) {
+        if (context == null || MODULE_PACKAGE.equals(context.getPackageName()) || !hasSettingsProvider(context)) {
+            return;
+        }
+        try {
+            Bundle extras = new Bundle();
+            extras.putString(KEY_DEBUG_CURRENT_CAMERA_ID, cameraId != null ? cameraId : "");
+            extras.putString(KEY_DEBUG_CURRENT_CAMERA_AUTO_TYPE, autoType != null ? autoType : "");
+            extras.putString(KEY_DEBUG_CURRENT_CAMERA_EFFECTIVE_TYPE,
+                    effectiveType != null ? effectiveType : "");
+            context.getContentResolver()
+                    .call(settingsProviderUri(),
+                            SbtSettingsProvider.METHOD_SET_CLOCK_CAMERA_DEBUG_STATE,
+                            null,
+                            extras);
+        } catch (Throwable ignored) {
+            // Debug camera metadata is advisory UI state only.
+        }
+    }
+
     private static boolean hasSettingsProvider(Context context) {
         if (context == null) {
             return false;
@@ -1198,6 +1240,7 @@ public final class SbtSettings {
                         SbtDefaults.BATTERY_BAR_CURVED_GEOMETRY_MODE_DEFAULT),
                 readBatteryBarScenarioSetFromPrefs(prefs),
                 readBatteryBarScenarioMapFromPrefs(prefs),
+                readBatteryBarScenarioEnabledMapFromPrefs(prefs),
                 clampInt(prefs.getInt(KEY_BATTERY_BAR_MIN_LEVEL, SbtDefaults.BATTERY_BAR_MIN_LEVEL_DEFAULT),
                         SbtDefaults.BATTERY_BAR_MIN_LEVEL_MIN,
                         SbtDefaults.BATTERY_BAR_MIN_LEVEL_MAX),
@@ -1287,9 +1330,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         prefs,
                         KEY_LAYOUT_NOTIF_UNLOCKED_COUNT,
-                        KEY_LAYOUT_NOTIF_ENABLED_UNLOCKED,
-                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_NOTIF_ENABLED_UNLOCKED_DEFAULT),
+                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromPrefs(
                         prefs,
                         SbtSettings::layoutNotifPositionKey,
@@ -1305,9 +1346,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         prefs,
                         KEY_LAYOUT_NOTIF_LOCK_COUNT,
-                        KEY_LAYOUT_NOTIF_ENABLED_LOCKSCREEN,
-                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_NOTIF_ENABLED_LOCKSCREEN_DEFAULT),
+                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromPrefs(
                         prefs,
                         SbtSettings::layoutLockNotifPositionKey,
@@ -1323,9 +1362,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         prefs,
                         KEY_LAYOUT_NOTIF_AOD_COUNT,
-                        KEY_LAYOUT_NOTIF_ENABLED_AOD,
-                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_NOTIF_ENABLED_AOD_DEFAULT),
+                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromPrefs(
                         prefs,
                         SbtSettings::layoutAodNotifPositionKey,
@@ -1362,9 +1399,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         prefs,
                         KEY_LAYOUT_STATUS_UNLOCKED_COUNT,
-                        KEY_LAYOUT_STATUS_ENABLED_UNLOCKED,
-                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_STATUS_ENABLED_UNLOCKED_DEFAULT),
+                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromPrefs(
                         prefs,
                         SbtSettings::layoutStatusPositionKey,
@@ -1380,9 +1415,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         prefs,
                         KEY_LAYOUT_STATUS_LOCK_COUNT,
-                        KEY_LAYOUT_STATUS_ENABLED_LOCKSCREEN,
-                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_STATUS_ENABLED_LOCKSCREEN_DEFAULT),
+                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromPrefs(
                         prefs,
                         SbtSettings::layoutLockStatusPositionKey,
@@ -1398,9 +1431,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         prefs,
                         KEY_LAYOUT_STATUS_AOD_COUNT,
-                        KEY_LAYOUT_STATUS_ENABLED_AOD,
-                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_STATUS_ENABLED_AOD_DEFAULT),
+                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromPrefs(
                         prefs,
                         SbtSettings::layoutAodStatusPositionKey,
@@ -1422,6 +1453,7 @@ public final class SbtSettings {
                 prefs.getBoolean(KEY_STATUS_CHIPS_HIDE_MEDIA_UNLOCKED, false),
                 prefs.getBoolean(KEY_STATUS_CHIPS_HIDE_NAV_UNLOCKED, false),
                 prefs.getBoolean(KEY_STATUS_CHIPS_HIDE_CALL, false),
+                prefs.getBoolean(KEY_STATUS_CHIPS_HIDE_BATTERY, false),
                 AppIconRules.parseBlockedModes(readStringSetFromPrefs(
                         prefs,
                         KEY_APP_ICON_BLOCKED_MODES)),
@@ -1446,7 +1478,10 @@ public final class SbtSettings {
                         SbtDefaults.DEBUG_VISUALIZE_CAMERA_CUTOUT_DEFAULT),
                 prefs.getBoolean(
                         KEY_DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS,
-                        SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT)
+                        SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT),
+                prefs.getBoolean(
+                        KEY_DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT,
+                        SbtDefaults.DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT_DEFAULT)
         );
     }
 
@@ -1516,6 +1551,7 @@ public final class SbtSettings {
                         SbtDefaults.BATTERY_BAR_CURVED_GEOMETRY_MODE_DEFAULT),
                 readBatteryBarScenarioSetFromBundle(bundle),
                 readBatteryBarScenarioMapFromBundle(bundle),
+                readBatteryBarScenarioEnabledMapFromBundle(bundle),
                 clampInt(bundle.getInt(KEY_BATTERY_BAR_MIN_LEVEL, SbtDefaults.BATTERY_BAR_MIN_LEVEL_DEFAULT),
                         SbtDefaults.BATTERY_BAR_MIN_LEVEL_MIN,
                         SbtDefaults.BATTERY_BAR_MIN_LEVEL_MAX),
@@ -1605,9 +1641,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         bundle,
                         KEY_LAYOUT_NOTIF_UNLOCKED_COUNT,
-                        KEY_LAYOUT_NOTIF_ENABLED_UNLOCKED,
-                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_NOTIF_ENABLED_UNLOCKED_DEFAULT),
+                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromBundle(
                         bundle,
                         SbtSettings::layoutNotifPositionKey,
@@ -1623,9 +1657,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         bundle,
                         KEY_LAYOUT_NOTIF_LOCK_COUNT,
-                        KEY_LAYOUT_NOTIF_ENABLED_LOCKSCREEN,
-                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_NOTIF_ENABLED_LOCKSCREEN_DEFAULT),
+                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromBundle(
                         bundle,
                         SbtSettings::layoutLockNotifPositionKey,
@@ -1641,9 +1673,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         bundle,
                         KEY_LAYOUT_NOTIF_AOD_COUNT,
-                        KEY_LAYOUT_NOTIF_ENABLED_AOD,
-                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_NOTIF_ENABLED_AOD_DEFAULT),
+                        SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromBundle(
                         bundle,
                         SbtSettings::layoutAodNotifPositionKey,
@@ -1680,9 +1710,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         bundle,
                         KEY_LAYOUT_STATUS_UNLOCKED_COUNT,
-                        KEY_LAYOUT_STATUS_ENABLED_UNLOCKED,
-                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_STATUS_ENABLED_UNLOCKED_DEFAULT),
+                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromBundle(
                         bundle,
                         SbtSettings::layoutStatusPositionKey,
@@ -1698,9 +1726,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         bundle,
                         KEY_LAYOUT_STATUS_LOCK_COUNT,
-                        KEY_LAYOUT_STATUS_ENABLED_LOCKSCREEN,
-                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_STATUS_ENABLED_LOCKSCREEN_DEFAULT),
+                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromBundle(
                         bundle,
                         SbtSettings::layoutLockStatusPositionKey,
@@ -1716,9 +1742,7 @@ public final class SbtSettings {
                 readIconContainerCount(
                         bundle,
                         KEY_LAYOUT_STATUS_AOD_COUNT,
-                        KEY_LAYOUT_STATUS_ENABLED_AOD,
-                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
-                        SbtDefaults.LAYOUT_STATUS_ENABLED_AOD_DEFAULT),
+                        SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT),
                 readStringArrayFromBundle(
                         bundle,
                         SbtSettings::layoutAodStatusPositionKey,
@@ -1740,6 +1764,7 @@ public final class SbtSettings {
                 bundle.getBoolean(KEY_STATUS_CHIPS_HIDE_MEDIA_UNLOCKED, false),
                 bundle.getBoolean(KEY_STATUS_CHIPS_HIDE_NAV_UNLOCKED, false),
                 bundle.getBoolean(KEY_STATUS_CHIPS_HIDE_CALL, false),
+                bundle.getBoolean(KEY_STATUS_CHIPS_HIDE_BATTERY, false),
                 AppIconRules.parseBlockedModes(readStringSetFromBundle(
                         bundle,
                         KEY_APP_ICON_BLOCKED_MODES)),
@@ -1764,7 +1789,10 @@ public final class SbtSettings {
                         SbtDefaults.DEBUG_VISUALIZE_CAMERA_CUTOUT_DEFAULT),
                 bundle.getBoolean(
                         KEY_DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS,
-                        SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT)
+                        SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT),
+                bundle.getBoolean(
+                        KEY_DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT,
+                        SbtDefaults.DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT_DEFAULT)
         );
     }
 
@@ -1791,35 +1819,21 @@ public final class SbtSettings {
     private static int readIconContainerCount(
             SharedPreferences prefs,
             String countKey,
-            String legacyEnabledKey,
-            int defaultCount,
-            boolean legacyEnabledDefault
+            int defaultCount
     ) {
-        int fallback = iconContainerCountFallback(
-                prefs.getBoolean(legacyEnabledKey, legacyEnabledDefault),
-                defaultCount);
-        int value = prefs.getInt(countKey, fallback);
+        int value = prefs.getInt(countKey, defaultCount);
         return clampIconContainerCount(value);
     }
 
     private static int readIconContainerCount(
             Bundle bundle,
             String countKey,
-            String legacyEnabledKey,
-            int defaultCount,
-            boolean legacyEnabledDefault
+            int defaultCount
     ) {
-        int fallback = iconContainerCountFallback(
-                bundle.getBoolean(legacyEnabledKey, legacyEnabledDefault),
-                defaultCount);
-        int value = bundle.getInt(countKey, fallback);
+        int value = bundle.getInt(countKey, defaultCount);
         return clampIconContainerCount(value);
     }
 
-    private static int iconContainerCountFallback(boolean legacyEnabled, int defaultCount) {
-        return legacyEnabled ? defaultCount : 0;
-    }
-
     private static String[] readStringArrayFromPrefs(
             SharedPreferences prefs,
             IndexedKey key,
@@ -1958,6 +1972,34 @@ public final class SbtSettings {
         return result;
     }
 
+    private static Map<String, Boolean> readBatteryBarScenarioEnabledMapFromPrefs(SharedPreferences prefs) {
+        if (prefs == null) {
+            return Collections.emptyMap();
+        }
+        HashMap<String, Boolean> result = new HashMap<>();
+        for (BatteryBarGeometry.Scenario scenario : BatteryBarGeometry.Scenario.values()) {
+            String key = batteryBarScenarioEnabledKey(scenario.id);
+            if (prefs.contains(key)) {
+                result.put(scenario.id, prefs.getBoolean(key, true));
+            }
+        }
+        return result;
+    }
+
+    private static Map<String, Boolean> readBatteryBarScenarioEnabledMapFromBundle(Bundle bundle) {
+        if (bundle == null) {
+            return Collections.emptyMap();
+        }
+        HashMap<String, Boolean> result = new HashMap<>();
+        for (BatteryBarGeometry.Scenario scenario : BatteryBarGeometry.Scenario.values()) {
+            String key = batteryBarScenarioEnabledKey(scenario.id);
+            if (bundle.containsKey(key)) {
+                result.put(scenario.id, bundle.getBoolean(key, true));
+            }
+        }
+        return result;
+    }
+
     private static Set<String> sanitizeBatteryBarScenarioSet(Set<String> source) {
         if (source == null || source.isEmpty()) {
             return Collections.emptySet();
@@ -1986,6 +2028,21 @@ public final class SbtSettings {
         return result.isEmpty() ? Collections.emptyMap() : Collections.unmodifiableMap(result);
     }
 
+    private static Map<String, Boolean> sanitizeBatteryBarScenarioEnabledMap(Map<String, Boolean> source) {
+        if (source == null || source.isEmpty()) {
+            return Collections.emptyMap();
+        }
+        HashMap<String, Boolean> result = new HashMap<>();
+        for (Map.Entry<String, Boolean> entry : source.entrySet()) {
+            String id = entry.getKey();
+            Boolean value = entry.getValue();
+            if (isBatteryBarScenarioId(id) && value != null) {
+                result.put(id, value);
+            }
+        }
+        return result.isEmpty() ? Collections.emptyMap() : Collections.unmodifiableMap(result);
+    }
+
     private static boolean isBatteryBarScenarioId(String id) {
         if (id == null) {
             return false;
@@ -2004,9 +2061,7 @@ public final class SbtSettings {
         }
         Map<String, Integer> parsed = SystemIconRules.parseBlockedModes(
                 readStringSetFromPrefs(prefs, KEY_SYSTEM_ICON_BLOCKED_MODES));
-        HashMap<String, Integer> merged = new HashMap<>(parsed);
-        mergeLegacySystemIconHidden(merged, readStringSetFromPrefs(prefs, KEY_SYSTEM_ICON_HIDE_SLOTS));
-        return merged.isEmpty() ? Collections.emptyMap() : merged;
+        return parsed.isEmpty() ? Collections.emptyMap() : parsed;
     }
 
     private static Map<String, Integer> readSystemIconBlockedModesFromBundle(Bundle bundle) {
@@ -2015,20 +2070,7 @@ public final class SbtSettings {
         }
         Map<String, Integer> parsed = SystemIconRules.parseBlockedModes(
                 readStringSetFromBundle(bundle, KEY_SYSTEM_ICON_BLOCKED_MODES));
-        HashMap<String, Integer> merged = new HashMap<>(parsed);
-        mergeLegacySystemIconHidden(merged, readStringSetFromBundle(bundle, KEY_SYSTEM_ICON_HIDE_SLOTS));
-        return merged.isEmpty() ? Collections.emptyMap() : merged;
-    }
-
-    private static void mergeLegacySystemIconHidden(HashMap<String, Integer> merged, Set<String> legacyHidden) {
-        if (merged == null || legacyHidden == null || legacyHidden.isEmpty()) {
-            return;
-        }
-        for (String slot : legacyHidden) {
-            SystemIconRules.setModeBlocked(merged, slot,
-                    SystemIconRules.MODE_AOD | SystemIconRules.MODE_LOCK | SystemIconRules.MODE_UNLOCK,
-                    true);
-        }
+        return parsed.isEmpty() ? Collections.emptyMap() : parsed;
     }
 
     public static void ensureReadable(Context context) {

app/src/main/java/se/ajpanton/statusbartweak/shell/settings/SbtSettingsProvider.java

@@ -107,8 +107,12 @@ public class SbtSettingsProvider extends ContentProvider {
             for (BatteryBarGeometry.Scenario scenario : BatteryBarGeometry.Scenario.values()) {
                 String enabledKey = BatteryBarGeometry.enabledKey(scenario);
                 String valueKey = BatteryBarGeometry.valueKey(scenario);
+                String scenarioEnabledKey = SbtSettings.batteryBarScenarioEnabledKey(scenario.id);
                 out.putBoolean(enabledKey, prefs.getBoolean(enabledKey, false));
                 out.putString(valueKey, prefs.getString(valueKey, null));
+                if (prefs.contains(scenarioEnabledKey)) {
+                    out.putBoolean(scenarioEnabledKey, prefs.getBoolean(scenarioEnabledKey, true));
+                }
             }
             out.putInt(SbtSettings.KEY_BATTERY_BAR_MIN_LEVEL,
                     prefs.getInt(SbtSettings.KEY_BATTERY_BAR_MIN_LEVEL, SbtDefaults.BATTERY_BAR_MIN_LEVEL_DEFAULT));
@@ -191,6 +195,9 @@ public class SbtSettingsProvider extends ContentProvider {
             out.putBoolean(SbtSettings.KEY_DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS,
                     prefs.getBoolean(SbtSettings.KEY_DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS,
                             SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT));
+            out.putBoolean(SbtSettings.KEY_DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT,
+                    prefs.getBoolean(SbtSettings.KEY_DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT,
+                            SbtDefaults.DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT_DEFAULT));
             out.putInt(SbtSettings.KEY_LAYOUT_PADDING_CUTOUT_PX,
                     prefs.getInt(SbtSettings.KEY_LAYOUT_PADDING_CUTOUT_PX,
                             SbtDefaults.LAYOUT_PADDING_CUTOUT_PX_DEFAULT));
@@ -261,11 +268,7 @@ public class SbtSettingsProvider extends ContentProvider {
                             SbtDefaults.LAYOUT_NOTIF_ENABLED_UNLOCKED_DEFAULT));
             out.putInt(SbtSettings.KEY_LAYOUT_NOTIF_UNLOCKED_COUNT,
                     prefs.getInt(SbtSettings.KEY_LAYOUT_NOTIF_UNLOCKED_COUNT,
-                            prefs.getBoolean(
-                                    SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_UNLOCKED,
-                                    SbtDefaults.LAYOUT_NOTIF_ENABLED_UNLOCKED_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
+                            SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT));
             out.putString(SbtSettings.KEY_LAYOUT_NOTIF_MIDDLE_SIDE,
                     prefs.getString(SbtSettings.KEY_LAYOUT_NOTIF_MIDDLE_SIDE,
                             SbtDefaults.LAYOUT_NOTIF_MIDDLE_SIDE_DEFAULT));
@@ -286,11 +289,7 @@ public class SbtSettingsProvider extends ContentProvider {
                     SbtDefaults.LAYOUT_NOTIF_VERTICAL_OFFSET_PX_DEFAULT);
             out.putInt(SbtSettings.KEY_LAYOUT_NOTIF_LOCK_COUNT,
                     prefs.getInt(SbtSettings.KEY_LAYOUT_NOTIF_LOCK_COUNT,
-                            prefs.getBoolean(
-                                    SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_LOCKSCREEN,
-                                    SbtDefaults.LAYOUT_NOTIF_ENABLED_LOCKSCREEN_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
+                            SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT));
             out.putInt(SbtSettings.layoutLockNotifIconHeightKey(),
                     prefs.getInt(SbtSettings.layoutLockNotifIconHeightKey(),
                             SbtDefaults.LAYOUT_NOTIF_LOCK_ICON_HEIGHT_STEPS_DEFAULT));
@@ -305,11 +304,7 @@ public class SbtSettingsProvider extends ContentProvider {
                     SbtDefaults.LAYOUT_NOTIF_VERTICAL_OFFSET_PX_DEFAULT);
             out.putInt(SbtSettings.KEY_LAYOUT_NOTIF_AOD_COUNT,
                     prefs.getInt(SbtSettings.KEY_LAYOUT_NOTIF_AOD_COUNT,
-                            prefs.getBoolean(
-                                    SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_AOD,
-                                    SbtDefaults.LAYOUT_NOTIF_ENABLED_AOD_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
+                            SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT));
             out.putInt(SbtSettings.layoutAodNotifIconHeightKey(),
                     prefs.getInt(SbtSettings.layoutAodNotifIconHeightKey(),
                             SbtDefaults.LAYOUT_NOTIF_AOD_ICON_HEIGHT_STEPS_DEFAULT));
@@ -336,11 +331,7 @@ public class SbtSettingsProvider extends ContentProvider {
                             SbtDefaults.LAYOUT_STATUS_ENABLED_UNLOCKED_DEFAULT));
             out.putInt(SbtSettings.KEY_LAYOUT_STATUS_UNLOCKED_COUNT,
                     prefs.getInt(SbtSettings.KEY_LAYOUT_STATUS_UNLOCKED_COUNT,
-                            prefs.getBoolean(
-                                    SbtSettings.KEY_LAYOUT_STATUS_ENABLED_UNLOCKED,
-                                    SbtDefaults.LAYOUT_STATUS_ENABLED_UNLOCKED_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
+                            SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT));
             out.putString(SbtSettings.KEY_LAYOUT_STATUS_MIDDLE_SIDE,
                     prefs.getString(SbtSettings.KEY_LAYOUT_STATUS_MIDDLE_SIDE,
                             SbtDefaults.LAYOUT_STATUS_MIDDLE_SIDE_DEFAULT));
@@ -365,11 +356,7 @@ public class SbtSettingsProvider extends ContentProvider {
                             SbtDefaults.SYSTEM_ICON_DUAL_SIM_SIGNAL_MODE_DEFAULT)));
             out.putInt(SbtSettings.KEY_LAYOUT_STATUS_LOCK_COUNT,
                     prefs.getInt(SbtSettings.KEY_LAYOUT_STATUS_LOCK_COUNT,
-                            prefs.getBoolean(
-                                    SbtSettings.KEY_LAYOUT_STATUS_ENABLED_LOCKSCREEN,
-                                    SbtDefaults.LAYOUT_STATUS_ENABLED_LOCKSCREEN_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
+                            SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT));
             out.putInt(SbtSettings.layoutLockStatusIconHeightKey(),
                     prefs.getInt(SbtSettings.layoutLockStatusIconHeightKey(),
                             SbtDefaults.LAYOUT_STATUS_ICON_HEIGHT_STEPS_DEFAULT));
@@ -384,11 +371,7 @@ public class SbtSettingsProvider extends ContentProvider {
                     SbtDefaults.LAYOUT_STATUS_VERTICAL_OFFSET_PX_DEFAULT);
             out.putInt(SbtSettings.KEY_LAYOUT_STATUS_AOD_COUNT,
                     prefs.getInt(SbtSettings.KEY_LAYOUT_STATUS_AOD_COUNT,
-                            prefs.getBoolean(
-                                    SbtSettings.KEY_LAYOUT_STATUS_ENABLED_AOD,
-                                    SbtDefaults.LAYOUT_STATUS_ENABLED_AOD_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
+                            SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT));
             out.putInt(SbtSettings.layoutAodStatusIconHeightKey(),
                     prefs.getInt(SbtSettings.layoutAodStatusIconHeightKey(),
                             SbtDefaults.LAYOUT_STATUS_ICON_HEIGHT_STEPS_DEFAULT));
@@ -403,7 +386,6 @@ public class SbtSettingsProvider extends ContentProvider {
                     SbtDefaults.LAYOUT_STATUS_VERTICAL_OFFSET_PX_DEFAULT);
             putStringSetArrayList(out, prefs, SbtSettings.KEY_CLOCK_CAMERA_TYPE_OVERRIDES);
             putStringSetArrayList(out, prefs, SbtSettings.KEY_SYSTEM_ICON_BLOCKED_MODES);
-            putStringSetArrayList(out, prefs, SbtSettings.KEY_SYSTEM_ICON_HIDE_SLOTS);
             out.putBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_ALL,
                     prefs.getBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_ALL, false));
             out.putBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_MEDIA_UNLOCKED,
@@ -412,6 +394,8 @@ public class SbtSettingsProvider extends ContentProvider {
                     prefs.getBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_NAV_UNLOCKED, false));
             out.putBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_CALL,
                     prefs.getBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_CALL, false));
+            out.putBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_BATTERY,
+                    prefs.getBoolean(SbtSettings.KEY_STATUS_CHIPS_HIDE_BATTERY, false));
             putStringCollectionArrayList(
                     out,
                     SbtSettings.KEY_APP_ICON_BLOCKED_MODES,

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/ClockFragment.java

@@ -1,6 +1,7 @@
 package se.ajpanton.statusbartweak.shell.ui;
 
 import se.ajpanton.statusbartweak.R;
+import se.ajpanton.statusbartweak.runtime.features.clock.ClockPatternPreviewRenderer;
 import se.ajpanton.statusbartweak.shell.settings.SbtDefaults;
 import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
 
@@ -8,6 +9,9 @@ import android.content.ClipData;
 import android.content.ClipboardManager;
 import android.content.Context;
 import android.content.SharedPreferences;
+import android.graphics.Color;
+import android.graphics.drawable.GradientDrawable;
+import android.net.Uri;
 import android.graphics.Typeface;
 import android.os.Bundle;
 import android.text.Editable;
@@ -30,18 +34,49 @@ import android.widget.Toast;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
+import androidx.core.content.ContextCompat;
 import androidx.fragment.app.Fragment;
 
 import com.google.android.material.button.MaterialButton;
+import com.google.android.material.card.MaterialCardView;
 import com.google.android.material.dialog.MaterialAlertDialogBuilder;
 
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 
 public final class ClockFragment extends Fragment {
+    private static final String PATTERN_ORIGIN_STATUSBAR = "statusbar";
+    private static final String PATTERN_ORIGIN_DRAWER_CLOCK = "drawer_clock";
+    private static final String PATTERN_ORIGIN_DRAWER_DATE = "drawer_date";
+    private static final int COLOR_STATUSBAR = 0xffe85050;
+    private static final int COLOR_DRAWER_CLOCK = 0xff4caf50;
+    private static final int COLOR_DRAWER_DATE = 0xff4f8cff;
+    private static final int CARD_STROKE_DP = 2;
+
+    private final ArrayList<PreviewBinding> previewBindings = new ArrayList<>();
+    private final ArrayList<StoredPatternBinding> storedPatternBindings = new ArrayList<>();
+    private final ArrayList<StoredPatternRowBinding> storedPatternRowBindings = new ArrayList<>();
+    private final Runnable previewTicker = new Runnable() {
+        @Override
+        public void run() {
+            boolean needsNextTick = false;
+            HashMap<String, ClockPatternPreviewRenderer.Result> renderCache = new HashMap<>();
+            for (PreviewBinding binding : previewBindings) {
+                needsNextTick |= updatePreview(binding);
+            }
+            for (StoredPatternRowBinding binding : storedPatternRowBindings) {
+                needsNextTick |= updateStoredPatternPreview(binding, renderCache);
+            }
+            if (needsNextTick && getView() != null) {
+                getView().postDelayed(this, nextSecondDelayMillis());
+            }
+        }
+    };
 
     @Nullable
     @Override
@@ -52,22 +87,35 @@ public final class ClockFragment extends Fragment {
         SharedPreferences prefs = requireContext()
                 .getSharedPreferences(SbtSettings.PREFS_NAME, Context.MODE_PRIVATE);
 
+        MaterialCardView customFormatCard = root.findViewById(R.id.clock_custom_format_card);
         CheckBox customFormatEnabled = root.findViewById(R.id.clock_custom_format_enabled);
         View customFormatContainer = root.findViewById(R.id.clock_custom_format_container);
         EditText customFormatInput = root.findViewById(R.id.clock_custom_format_input);
+        ClockPatternPreviewView customFormatPreview =
+                root.findViewById(R.id.clock_custom_format_preview);
+        MaterialCardView drawerClockCustomFormatCard =
+                root.findViewById(R.id.drawer_clock_custom_format_card);
         CheckBox drawerClockCustomFormatEnabled =
                 root.findViewById(R.id.drawer_clock_custom_format_enabled);
         View drawerClockCustomFormatContainer =
                 root.findViewById(R.id.drawer_clock_custom_format_container);
         EditText drawerClockCustomFormatInput =
                 root.findViewById(R.id.drawer_clock_custom_format_input);
+        ClockPatternPreviewView drawerClockCustomFormatPreview =
+                root.findViewById(R.id.drawer_clock_custom_format_preview);
+        MaterialCardView drawerDateCustomFormatCard =
+                root.findViewById(R.id.drawer_date_custom_format_card);
         CheckBox drawerDateCustomFormatEnabled =
                 root.findViewById(R.id.drawer_date_custom_format_enabled);
         View drawerDateCustomFormatContainer =
                 root.findViewById(R.id.drawer_date_custom_format_container);
         EditText drawerDateCustomFormatInput =
                 root.findViewById(R.id.drawer_date_custom_format_input);
+        ClockPatternPreviewView drawerDateCustomFormatPreview =
+                root.findViewById(R.id.drawer_date_custom_format_preview);
         MaterialButton fontPickerButton = root.findViewById(R.id.clock_font_picker_button);
+        MaterialButton restoreStoredPatternsButton =
+                root.findViewById(R.id.clock_restore_stored_patterns_button);
         TextView customFormatHelpToggle = root.findViewById(R.id.clock_custom_format_help_toggle);
         View customFormatHelpContainer = root.findViewById(R.id.clock_custom_format_help_container);
         TextView customFormatHelpCommon = root.findViewById(R.id.clock_custom_format_help);
@@ -94,27 +142,54 @@ public final class ClockFragment extends Fragment {
                 SbtSettings.KEY_DRAWER_DATE_CUSTOM_FORMAT,
                 SbtDefaults.DRAWER_DATE_CUSTOM_FORMAT_DEFAULT);
 
-        customFormatEnabled.setChecked(customFormatEnabledValue);
-        customFormatInput.setText(customFormatValue);
-        updateCustomFormatVisibility(customFormatContainer, customFormatEnabledValue);
+        previewBindings.clear();
+        storedPatternBindings.clear();
+        ensureDefaultStoredPatterns(prefs);
         bindCustomFormat(
                 prefs,
+                customFormatCard,
+                customFormatEnabled,
+                customFormatContainer,
+                customFormatInput,
+                customFormatPreview,
+                PATTERN_ORIGIN_STATUSBAR,
+                COLOR_STATUSBAR,
+                SbtSettings.KEY_CLOCK_CUSTOM_FORMAT_ENABLED,
+                SbtSettings.KEY_CLOCK_CUSTOM_FORMAT,
+                customFormatEnabledValue,
+                customFormatValue,
+                18f,
+                true);
+        bindCustomFormat(
+                prefs,
+                drawerClockCustomFormatCard,
                 drawerClockCustomFormatEnabled,
                 drawerClockCustomFormatContainer,
                 drawerClockCustomFormatInput,
+                drawerClockCustomFormatPreview,
+                PATTERN_ORIGIN_DRAWER_CLOCK,
+                COLOR_DRAWER_CLOCK,
                 SbtSettings.KEY_DRAWER_CLOCK_CUSTOM_FORMAT_ENABLED,
                 SbtSettings.KEY_DRAWER_CLOCK_CUSTOM_FORMAT,
                 drawerClockCustomFormatEnabledValue,
-                drawerClockCustomFormatValue);
+                drawerClockCustomFormatValue,
+                24f,
+                false);
         bindCustomFormat(
                 prefs,
+                drawerDateCustomFormatCard,
                 drawerDateCustomFormatEnabled,
                 drawerDateCustomFormatContainer,
                 drawerDateCustomFormatInput,
+                drawerDateCustomFormatPreview,
+                PATTERN_ORIGIN_DRAWER_DATE,
+                COLOR_DRAWER_DATE,
                 SbtSettings.KEY_DRAWER_DATE_CUSTOM_FORMAT_ENABLED,
                 SbtSettings.KEY_DRAWER_DATE_CUSTOM_FORMAT,
                 drawerDateCustomFormatEnabledValue,
-                drawerDateCustomFormatValue);
+                drawerDateCustomFormatValue,
+                16f,
+                false);
         updateCustomFormatHelpVisibility(customFormatHelpContainer, customFormatHelpToggle, false);
         applyBulletText(customFormatHelpCommon);
         applyBulletText(customFormatHelpStyling);
@@ -123,12 +198,6 @@ public final class ClockFragment extends Fragment {
             customFormatHelpLink.setMovementMethod(LinkMovementMethod.getInstance());
         }
 
-        customFormatEnabled.setOnCheckedChangeListener((buttonView, isChecked) -> {
-            updateCustomFormatVisibility(customFormatContainer, isChecked);
-            prefs.edit().putBoolean(SbtSettings.KEY_CLOCK_CUSTOM_FORMAT_ENABLED, isChecked).apply();
-            SbtSettings.ensureReadable(requireContext());
-        });
-
         if (customFormatHelpToggle != null) {
             customFormatHelpToggle.setOnClickListener(v -> updateCustomFormatHelpVisibility(
                     customFormatHelpContainer,
@@ -136,27 +205,15 @@ public final class ClockFragment extends Fragment {
                     customFormatHelpContainer == null || customFormatHelpContainer.getVisibility() != View.VISIBLE));
         }
 
-        customFormatInput.addTextChangedListener(new TextWatcher() {
-            @Override
-            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
-            }
-
-            @Override
-            public void onTextChanged(CharSequence s, int start, int before, int count) {
-            }
-
-            @Override
-            public void afterTextChanged(Editable s) {
-                prefs.edit()
-                        .putString(SbtSettings.KEY_CLOCK_CUSTOM_FORMAT, s != null ? s.toString() : "")
-                        .apply();
-                SbtSettings.ensureReadable(requireContext());
-            }
-        });
-
         if (fontPickerButton != null) {
             fontPickerButton.setOnClickListener(v -> showFontPickerDialog());
         }
+        if (restoreStoredPatternsButton != null) {
+            restoreStoredPatternsButton.setOnClickListener(v -> {
+                persistStoredPatterns(prefs, mergeDefaultPatterns(loadStoredPatterns(prefs)));
+                renderAllStoredPatternLists(prefs);
+            });
+        }
 
         return root;
     }
@@ -169,23 +226,53 @@ public final class ClockFragment extends Fragment {
     }
 
     private void bindCustomFormat(SharedPreferences prefs,
+                                  MaterialCardView card,
                                   CheckBox enabledView,
                                   View container,
                                   EditText input,
+                                  ClockPatternPreviewView preview,
+                                  String origin,
+                                  int accentColor,
                                   String enabledKey,
                                   String formatKey,
                                   boolean enabled,
-                                  String format) {
+                                  String format,
+                                  float previewTextSizeSp,
+                                  boolean multilinePreview) {
         if (enabledView == null || input == null) {
             return;
         }
+        styleClockCard(card, accentColor);
+        styleBorderedView(input, accentColor, 6, 8, 6);
+        styleBorderedView(preview, accentColor, 8, 10, 8);
         enabledView.setChecked(enabled);
         input.setText(format != null ? format : "");
+        if (preview != null) {
+            preview.setPreviewTextAppearance(
+                    requireContext().getColor(R.color.sbt_on_surface),
+                    previewTextSizeSp);
+        }
         updateCustomFormatVisibility(container, enabled);
+        PreviewBinding binding = new PreviewBinding(enabledView, input, preview, multilinePreview);
+        previewBindings.add(binding);
+        StoredPatternBinding storedBinding = createStoredPatternSection(
+                prefs,
+                container,
+                input,
+                origin,
+                accentColor,
+                multilinePreview);
+        if (storedBinding != null) {
+            storedPatternBindings.add(storedBinding);
+            renderStoredPatternList(prefs, storedBinding);
+        }
+        updatePreview(binding);
         enabledView.setOnCheckedChangeListener((buttonView, isChecked) -> {
             updateCustomFormatVisibility(container, isChecked);
             prefs.edit().putBoolean(enabledKey, isChecked).apply();
             SbtSettings.ensureReadable(requireContext());
+            updatePreview(binding);
+            schedulePreviewTickerIfNeeded();
         });
         input.addTextChangedListener(new TextWatcher() {
             @Override
@@ -202,10 +289,501 @@ public final class ClockFragment extends Fragment {
                         .putString(formatKey, s != null ? s.toString() : "")
                         .apply();
                 SbtSettings.ensureReadable(requireContext());
+                updatePreview(binding);
+                schedulePreviewTickerIfNeeded();
             }
         });
     }
 
+    private void styleClockCard(MaterialCardView card, int accentColor) {
+        if (card == null) {
+            return;
+        }
+        card.setStrokeWidth(ViewTreeSupport.dp(card.getContext(), CARD_STROKE_DP));
+        card.setStrokeColor(accentColor);
+    }
+
+    private void styleBorderedView(View view,
+                                   int accentColor,
+                                   int radiusDp,
+                                   int horizontalPaddingDp,
+                                   int verticalPaddingDp) {
+        if (view == null) {
+            return;
+        }
+        Context context = view.getContext();
+        GradientDrawable background = new GradientDrawable();
+        background.setColor(Color.TRANSPARENT);
+        background.setCornerRadius(ViewTreeSupport.dp(context, radiusDp));
+        background.setStroke(ViewTreeSupport.dp(context, CARD_STROKE_DP), accentColor);
+        view.setBackground(background);
+        view.setPadding(
+                ViewTreeSupport.dp(context, horizontalPaddingDp),
+                ViewTreeSupport.dp(context, verticalPaddingDp),
+                ViewTreeSupport.dp(context, horizontalPaddingDp),
+                ViewTreeSupport.dp(context, verticalPaddingDp));
+    }
+
+    private StoredPatternBinding createStoredPatternSection(
+            SharedPreferences prefs,
+            View container,
+            EditText input,
+            String origin,
+            int accentColor,
+            boolean multilinePreview
+    ) {
+        if (!(container instanceof LinearLayout parent) || input == null) {
+            return null;
+        }
+        Context context = parent.getContext();
+        MaterialButton toggle = new MaterialButton(
+                context,
+                null,
+                com.google.android.material.R.attr.materialButtonOutlinedStyle);
+        toggle.setText(R.string.clock_stored_patterns_show);
+        LinearLayout.LayoutParams toggleParams = new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+        toggleParams.topMargin = ViewTreeSupport.dp(context, 12);
+        parent.addView(toggle, toggleParams);
+
+        LinearLayout section = new LinearLayout(context);
+        section.setOrientation(LinearLayout.VERTICAL);
+        section.setVisibility(View.GONE);
+        parent.addView(section, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        TextView hint = new TextView(context);
+        hint.setText(R.string.clock_stored_patterns_hint);
+        hint.setTextAppearance(android.R.style.TextAppearance_Material_Body2);
+        LinearLayout.LayoutParams hintParams = new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+        hintParams.topMargin = ViewTreeSupport.dp(context, 8);
+        section.addView(hint, hintParams);
+
+        LinearLayout list = new LinearLayout(context);
+        list.setOrientation(LinearLayout.VERTICAL);
+        section.addView(list, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        MaterialButton storeButton = new MaterialButton(
+                context,
+                null,
+                com.google.android.material.R.attr.materialButtonOutlinedStyle);
+        storeButton.setText(R.string.clock_store_current_pattern);
+        LinearLayout.LayoutParams storeParams = new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+        storeParams.topMargin = ViewTreeSupport.dp(context, 8);
+        section.addView(storeButton, storeParams);
+
+        StoredPatternBinding binding = new StoredPatternBinding(
+                input,
+                origin,
+                accentColor,
+                multilinePreview,
+                toggle,
+                section,
+                list);
+        toggle.setOnClickListener(v -> {
+            boolean show = section.getVisibility() != View.VISIBLE;
+            section.setVisibility(show ? View.VISIBLE : View.GONE);
+            toggle.setText(show
+                    ? R.string.clock_stored_patterns_hide
+                    : R.string.clock_stored_patterns_show);
+            if (show) {
+                renderStoredPatternList(prefs, binding);
+            } else {
+                removeStoredPatternRowsFor(binding);
+                list.removeAllViews();
+                schedulePreviewTickerIfNeeded();
+            }
+        });
+        storeButton.setOnClickListener(v -> {
+            String pattern = input.getText() != null ? input.getText().toString() : "";
+            storePattern(prefs, pattern, origin);
+            renderAllStoredPatternLists(prefs);
+        });
+        return binding;
+    }
+
+    private void renderAllStoredPatternLists(SharedPreferences prefs) {
+        for (StoredPatternBinding binding : storedPatternBindings) {
+            renderStoredPatternList(prefs, binding);
+        }
+    }
+
+    private void renderStoredPatternList(SharedPreferences prefs, StoredPatternBinding binding) {
+        if (binding == null || binding.listContainer == null) {
+            return;
+        }
+        Context context = binding.listContainer.getContext();
+        removeStoredPatternRowsFor(binding);
+        binding.listContainer.removeAllViews();
+        if (binding.section == null || binding.section.getVisibility() != View.VISIBLE) {
+            schedulePreviewTickerIfNeeded();
+            return;
+        }
+        ArrayList<StoredPattern> patterns = loadStoredPatterns(prefs);
+        for (StoredPattern pattern : patterns) {
+            binding.listContainer.addView(createStoredPatternRow(context, prefs, binding, pattern));
+        }
+        schedulePreviewTickerIfNeeded();
+    }
+
+    private View createStoredPatternRow(
+            Context context,
+            SharedPreferences prefs,
+            StoredPatternBinding binding,
+            StoredPattern pattern
+    ) {
+        LinearLayout row = new LinearLayout(context);
+        row.setOrientation(LinearLayout.HORIZONTAL);
+        row.setGravity(android.view.Gravity.CENTER_VERTICAL);
+        LinearLayout.LayoutParams rowParams = new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+        rowParams.topMargin = ViewTreeSupport.dp(context, 8);
+        row.setLayoutParams(rowParams);
+
+        ClockPatternPreviewView preview = new ClockPatternPreviewView(context);
+        preview.setPreviewTextAppearance(
+                requireContext().getColor(R.color.sbt_on_surface),
+                previewTextSizeForOrigin(pattern.origin));
+        styleBorderedView(preview, colorForOrigin(pattern.origin), 8, 10, 8);
+        StoredPatternRowBinding rowBinding = new StoredPatternRowBinding(
+                binding,
+                preview,
+                pattern.pattern,
+                normaliseOrigin(pattern.origin),
+                binding.multilinePreview);
+        storedPatternRowBindings.add(rowBinding);
+        updateStoredPatternPreview(rowBinding, new HashMap<>());
+        preview.setOnClickListener(v -> {
+            binding.input.setText(pattern.pattern);
+            binding.input.setSelection(binding.input.getText() != null
+                    ? binding.input.getText().length()
+                    : 0);
+        });
+        row.addView(preview, new LinearLayout.LayoutParams(
+                0,
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                1f));
+
+        MaterialButton deleteButton = new MaterialButton(context);
+        deleteButton.setText("×");
+        deleteButton.setTextColor(Color.WHITE);
+        deleteButton.setBackgroundTintList(android.content.res.ColorStateList.valueOf(
+                ContextCompat.getColor(context, R.color.sbt_danger)));
+        deleteButton.setMinWidth(0);
+        deleteButton.setMinHeight(0);
+        deleteButton.setPadding(0, 0, 0, 0);
+        deleteButton.setOnClickListener(v -> {
+            deleteStoredPattern(prefs, pattern.pattern);
+            renderAllStoredPatternLists(prefs);
+        });
+        LinearLayout.LayoutParams deleteParams = new LinearLayout.LayoutParams(
+                ViewTreeSupport.dp(context, 44),
+                ViewTreeSupport.dp(context, 44));
+        deleteParams.leftMargin = ViewTreeSupport.dp(context, 8);
+        row.addView(deleteButton, deleteParams);
+        return row;
+    }
+
+    private void removeStoredPatternRowsFor(StoredPatternBinding binding) {
+        for (int i = storedPatternRowBindings.size() - 1; i >= 0; i--) {
+            if (storedPatternRowBindings.get(i).owner == binding) {
+                storedPatternRowBindings.remove(i);
+            }
+        }
+    }
+
+    private void ensureDefaultStoredPatterns(SharedPreferences prefs) {
+        if (prefs == null || prefs.contains(SbtSettings.KEY_CLOCK_STORED_PATTERNS)) {
+            return;
+        }
+        persistStoredPatterns(prefs, defaultStoredPatterns());
+    }
+
+    private ArrayList<StoredPattern> mergeDefaultPatterns(ArrayList<StoredPattern> current) {
+        ArrayList<StoredPattern> result = current != null ? current : new ArrayList<>();
+        for (StoredPattern pattern : defaultStoredPatterns()) {
+            upsertPattern(result, pattern.pattern, pattern.origin);
+        }
+        return result;
+    }
+
+    private ArrayList<StoredPattern> defaultStoredPatterns() {
+        ArrayList<StoredPattern> patterns = new ArrayList<>();
+        patterns.add(new StoredPattern("H:mm:ss", PATTERN_ORIGIN_STATUSBAR));
+        patterns.add(new StoredPattern("{big}H:mm:{/big color(#batterybar)}ss", PATTERN_ORIGIN_STATUSBAR));
+        patterns.add(new StoredPattern(
+                "{@sans-serif-condensed-light color(#fff;#000)}|d{\\n30 big}H:mm:|{/big color(#batterybar invRGB 0.5 *RGB invRGB;#batterybar 0.5 *RGB)}ss",
+                PATTERN_ORIGIN_STATUSBAR));
+        patterns.add(new StoredPattern("{@sans-serif-condensed-light}H:mm:{small}ss", PATTERN_ORIGIN_DRAWER_CLOCK));
+        patterns.add(new StoredPattern("EEE, d MMM", PATTERN_ORIGIN_DRAWER_DATE));
+        patterns.add(new StoredPattern("EEE, MMM d", PATTERN_ORIGIN_DRAWER_DATE));
+        patterns.add(new StoredPattern("{@sans-serif-condensed-light}EEEE, MMMM d", PATTERN_ORIGIN_DRAWER_DATE));
+        patterns.add(new StoredPattern("{@sans-serif-condensed-light}EEEE, d MMMM", PATTERN_ORIGIN_DRAWER_DATE));
+        return patterns;
+    }
+
+    private void storePattern(SharedPreferences prefs, String pattern, String origin) {
+        String value = pattern != null ? pattern.trim() : "";
+        if (value.isEmpty()) {
+            return;
+        }
+        ArrayList<StoredPattern> patterns = loadStoredPatterns(prefs);
+        upsertPattern(patterns, value, origin);
+        persistStoredPatterns(prefs, patterns);
+    }
+
+    private void upsertPattern(ArrayList<StoredPattern> patterns, String pattern, String origin) {
+        if (patterns == null || pattern == null || pattern.trim().isEmpty()) {
+            return;
+        }
+        String value = pattern.trim();
+        String resolvedOrigin = normaliseOrigin(origin);
+        for (int i = 0; i < patterns.size(); i++) {
+            StoredPattern existing = patterns.get(i);
+            if (existing != null && value.equals(existing.pattern)) {
+                patterns.set(i, new StoredPattern(value, resolvedOrigin));
+                return;
+            }
+        }
+        patterns.add(new StoredPattern(value, resolvedOrigin));
+    }
+
+    private void deleteStoredPattern(SharedPreferences prefs, String pattern) {
+        ArrayList<StoredPattern> patterns = loadStoredPatterns(prefs);
+        for (int i = patterns.size() - 1; i >= 0; i--) {
+            StoredPattern existing = patterns.get(i);
+            if (existing != null && existing.pattern.equals(pattern)) {
+                patterns.remove(i);
+            }
+        }
+        persistStoredPatterns(prefs, patterns);
+    }
+
+    private ArrayList<StoredPattern> loadStoredPatterns(SharedPreferences prefs) {
+        ArrayList<StoredPattern> patterns = new ArrayList<>();
+        if (prefs == null) {
+            return patterns;
+        }
+        String encoded = prefs.getString(SbtSettings.KEY_CLOCK_STORED_PATTERNS, "");
+        if (encoded == null || encoded.isEmpty()) {
+            return patterns;
+        }
+        String[] lines = encoded.split("\\n", -1);
+        for (String line : lines) {
+            StoredPattern pattern = decodeStoredPattern(line);
+            if (pattern == null) {
+                continue;
+            }
+            upsertPattern(patterns, pattern.pattern, pattern.origin);
+        }
+        return patterns;
+    }
+
+    private void persistStoredPatterns(SharedPreferences prefs, ArrayList<StoredPattern> patterns) {
+        if (prefs == null) {
+            return;
+        }
+        StringBuilder encoded = new StringBuilder();
+        if (patterns != null) {
+            for (StoredPattern pattern : patterns) {
+                if (pattern == null || pattern.pattern == null || pattern.pattern.trim().isEmpty()) {
+                    continue;
+                }
+                if (encoded.length() > 0) {
+                    encoded.append('\n');
+                }
+                encoded.append(normaliseOrigin(pattern.origin))
+                        .append('|')
+                        .append(Uri.encode(pattern.pattern));
+            }
+        }
+        prefs.edit().putString(SbtSettings.KEY_CLOCK_STORED_PATTERNS, encoded.toString()).apply();
+    }
+
+    private StoredPattern decodeStoredPattern(String line) {
+        if (line == null || line.isEmpty()) {
+            return null;
+        }
+        int split = line.indexOf('|');
+        if (split <= 0 || split >= line.length() - 1) {
+            return null;
+        }
+        String origin = normaliseOrigin(line.substring(0, split));
+        String pattern = Uri.decode(line.substring(split + 1));
+        if (pattern == null || pattern.trim().isEmpty()) {
+            return null;
+        }
+        return new StoredPattern(pattern.trim(), origin);
+    }
+
+    private String normaliseOrigin(String origin) {
+        if (PATTERN_ORIGIN_DRAWER_CLOCK.equals(origin)
+                || PATTERN_ORIGIN_DRAWER_DATE.equals(origin)
+                || PATTERN_ORIGIN_STATUSBAR.equals(origin)) {
+            return origin;
+        }
+        return PATTERN_ORIGIN_STATUSBAR;
+    }
+
+    private int colorForOrigin(String origin) {
+        switch (normaliseOrigin(origin)) {
+            case PATTERN_ORIGIN_DRAWER_CLOCK:
+                return COLOR_DRAWER_CLOCK;
+            case PATTERN_ORIGIN_DRAWER_DATE:
+                return COLOR_DRAWER_DATE;
+            case PATTERN_ORIGIN_STATUSBAR:
+            default:
+                return COLOR_STATUSBAR;
+        }
+    }
+
+    private float previewTextSizeForOrigin(String origin) {
+        switch (normaliseOrigin(origin)) {
+            case PATTERN_ORIGIN_DRAWER_CLOCK:
+                return 24f;
+            case PATTERN_ORIGIN_DRAWER_DATE:
+                return 16f;
+            case PATTERN_ORIGIN_STATUSBAR:
+            default:
+                return 18f;
+        }
+    }
+
+    private boolean updatePreview(PreviewBinding binding) {
+        if (binding == null || binding.preview == null) {
+            return false;
+        }
+        boolean enabled = binding.enabled != null && binding.enabled.isChecked();
+        String pattern = binding.input != null && binding.input.getText() != null
+                ? binding.input.getText().toString()
+                : "";
+        if (!enabled || pattern.isEmpty()) {
+            binding.preview.setVisibility(View.GONE);
+            binding.preview.setPreview(null);
+            binding.preview.setContentDescription("");
+            return false;
+        }
+        ClockPatternPreviewRenderer.Result result = ClockPatternPreviewRenderer.render(
+                binding.preview.getContext(),
+                pattern,
+                binding.preview.getPreviewTextColor());
+        if (!binding.multilinePreview) {
+            result = flattenRows(result);
+        }
+        binding.preview.setPreview(result);
+        binding.preview.setVisibility(result.rows().isEmpty() ? View.GONE : View.VISIBLE);
+        binding.preview.setContentDescription(result.contentDescription());
+        return result.containsSeconds();
+    }
+
+    private boolean updateStoredPatternPreview(
+            StoredPatternRowBinding binding,
+            Map<String, ClockPatternPreviewRenderer.Result> cache
+    ) {
+        if (binding == null
+                || binding.preview == null
+                || binding.owner == null
+                || binding.owner.section == null
+                || binding.owner.section.getVisibility() != View.VISIBLE) {
+            return false;
+        }
+        String key = binding.origin + "\u0000" + binding.multilinePreview + "\u0000" + binding.pattern;
+        ClockPatternPreviewRenderer.Result result = cache != null ? cache.get(key) : null;
+        if (result == null) {
+            result = ClockPatternPreviewRenderer.render(
+                    binding.preview.getContext(),
+                    binding.pattern,
+                    binding.preview.getPreviewTextColor());
+            if (!binding.multilinePreview) {
+                result = flattenRows(result);
+            }
+            if (cache != null) {
+                cache.put(key, result);
+            }
+        }
+        binding.preview.setPreview(result);
+        binding.preview.setContentDescription(result.contentDescription());
+        return result.containsSeconds();
+    }
+
+    private ClockPatternPreviewRenderer.Result flattenRows(ClockPatternPreviewRenderer.Result result) {
+        if (result == null || result.rows() == null || result.rows().size() <= 1) {
+            return result;
+        }
+        SpannableStringBuilder text = new SpannableStringBuilder();
+        StringBuilder description = new StringBuilder();
+        for (int i = 0; i < result.rows().size(); i++) {
+            ClockPatternPreviewRenderer.Row row = result.rows().get(i);
+            if (i > 0) {
+                text.append(' ');
+                description.append(' ');
+            }
+            if (row != null && row.text() != null) {
+                text.append(row.text());
+                description.append(row.text());
+            }
+        }
+        ArrayList<ClockPatternPreviewRenderer.Row> rows = new ArrayList<>();
+        rows.add(new ClockPatternPreviewRenderer.Row(text, "", "", 0, 0));
+        return new ClockPatternPreviewRenderer.Result(rows, description.toString(), result.containsSeconds());
+    }
+
+    private void schedulePreviewTickerIfNeeded() {
+        View view = getView();
+        if (view == null) {
+            return;
+        }
+        view.removeCallbacks(previewTicker);
+        for (PreviewBinding binding : previewBindings) {
+            if (updatePreview(binding)) {
+                view.postDelayed(previewTicker, nextSecondDelayMillis());
+                return;
+            }
+        }
+    }
+
+    private long nextSecondDelayMillis() {
+        long now = System.currentTimeMillis();
+        long next = now - (now % 1000L) + 1000L;
+        return Math.max(1L, next - now);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        schedulePreviewTickerIfNeeded();
+    }
+
+    @Override
+    public void onPause() {
+        View view = getView();
+        if (view != null) {
+            view.removeCallbacks(previewTicker);
+        }
+        super.onPause();
+    }
+
+    @Override
+    public void onDestroyView() {
+        View view = getView();
+        if (view != null) {
+            view.removeCallbacks(previewTicker);
+        }
+        previewBindings.clear();
+        storedPatternBindings.clear();
+        storedPatternRowBindings.clear();
+        super.onDestroyView();
+    }
+
     private void updateCustomFormatHelpVisibility(View helpContainer,
                                                   TextView helpToggle,
                                                   boolean visible) {
@@ -354,6 +932,32 @@ public final class ClockFragment extends Fragment {
         view.setText(builder);
     }
 
+    private record PreviewBinding(CheckBox enabled, EditText input, ClockPatternPreviewView preview, boolean multilinePreview) {
+    }
+
+    private record StoredPatternBinding(
+            EditText input,
+            String origin,
+            int accentColor,
+            boolean multilinePreview,
+            MaterialButton toggle,
+            View section,
+            LinearLayout listContainer
+    ) {
+    }
+
+    private record StoredPatternRowBinding(
+            StoredPatternBinding owner,
+            ClockPatternPreviewView preview,
+            String pattern,
+            String origin,
+            boolean multilinePreview
+    ) {
+    }
+
+    private record StoredPattern(String pattern, String origin) {
+    }
+
     private static final class FontFamilyAdapter extends BaseAdapter {
         private static final String SAMPLE_PATTERN = "EEEE HH:mm:ss";
 

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/ClockPatternPreviewView.java

@@ -0,0 +1,228 @@
+package se.ajpanton.statusbartweak.shell.ui;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.text.Layout;
+import android.text.StaticLayout;
+import android.text.TextPaint;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.View;
+
+import java.util.ArrayList;
+
+import se.ajpanton.statusbartweak.runtime.features.clock.ClockPatternPreviewRenderer;
+import se.ajpanton.statusbartweak.shell.settings.SbtDefaults;
+
+public final class ClockPatternPreviewView extends View {
+    private final TextPaint textPaint = new TextPaint(TextPaint.ANTI_ALIAS_FLAG);
+    private final ArrayList<MeasuredRow> measuredRows = new ArrayList<>();
+    private ClockPatternPreviewRenderer.Result result;
+    private int textColor;
+    private float textSizePx;
+    private int contentWidth;
+    private int contentHeight;
+
+    public ClockPatternPreviewView(Context context) {
+        super(context);
+    }
+
+    public ClockPatternPreviewView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public void setPreviewTextAppearance(int color, float sizeSp) {
+        textColor = color;
+        textSizePx = TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_SP,
+                sizeSp,
+                getResources().getDisplayMetrics());
+        textPaint.setColor(textColor);
+        textPaint.setTextSize(textSizePx);
+        rebuildMeasurements();
+    }
+
+    public int getPreviewTextColor() {
+        return textColor;
+    }
+
+    public void setPreview(ClockPatternPreviewRenderer.Result nextResult) {
+        result = nextResult;
+        rebuildMeasurements();
+    }
+
+    private void rebuildMeasurements() {
+        measuredRows.clear();
+        contentWidth = 0;
+        contentHeight = 0;
+        if (result == null || result.rows() == null || result.rows().isEmpty()) {
+            requestLayout();
+            invalidate();
+            return;
+        }
+        int leftColumnWidth = 0;
+        int rightColumnWidth = 0;
+        int baseRowHeight = measureText("0").height;
+        for (ClockPatternPreviewRenderer.Row row : result.rows()) {
+            MeasuredRow measured = measureRow(row);
+            measuredRows.add(measured);
+            if (measured.piped) {
+                leftColumnWidth = Math.max(leftColumnWidth, measured.left.width);
+                rightColumnWidth = Math.max(rightColumnWidth, measured.right.width);
+            } else {
+                contentWidth = Math.max(contentWidth, measured.full.width);
+            }
+        }
+        if (leftColumnWidth > 0 || rightColumnWidth > 0) {
+            contentWidth = Math.max(contentWidth, leftColumnWidth + rightColumnWidth);
+            for (MeasuredRow measured : measuredRows) {
+                measured.leftColumnWidth = leftColumnWidth;
+            }
+        }
+        positionRows(Math.max(1, baseRowHeight));
+        requestLayout();
+        invalidate();
+    }
+
+    private MeasuredRow measureRow(ClockPatternPreviewRenderer.Row row) {
+        if (row != null && row.pipeCount() > 0) {
+            MeasuredText left = measureText(row.leftText());
+            MeasuredText right = measureText(row.rightText());
+            return MeasuredRow.piped(left, right, row.gapBeforePx());
+        }
+        return MeasuredRow.full(measureText(row != null ? row.text() : ""), row != null ? row.gapBeforePx() : 0);
+    }
+
+    private MeasuredText measureText(CharSequence text) {
+        CharSequence safeText = text != null ? text : "";
+        if (TextUtils.isEmpty(safeText)) {
+            safeText = " ";
+        }
+        int width = Math.max(1, (int) Math.ceil(Layout.getDesiredWidth(safeText, textPaint)));
+        StaticLayout layout = StaticLayout.Builder
+                .obtain(safeText, 0, safeText.length(), textPaint, width)
+                .setAlignment(Layout.Alignment.ALIGN_NORMAL)
+                .setIncludePad(false)
+                .setLineSpacing(0f, 1f)
+                .build();
+        if (layout.getLineCount() <= 0) {
+            TextPaint.FontMetricsInt metrics = textPaint.getFontMetricsInt();
+            int ascent = -metrics.ascent;
+            int descent = metrics.descent;
+            return new MeasuredText(layout, width, Math.max(1, ascent + descent), ascent, descent);
+        }
+        int baseline = layout.getLineBaseline(0);
+        int ascent = Math.max(0, baseline - layout.getLineTop(0));
+        int descent = Math.max(0, layout.getLineBottom(0) - baseline);
+        return new MeasuredText(layout, width, Math.max(1, ascent + descent), ascent, descent);
+    }
+
+    private void positionRows(int baseRowHeight) {
+        if (measuredRows.isEmpty()) {
+            return;
+        }
+        int minTop = Integer.MAX_VALUE;
+        int maxBottom = Integer.MIN_VALUE;
+        int bottom = 0;
+        for (int i = 0; i < measuredRows.size(); i++) {
+            MeasuredRow row = measuredRows.get(i);
+            if (i == 0) {
+                bottom = row.height;
+            } else {
+                bottom += resolveGapPx(row.gapBeforePx, baseRowHeight);
+            }
+            int top = bottom - row.height;
+            row.drawTop = top;
+            minTop = Math.min(minTop, top);
+            maxBottom = Math.max(maxBottom, bottom);
+        }
+        for (MeasuredRow row : measuredRows) {
+            row.drawTop -= minTop;
+        }
+        contentHeight = Math.max(1, maxBottom - minTop);
+    }
+
+    private int resolveGapPx(int gapBefore, int baseRowHeight) {
+        if (gapBefore == ClockPatternPreviewRenderer.ROW_GAP_AUTO) {
+            return Math.max(1, baseRowHeight);
+        }
+        if (gapBefore == 0) {
+            return 0;
+        }
+        int defaultSteps = Math.max(1, SbtDefaults.CLOCK_TEXT_SIZE_STEPS_DEFAULT);
+        return Math.max(1, Math.round(gapBefore * Math.max(1, baseRowHeight) / (float) defaultSteps));
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        int desiredWidth = getPaddingLeft() + contentWidth + getPaddingRight();
+        int desiredHeight = getPaddingTop() + contentHeight + getPaddingBottom();
+        setMeasuredDimension(
+                resolveSize(desiredWidth, widthMeasureSpec),
+                resolveSize(desiredHeight, heightMeasureSpec));
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        for (MeasuredRow row : measuredRows) {
+            int y = getPaddingTop() + row.drawTop;
+            if (row.piped) {
+                drawText(canvas, row.left, getPaddingLeft() + row.leftColumnWidth - row.left.width, y + row.ascent - row.left.ascent);
+                drawText(canvas, row.right, getPaddingLeft() + row.leftColumnWidth, y + row.ascent - row.right.ascent);
+            } else {
+                drawText(canvas, row.full, getPaddingLeft(), y);
+            }
+        }
+    }
+
+    private void drawText(Canvas canvas, MeasuredText text, int left, int top) {
+        if (text == null || text.layout == null) {
+            return;
+        }
+        int save = canvas.save();
+        canvas.translate(left, top);
+        text.layout.draw(canvas);
+        canvas.restoreToCount(save);
+    }
+
+    private static final class MeasuredRow {
+        final boolean piped;
+        final MeasuredText full;
+        final MeasuredText left;
+        final MeasuredText right;
+        final int height;
+        final int ascent;
+        final int descent;
+        final int gapBeforePx;
+        int leftColumnWidth;
+        int drawTop;
+
+        private MeasuredRow(boolean piped, MeasuredText full, MeasuredText left, MeasuredText right, int gapBeforePx) {
+            this.piped = piped;
+            this.full = full;
+            this.left = left;
+            this.right = right;
+            this.gapBeforePx = gapBeforePx;
+            this.ascent = piped
+                    ? Math.max(left != null ? left.ascent : 0, right != null ? right.ascent : 0)
+                    : full != null ? full.ascent : 0;
+            this.descent = piped
+                    ? Math.max(left != null ? left.descent : 0, right != null ? right.descent : 0)
+                    : full != null ? full.descent : 0;
+            this.height = Math.max(1, ascent + descent);
+        }
+
+        static MeasuredRow full(MeasuredText text, int gapBeforePx) {
+            return new MeasuredRow(false, text, null, null, gapBeforePx);
+        }
+
+        static MeasuredRow piped(MeasuredText left, MeasuredText right, int gapBeforePx) {
+            return new MeasuredRow(true, null, left, right, gapBeforePx);
+        }
+    }
+
+    private record MeasuredText(StaticLayout layout, int width, int height, int ascent, int descent) {
+    }
+}

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/IconsDebugFragment.java

@@ -27,6 +27,7 @@ import java.util.HashMap;
 import java.util.Map;
 
 import se.ajpanton.statusbartweak.R;
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.shell.debug.DebugNotifications;
 import se.ajpanton.statusbartweak.shell.settings.ClockCameraTypeSupport;
 import se.ajpanton.statusbartweak.shell.settings.SbtDefaults;
@@ -64,6 +65,8 @@ public class IconsDebugFragment extends Fragment {
         SwitchMaterial visualizeAodStockContainersSwitch =
                 root.findViewById(R.id.debug_visualize_aod_stock_containers_switch);
         MaterialButton restartSystemUiButton = root.findViewById(R.id.debug_restart_systemui_button);
+        SwitchMaterial experimentalAodStatusbarRootSwitch =
+                root.findViewById(R.id.debug_experimental_aod_statusbar_root_switch);
         SwitchMaterial cycleIconsSwitch = root.findViewById(R.id.debug_cycle_icons_switch);
         TextView currentCameraIdentified = root.findViewById(R.id.debug_camera_current_identified);
         LinearLayout currentCameraOverrideRow = root.findViewById(R.id.debug_camera_current_override_row);
@@ -137,6 +140,18 @@ public class IconsDebugFragment extends Fragment {
                 SbtSettings.KEY_DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS,
                 SbtDefaults.DEBUG_VISUALIZE_AOD_STOCK_CONTAINERS_DEFAULT,
                 true);
+        ViewTreeSupport.bindBooleanPreference(
+                requireContext(),
+                prefs,
+                experimentalAodStatusbarRootSwitch,
+                SbtSettings.KEY_DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT,
+                SbtDefaults.DEBUG_EXPERIMENTAL_AOD_STATUSBAR_ROOT_DEFAULT,
+                true);
+        if (SystemUiCapabilities.isSamsungOneUi()
+                && experimentalAodStatusbarRootSwitch != null) {
+            experimentalAodStatusbarRootSwitch.setChecked(false);
+            experimentalAodStatusbarRootSwitch.setEnabled(false);
+        }
         bindRestartSystemUiButton(restartSystemUiButton);
         updateVisualizerSwitchAvailability(
                 prefs,
@@ -338,7 +353,8 @@ public class IconsDebugFragment extends Fragment {
 
         if (TextUtils.isEmpty(cameraId)) {
             identifiedView.setText(getString(R.string.debug_camera_identified_as,
-                    getString(R.string.debug_camera_unknown)));
+                    getString(R.string.debug_camera_unknown),
+                    ""));
             if (overrideRow != null) {
                 overrideRow.setVisibility(View.GONE);
             }
@@ -352,7 +368,8 @@ public class IconsDebugFragment extends Fragment {
                     : ClockCameraTypeSupport.normalizeType(effectiveTypeFromReport));
             identifiedView.setText(getString(
                     R.string.debug_camera_identified_as,
-                    readableType(currentAutoType)));
+                    readableType(currentAutoType),
+                    cameraId));
 
             if (overrideRow != null && overrideView != null && actionButton != null) {
                 overrideRow.setVisibility(View.VISIBLE);

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/LayoutFragment.java

@@ -17,6 +17,7 @@ import android.view.inputmethod.EditorInfo;
 import android.widget.CheckBox;
 import android.widget.EditText;
 import android.widget.LinearLayout;
+import android.widget.RadioButton;
 import android.widget.RadioGroup;
 import android.widget.TextView;
 
@@ -148,8 +149,6 @@ public final class LayoutFragment extends Fragment {
                 R.string.layout_notification_position_title,
                 SbtSettings.KEY_LAYOUT_NOTIF_UNLOCKED_COUNT,
                 SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
-                SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_UNLOCKED,
-                SbtDefaults.LAYOUT_NOTIF_ENABLED_UNLOCKED_DEFAULT,
                 SbtSettings::layoutNotifPositionKey,
                 SbtSettings::layoutNotifMiddleSideKey,
                 SbtSettings::layoutNotifVerticalOffsetKey,
@@ -166,8 +165,6 @@ public final class LayoutFragment extends Fragment {
                 R.string.layout_status_position_title,
                 SbtSettings.KEY_LAYOUT_STATUS_UNLOCKED_COUNT,
                 SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
-                SbtSettings.KEY_LAYOUT_STATUS_ENABLED_UNLOCKED,
-                SbtDefaults.LAYOUT_STATUS_ENABLED_UNLOCKED_DEFAULT,
                 SbtSettings::layoutStatusPositionKey,
                 SbtSettings::layoutStatusMiddleSideKey,
                 SbtSettings::layoutStatusVerticalOffsetKey,
@@ -187,8 +184,6 @@ public final class LayoutFragment extends Fragment {
             int sectionTitleId,
             String countKey,
             int countDefault,
-            String legacyEnabledKey,
-            boolean legacyEnabledDefault,
             SbtSettings.IndexedKey positionKey,
             SbtSettings.IndexedKey middleSideKey,
             SbtSettings.IndexedKey verticalOffsetKey,
@@ -223,9 +218,7 @@ public final class LayoutFragment extends Fragment {
             int count = ViewTreeSupport.iconContainerCount(
                     prefs,
                     countKey,
-                    legacyEnabledKey,
-                    countDefault,
-                    legacyEnabledDefault);
+                    countDefault);
             LayoutXmlCardSupport.setIndexedCardTitle(requireContext(), sourceCard, sectionTitleId, 0, count);
             setCompatPadding(sourceCard, count <= 1);
             boolean cardsMode = LockedNotificationModeUi.MODE_CARDS.equals(
@@ -246,7 +239,6 @@ public final class LayoutFragment extends Fragment {
                                     requireContext(),
                                     prefs,
                                     countKey,
-                            legacyEnabledKey,
                                     value),
                     () -> {
                         if (rebuild[0] != null) {
@@ -868,15 +860,30 @@ public final class LayoutFragment extends Fragment {
     }
 
     private int resolveLeftSideId(RadioGroup group) {
-        int id = group.getChildCount() > 0 ? group.getChildAt(0).getId() : View.NO_ID;
+        int id = sideButtonId(group, 0);
         return id != View.NO_ID ? id : 0;
     }
 
     private int resolveRightSideId(RadioGroup group) {
-        int id = group.getChildCount() > 1 ? group.getChildAt(1).getId() : View.NO_ID;
+        int id = sideButtonId(group, 1);
         return id != View.NO_ID ? id : resolveLeftSideId(group);
     }
 
+    private int sideButtonId(RadioGroup group, int radioIndex) {
+        int seen = 0;
+        for (int i = 0; i < group.getChildCount(); i++) {
+            View child = group.getChildAt(i);
+            if (!(child instanceof RadioButton)) {
+                continue;
+            }
+            if (seen == radioIndex) {
+                return child.getId();
+            }
+            seen++;
+        }
+        return View.NO_ID;
+    }
+
     private void setNumericText(EditText input, int value) {
         if (input == null) {
             return;

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/LockedNotificationModeUi.java

@@ -9,6 +9,7 @@ import android.widget.TextView;
 import android.widget.Toast;
 
 import se.ajpanton.statusbartweak.R;
+import se.ajpanton.statusbartweak.platform.SystemUiCapabilities;
 import se.ajpanton.statusbartweak.shell.debug.NotificationDisplayStyleSettings;
 import se.ajpanton.statusbartweak.shell.settings.SbtSettings;
 
@@ -40,6 +41,10 @@ final class LockedNotificationModeUi {
             return;
         }
         group.setOnCheckedChangeListener(null);
+        if (!SystemUiCapabilities.supportsSamsungNotificationDisplayStyles()) {
+            bindIconsOnly(context, prefs, group, hint);
+            return;
+        }
         RadioButton cards = button(context, R.string.debug_notification_style_cards, MODE_CARDS);
         RadioButton icons = button(context, R.string.debug_notification_style_icons, MODE_ICONS);
         RadioButton dot = button(context, R.string.debug_notification_style_dot, MODE_DOT);
@@ -76,7 +81,31 @@ final class LockedNotificationModeUi {
         });
     }
 
+    private static void bindIconsOnly(
+            Context context,
+            SharedPreferences prefs,
+            RadioGroup group,
+            TextView hint
+    ) {
+        RadioButton icons = button(context, R.string.debug_notification_style_icons, MODE_ICONS);
+        group.removeAllViews();
+        group.addView(icons);
+        group.check(icons.getId());
+        group.setEnabled(false);
+        icons.setEnabled(false);
+        if (hint != null) {
+            hint.setText(R.string.layout_locked_notifications_hint_icons_only);
+        }
+        if (!MODE_ICONS.equals(prefs.getString(SbtSettings.KEY_LOCKED_NOTIFICATION_MODE, MODE_ICONS))) {
+            prefs.edit().putString(SbtSettings.KEY_LOCKED_NOTIFICATION_MODE, MODE_ICONS).apply();
+            SbtSettings.ensureReadable(context);
+        }
+    }
+
     static String currentMode(Context context) {
+        if (!SystemUiCapabilities.supportsSamsungNotificationDisplayStyles()) {
+            return MODE_ICONS;
+        }
         NotificationDisplayStyleSettings.Style style =
                 NotificationDisplayStyleSettings.read(context).style();
         return currentMode(style);

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/LockedSceneLayoutFragment.java

@@ -10,6 +10,7 @@ import android.view.ViewGroup;
 import android.widget.CheckBox;
 import android.widget.EditText;
 import android.widget.LinearLayout;
+import android.widget.RadioButton;
 import android.widget.RadioGroup;
 import android.widget.ScrollView;
 import android.widget.TextView;
@@ -173,8 +174,6 @@ abstract class LockedSceneLayoutFragment extends Fragment {
                 R.id.status_vertical_offset_plus_fast,
                 R.id.status_vertical_offset_reset,
                 R.string.layout_status_position_title,
-                aod ? SbtSettings.KEY_LAYOUT_STATUS_ENABLED_AOD : SbtSettings.KEY_LAYOUT_STATUS_ENABLED_LOCKSCREEN,
-                aod ? SbtDefaults.LAYOUT_STATUS_ENABLED_AOD_DEFAULT : SbtDefaults.LAYOUT_STATUS_ENABLED_LOCKSCREEN_DEFAULT,
                 SbtDefaults.LAYOUT_STATUS_POSITION_DEFAULT,
                 SbtDefaults.LAYOUT_STATUS_MIDDLE_SIDE_DEFAULT,
                 SbtDefaults.LAYOUT_STATUS_VERTICAL_OFFSET_PX_DEFAULT,
@@ -205,8 +204,6 @@ abstract class LockedSceneLayoutFragment extends Fragment {
                     R.id.notif_vertical_offset_plus_fast,
                     R.id.notif_vertical_offset_reset,
                     R.string.layout_notification_position_title,
-                    aod ? SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_AOD : SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_LOCKSCREEN,
-                    aod ? SbtDefaults.LAYOUT_NOTIF_ENABLED_AOD_DEFAULT : SbtDefaults.LAYOUT_NOTIF_ENABLED_LOCKSCREEN_DEFAULT,
                     SbtDefaults.LAYOUT_NOTIF_POSITION_DEFAULT,
                     SbtDefaults.LAYOUT_NOTIF_MIDDLE_SIDE_DEFAULT,
                     SbtDefaults.LAYOUT_NOTIF_VERTICAL_OFFSET_PX_DEFAULT,
@@ -305,8 +302,6 @@ abstract class LockedSceneLayoutFragment extends Fragment {
             int verticalPlusFastId,
             int verticalResetId,
             int titleId,
-            String legacyEnabledKey,
-            boolean legacyEnabledDefault,
             String positionDefault,
             String middleSideDefault,
             int verticalOffsetDefault,
@@ -324,9 +319,7 @@ abstract class LockedSceneLayoutFragment extends Fragment {
             int count = ViewTreeSupport.iconContainerCount(
                     prefs,
                     countKey,
-                    legacyEnabledKey,
-                    1,
-                    legacyEnabledDefault);
+                    1);
             View primary = configuredIconContainerCard(
                     context,
                     prefs,
@@ -354,7 +347,6 @@ abstract class LockedSceneLayoutFragment extends Fragment {
                     verticalOffsetDefault,
                     iconHeightKey,
                     iconHeightDefault,
-                    legacyEnabledKey,
                     countKey,
                     count,
                     rebuild[0]);
@@ -390,7 +382,6 @@ abstract class LockedSceneLayoutFragment extends Fragment {
                         null,
                         0,
                         null,
-                        null,
                         count,
                         null);
                 setTopMargin(context, copy, 0);
@@ -452,7 +443,6 @@ abstract class LockedSceneLayoutFragment extends Fragment {
             int verticalOffsetDefault,
             @Nullable String iconHeightKey,
             int iconHeightDefault,
-            @Nullable String legacyEnabledKey,
             @Nullable String countKey,
             int count,
             @Nullable Runnable onCountChanged
@@ -470,7 +460,6 @@ abstract class LockedSceneLayoutFragment extends Fragment {
                                     context,
                                     prefs,
                                     countKey,
-                                    legacyEnabledKey,
                                     value),
                             onCountChanged),
                     insertIndex);
@@ -787,7 +776,7 @@ abstract class LockedSceneLayoutFragment extends Fragment {
     private int firstSideId(RadioGroup group, int rightId) {
         for (int i = 0; i < group.getChildCount(); i++) {
             View child = group.getChildAt(i);
-            if (child.getId() != rightId) {
+            if (child instanceof RadioButton && child.getId() != rightId) {
                 return child.getId();
             }
         }

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/MainActivity.java

@@ -5,10 +5,15 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.view.Menu;
 import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
 
+import androidx.activity.OnBackPressedCallback;
 import androidx.annotation.NonNull;
 import androidx.appcompat.app.ActionBarDrawerToggle;
 import androidx.appcompat.app.AppCompatActivity;
+import androidx.drawerlayout.widget.DrawerLayout;
 import androidx.core.graphics.Insets;
 import androidx.core.view.GravityCompat;
 import androidx.core.view.ViewCompat;
@@ -22,10 +27,18 @@ import se.ajpanton.statusbartweak.R;
 
 public class MainActivity extends AppCompatActivity implements NavigationView.OnNavigationItemSelectedListener {
     private static final String EXTRA_OPEN_NAV_ITEM = "open_nav_item";
+    private static final String STATE_CURRENT_ITEM_ID = "current_item_id";
+    private static final float PERMANENT_SIDEBAR_FOLDED_WIDTH_MULTIPLIER = 1.1f;
 
     private SafeInsetDrawerLayout drawerLayout;
-    private NavigationView navigationView;
-    private Integer navigationBasePaddingLeft;
+    private NavigationView drawerNavigationView;
+    private NavigationView permanentNavigationView;
+    private MaterialToolbar toolbar;
+    private ActionBarDrawerToggle drawerToggle;
+    private Integer drawerNavigationBasePaddingLeft;
+    private Integer permanentNavigationBasePaddingLeft;
+    private boolean permanentSidebar;
+    private int currentItemId = R.id.nav_layout;
 
     public static Intent newOpenDebugIntent(Context context) {
         Intent intent = new Intent(context, MainActivity.class);
@@ -39,34 +52,63 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
 
-        MaterialToolbar toolbar = findViewById(R.id.toolbar);
+        toolbar = findViewById(R.id.toolbar);
         setSupportActionBar(toolbar);
 
         drawerLayout = findViewById(R.id.drawer_layout);
-        navigationView = findViewById(R.id.nav_view);
-        navigationView.setNavigationItemSelectedListener(this);
-        navigationView.getMenu().setGroupCheckable(0, true, true);
+        drawerNavigationView = findViewById(R.id.nav_view_drawer);
+        permanentNavigationView = findViewById(R.id.nav_view_permanent);
+        setupNavigationView(drawerNavigationView);
+        setupNavigationView(permanentNavigationView);
         applyNavigationDrawerInsets();
-
-        ActionBarDrawerToggle toggle = new ActionBarDrawerToggle(
+        drawerToggle = new ActionBarDrawerToggle(
                 this,
                 drawerLayout,
                 toolbar,
                 R.string.nav_open,
                 R.string.nav_close
         );
-        drawerLayout.addDrawerListener(toggle);
-        toggle.syncState();
+        drawerLayout.addDrawerListener(drawerToggle);
+        drawerToggle.syncState();
+        toolbar.setNavigationOnClickListener(v -> {
+            if (!permanentSidebar) {
+                drawerLayout.openDrawer(GravityCompat.START);
+            }
+        });
+        getOnBackPressedDispatcher().addCallback(this, new OnBackPressedCallback(true) {
+            @Override
+            public void handleOnBackPressed() {
+                if (!permanentSidebar && drawerLayout.isDrawerOpen(GravityCompat.START)) {
+                    drawerLayout.closeDrawer(GravityCompat.START);
+                    return;
+                }
+                setEnabled(false);
+                getOnBackPressedDispatcher().onBackPressed();
+                setEnabled(true);
+            }
+        });
 
+        if (savedInstanceState != null) {
+            currentItemId = savedInstanceState.getInt(STATE_CURRENT_ITEM_ID, currentItemId);
+        }
         if (savedInstanceState == null) {
             int initialItemId = resolveInitialItemId(getIntent());
             navigateTo(initialItemId);
             consumeOpenNavItemExtra(getIntent());
         } else {
+            syncDrawerSelection(currentItemId);
+            setTitle(resolveTitle(currentItemId));
+            drawerLayout.post(this::applyPageTitleVisibility);
             handleOpenNavIntent(getIntent());
         }
     }
 
+    @Override
+    protected void onSaveInstanceState(@NonNull Bundle outState) {
+        outState.putInt(STATE_CURRENT_ITEM_ID, currentItemId);
+        super.onSaveInstanceState(outState);
+    }
+
     @Override
     protected void onNewIntent(Intent intent) {
         super.onNewIntent(intent);
@@ -77,11 +119,14 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
     @Override
     public boolean onNavigationItemSelected(@NonNull android.view.MenuItem item) {
         navigateTo(item.getItemId());
+        if (!permanentSidebar) {
             drawerLayout.closeDrawer(GravityCompat.START);
+        }
         return true;
     }
 
     private void navigateTo(int itemId) {
+        currentItemId = itemId;
         syncDrawerSelection(itemId);
         Fragment fragment;
         if (itemId == R.id.nav_system_icons) {
@@ -110,6 +155,7 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
         getSupportFragmentManager()
                 .beginTransaction()
                 .replace(R.id.content_frame, fragment)
+                .runOnCommit(this::applyPageTitleVisibility)
                 .commit();
         setTitle(resolveTitle(itemId));
     }
@@ -149,6 +195,11 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
     }
 
     private void syncDrawerSelection(int itemId) {
+        syncNavigationSelection(drawerNavigationView, itemId);
+        syncNavigationSelection(permanentNavigationView, itemId);
+    }
+
+    private void syncNavigationSelection(NavigationView navigationView, int itemId) {
         if (navigationView == null) {
             return;
         }
@@ -167,6 +218,17 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
         navigationView.invalidate();
     }
 
+    private void setupNavigationView(NavigationView navigationView) {
+        if (navigationView == null) {
+            return;
+        }
+        navigationView.setNavigationItemSelectedListener(this);
+        navigationView.getMenu().setGroupCheckable(0, true, true);
+        navigationView.addOnLayoutChangeListener((view, left, top, right, bottom,
+                                                  oldLeft, oldTop, oldRight, oldBottom) ->
+                updateNavigationHeaderHeight(navigationView));
+    }
+
     private int resolveInitialItemId(Intent intent) {
         int requested = resolveOpenItemId(intent);
         return requested != -1 ? requested : R.id.nav_layout;
@@ -195,6 +257,7 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
     private void applyNavigationDrawerMarginsFromRootInsets() {
         WindowInsetsCompat insets = ViewCompat.getRootWindowInsets(drawerLayout);
         if (insets == null) {
+            applyNavigationDrawerSafeArea(0, 0);
             return;
         }
         Insets safeInsets = insets.getInsetsIgnoringVisibility(
@@ -206,10 +269,25 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
         int safeLeft = Math.max(Math.max(0, leftInset), Math.max(0, drawerLayout.getPaddingLeft()));
         int safeRight = Math.max(Math.max(0, rightInset), Math.max(0, drawerLayout.getPaddingRight()));
         drawerLayout.setDrawerSafeInsets(safeLeft, safeRight);
-        if (navigationBasePaddingLeft == null) {
-            navigationBasePaddingLeft = navigationView.getPaddingLeft();
+        drawerNavigationBasePaddingLeft = applyNavigationLeftPadding(
+                drawerNavigationView,
+                drawerNavigationBasePaddingLeft,
+                safeLeft);
+        permanentNavigationBasePaddingLeft = applyNavigationLeftPadding(
+                permanentNavigationView,
+                permanentNavigationBasePaddingLeft,
+                0);
+        updatePermanentSidebarMode();
     }
-        int leftPadding = navigationBasePaddingLeft + safeLeft;
+
+    private Integer applyNavigationLeftPadding(NavigationView navigationView,
+                                               Integer basePaddingLeft,
+                                               int safeLeft) {
+        if (navigationView == null) {
+            return basePaddingLeft;
+        }
+        int base = basePaddingLeft != null ? basePaddingLeft : navigationView.getPaddingLeft();
+        int leftPadding = base + safeLeft;
         if (navigationView.getPaddingLeft() != leftPadding
                 || Math.round(navigationView.getTranslationX()) != 0) {
             navigationView.setTranslationX(0f);
@@ -220,5 +298,102 @@ public class MainActivity extends AppCompatActivity implements NavigationView.On
                     navigationView.getPaddingBottom());
             navigationView.requestLayout();
         }
+        return base;
+    }
+
+    private void updatePermanentSidebarMode() {
+        int rootWidth = drawerLayout.getWidth();
+        if (rootWidth <= 0) {
+            return;
+        }
+        int drawerWidth = getResources().getDimensionPixelSize(R.dimen.sbt_navigation_drawer_width);
+        int foldedPortraitWidth = getResources().getDimensionPixelSize(R.dimen.sbt_folded_portrait_width);
+        boolean shouldUsePermanentSidebar = rootWidth >= drawerWidth
+                + Math.round(foldedPortraitWidth * PERMANENT_SIDEBAR_FOLDED_WIDTH_MULTIPLIER);
+        if (permanentSidebar != shouldUsePermanentSidebar) {
+            permanentSidebar = shouldUsePermanentSidebar;
+            drawerToggle.setDrawerIndicatorEnabled(!permanentSidebar);
+            toolbar.setVisibility(permanentSidebar ? View.GONE : View.VISIBLE);
+            setTitle(resolveTitle(currentItemId));
+            if (permanentSidebar) {
+                permanentNavigationView.setVisibility(View.VISIBLE);
+                drawerLayout.closeDrawer(GravityCompat.START, false);
+            } else {
+                drawerLayout.closeDrawer(GravityCompat.START, false);
+                permanentNavigationView.setVisibility(View.GONE);
+            }
+            drawerToggle.syncState();
+        }
+        if (permanentSidebar) {
+            drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED, GravityCompat.START);
+            drawerNavigationView.setVisibility(View.GONE);
+        } else {
+            drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED, GravityCompat.START);
+            drawerNavigationView.setVisibility(View.VISIBLE);
+            drawerNavigationView.requestLayout();
+        }
+        updateNavigationHeaderHeight(drawerNavigationView);
+        updateNavigationHeaderHeight(permanentNavigationView);
+        applyPageTitleVisibility();
+    }
+
+    private void updateNavigationHeaderHeight(NavigationView navigationView) {
+        if (navigationView == null || navigationView.getHeaderCount() == 0) {
+            return;
+        }
+        int navigationHeight = navigationView.getHeight();
+        if (navigationHeight <= 0) {
+            return;
+        }
+        int menuRows = countVisibleMenuRows(navigationView.getMenu());
+        int menuHeight = menuRows * getResources().getDimensionPixelSize(R.dimen.sbt_navigation_menu_item_height);
+        int minHeaderHeight = getResources().getDimensionPixelSize(R.dimen.sbt_drawer_header_min_height);
+        int maxHeaderHeight = getResources().getDimensionPixelSize(R.dimen.sbt_drawer_header_max_height);
+        int desiredHeaderHeight = Math.max(
+                minHeaderHeight,
+                Math.min(maxHeaderHeight, navigationHeight - menuHeight));
+        View header = navigationView.getHeaderView(0);
+        if (header == null || header.getLayoutParams() == null
+                || header.getLayoutParams().height == desiredHeaderHeight) {
+            return;
+        }
+        header.getLayoutParams().height = desiredHeaderHeight;
+        header.requestLayout();
+    }
+
+    private int countVisibleMenuRows(Menu menu) {
+        if (menu == null) {
+            return 0;
+        }
+        int count = 0;
+        for (int i = 0; i < menu.size(); i++) {
+            MenuItem item = menu.getItem(i);
+            if (item != null && item.isVisible()) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private void applyPageTitleVisibility() {
+        View content = findViewById(R.id.content_frame);
+        setTaggedPageTitlesVisible(content, permanentSidebar);
+    }
+
+    private void setTaggedPageTitlesVisible(View view, boolean visible) {
+        if (view == null) {
+            return;
+        }
+        Object tag = view.getTag();
+        if (tag instanceof String string && "statusbartweak.page.title".equals(string)
+                && view instanceof TextView) {
+            view.setVisibility(visible ? View.VISIBLE : View.GONE);
+        }
+        if (!(view instanceof ViewGroup group)) {
+            return;
+        }
+        for (int i = 0; i < group.getChildCount(); i++) {
+            setTaggedPageTitlesVisible(group.getChildAt(i), visible);
+        }
     }
 }

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/StatusChipsFragment.java

@@ -45,6 +45,11 @@ public class StatusChipsFragment extends Fragment {
                 SbtSettings.KEY_STATUS_CHIPS_HIDE_CALL,
                 false,
                 true);
+        ViewTreeSupport.bindBooleanPreference(requireContext(), prefs, root,
+                R.id.status_chips_hide_battery_switch,
+                SbtSettings.KEY_STATUS_CHIPS_HIDE_BATTERY,
+                false,
+                true);
         return root;
     }
 }

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/SystemIconsFragment.java

@@ -477,8 +477,6 @@ public class SystemIconsFragment extends Fragment {
         Set<String> encoded = SystemIconRules.encodeBlockedModes(blockedModes);
         prefs.edit()
                 .putStringSet(SbtSettings.KEY_SYSTEM_ICON_BLOCKED_MODES, encoded)
-                // Clear legacy key so migration does not keep re-forcing stale global hides.
-                .putStringSet(SbtSettings.KEY_SYSTEM_ICON_HIDE_SLOTS, Collections.emptySet())
                 .apply();
         SbtSettings.ensureReadable(requireContext());
     }

app/src/main/java/se/ajpanton/statusbartweak/shell/ui/ViewTreeSupport.java

@@ -238,25 +238,20 @@ final class ViewTreeSupport {
     static int iconContainerCount(
             SharedPreferences prefs,
             String countKey,
-            String legacyEnabledKey,
-            int defaultCount,
-            boolean legacyEnabledDefault
+            int defaultCount
     ) {
-        int fallback = prefs.getBoolean(legacyEnabledKey, legacyEnabledDefault) ? defaultCount : 0;
-        return SbtSettings.clampIconContainerCount(prefs.getInt(countKey, fallback));
+        return SbtSettings.clampIconContainerCount(prefs.getInt(countKey, defaultCount));
     }
 
     static void persistIconContainerCount(
             Context context,
             SharedPreferences prefs,
             String countKey,
-            String legacyEnabledKey,
             int count
     ) {
         int clamped = SbtSettings.clampIconContainerCount(count);
         prefs.edit()
                 .putInt(countKey, clamped)
-                .putBoolean(legacyEnabledKey, clamped > 0)
                 .apply();
         SbtSettings.ensureReadable(context);
     }

app/src/main/res/drawable/sbt_clock_input_background.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@android:color/transparent" />
+    <stroke
+        android:width="1dp"
+        android:color="@color/sbt_card_outline" />
+    <corners android:radius="6dp" />
+    <padding
+        android:left="8dp"
+        android:top="6dp"
+        android:right="8dp"
+        android:bottom="6dp" />
+</shape>

app/src/main/res/drawable/sbt_clock_preview_background.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@android:color/transparent" />
+    <stroke
+        android:width="1dp"
+        android:color="@color/sbt_panel_outline" />
+    <corners android:radius="8dp" />
+    <padding
+        android:left="10dp"
+        android:top="8dp"
+        android:right="10dp"
+        android:bottom="8dp" />
+</shape>

app/src/main/res/layout/activity_main.xml

@@ -9,8 +9,28 @@
     android:fitsSystemWindows="true">
 
     <LinearLayout
+        android:id="@+id/main_shell"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
+        android:orientation="horizontal">
+
+        <com.google.android.material.navigation.NavigationView
+            android:id="@+id/nav_view_permanent"
+            android:layout_width="@dimen/sbt_navigation_drawer_width"
+            android:layout_height="match_parent"
+            android:background="@color/sbt_surface"
+            android:fitsSystemWindows="true"
+            android:visibility="gone"
+            app:headerLayout="@layout/drawer_header"
+            app:itemBackground="@drawable/drawer_item_background"
+            app:itemTextColor="@color/drawer_item_text_color"
+            app:menu="@menu/drawer_menu" />
+
+        <LinearLayout
+            android:id="@+id/main_content"
+            android:layout_width="0dp"
+            android:layout_height="match_parent"
+            android:layout_weight="1"
             android:orientation="vertical">
 
             <com.google.android.material.appbar.MaterialToolbar
@@ -30,9 +50,11 @@
 
         </LinearLayout>
 
+    </LinearLayout>
+
     <com.google.android.material.navigation.NavigationView
-        android:id="@+id/nav_view"
-        android:layout_width="wrap_content"
+        android:id="@+id/nav_view_drawer"
+        android:layout_width="@dimen/sbt_navigation_drawer_width"
         android:layout_height="match_parent"
         android:layout_gravity="start"
         android:background="@color/sbt_surface"

app/src/main/res/layout/drawer_header.xml

@@ -2,11 +2,11 @@
 <LinearLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
-    android:layout_height="172dp"
+    android:layout_height="@dimen/sbt_drawer_header_height"
     android:background="@drawable/sbt_drawer_header_background"
     android:gravity="bottom"
     android:orientation="vertical"
-    android:padding="20dp">
+    android:padding="@dimen/sbt_drawer_header_padding">
 
     <TextView
         android:layout_width="wrap_content"

app/src/main/res/layout/fragment_battery_bar.xml

@@ -13,41 +13,10 @@
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:tag="statusbartweak.page.title"
             android:text="@string/battery_bar_title"
             android:textAppearance="?attr/textAppearanceHeadline5" />
 
-        <com.google.android.material.card.MaterialCardView
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="16dp"
-            app:cardUseCompatPadding="true"
-            app:strokeColor="@color/sbt_card_outline"
-            app:strokeWidth="1dp">
-
-            <LinearLayout
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:orientation="vertical"
-                android:padding="16dp">
-
-                <TextView
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:text="@string/battery_bar_master_toggle_title"
-                    android:textAppearance="?attr/textAppearanceSubtitle1"
-                    android:textAllCaps="true"
-                    android:letterSpacing="0.03"
-                    android:textStyle="bold" />
-
-                <com.google.android.material.switchmaterial.SwitchMaterial
-                    android:id="@+id/battery_bar_enabled_switch"
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:layout_marginTop="8dp"
-                    android:text="@string/battery_bar_enabled" />
-            </LinearLayout>
-        </com.google.android.material.card.MaterialCardView>
-
         <LinearLayout
             android:id="@+id/battery_bar_geometry_section"
             android:layout_width="match_parent"
@@ -71,18 +40,45 @@
                     <TextView
                         android:layout_width="wrap_content"
                         android:layout_height="wrap_content"
-                        android:text="@string/battery_bar_position_title"
+                        android:text="@string/battery_bar_base_settings_title"
                         android:textAppearance="?attr/textAppearanceSubtitle1"
                         android:textAllCaps="true"
                         android:letterSpacing="0.03"
                         android:textStyle="bold" />
 
+                    <com.google.android.material.switchmaterial.SwitchMaterial
+                        android:id="@+id/battery_bar_enabled_switch"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="8dp"
+                        android:text="@string/battery_bar_enabled" />
+
+                    <LinearLayout
+                        android:id="@+id/battery_bar_base_controls"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:orientation="vertical">
+
+                        <TextView
+                            android:layout_width="match_parent"
+                            android:layout_height="wrap_content"
+                            android:layout_marginTop="12dp"
+                            android:text="@string/battery_bar_position_title"
+                            android:textAppearance="?attr/textAppearanceBody2" />
+
                         <RadioGroup
                             android:id="@+id/battery_bar_position_group"
                             android:layout_width="match_parent"
                             android:layout_height="wrap_content"
                             android:layout_marginTop="8dp">
 
+                            <RadioButton
+                                android:id="@+id/battery_bar_curved_geometry_length"
+                                android:layout_width="match_parent"
+                                android:layout_height="wrap_content"
+                                android:minHeight="36dp"
+                                android:text="@string/battery_bar_curved_geometry_length" />
+
                             <RadioButton
                                 android:id="@+id/battery_bar_position_top"
                                 android:layout_width="match_parent"
@@ -102,145 +98,8 @@
                             android:layout_width="match_parent"
                             android:layout_height="wrap_content"
                             android:layout_marginTop="16dp"
-                        android:text="@string/battery_bar_thickness_title"
-                        android:textAppearance="?attr/textAppearanceBody2" />
-
-                    <LinearLayout
-                        android:layout_width="wrap_content"
-                        android:layout_height="wrap_content"
-                        android:layout_marginTop="8dp"
-                        android:gravity="center_vertical"
-                        android:orientation="horizontal">
-
-                        <com.google.android.material.button.MaterialButton
-                            android:id="@+id/battery_bar_thickness_minus"
-                            style="?attr/materialButtonOutlinedStyle"
-                            android:layout_width="40dp"
-                            android:layout_height="wrap_content"
-                            android:text="-" />
-
-                        <EditText
-                            android:id="@+id/battery_bar_thickness_input"
-                            android:layout_width="72dp"
-                            android:layout_height="wrap_content"
-                            android:layout_marginStart="8dp"
-                            android:layout_marginEnd="8dp"
-                            android:ems="3"
-                            android:gravity="center"
-                            android:importantForAutofill="no"
-                            android:inputType="number"
-                            android:maxLines="1"
-                            android:singleLine="true" />
-
-                        <com.google.android.material.button.MaterialButton
-                            android:id="@+id/battery_bar_thickness_plus"
-                            style="?attr/materialButtonOutlinedStyle"
-                            android:layout_width="40dp"
-                            android:layout_height="wrap_content"
-                            android:text="+" />
-                    </LinearLayout>
-
-                    <TextView
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:layout_marginTop="16dp"
-                        android:text="@string/battery_bar_edge_offset_title"
-                        android:textAppearance="?attr/textAppearanceBody2" />
-
-                    <LinearLayout
-                        android:layout_width="wrap_content"
-                        android:layout_height="wrap_content"
-                        android:layout_marginTop="8dp"
-                        android:gravity="center_vertical"
-                        android:orientation="horizontal">
-
-                        <com.google.android.material.button.MaterialButton
-                            android:id="@+id/battery_bar_edge_offset_minus"
-                            style="?attr/materialButtonOutlinedStyle"
-                            android:layout_width="40dp"
-                            android:layout_height="wrap_content"
-                            android:text="-" />
-
-                        <EditText
-                            android:id="@+id/battery_bar_edge_offset_input"
-                            android:layout_width="72dp"
-                            android:layout_height="wrap_content"
-                            android:layout_marginStart="8dp"
-                            android:layout_marginEnd="8dp"
-                            android:ems="3"
-                            android:gravity="center"
-                            android:importantForAutofill="no"
-                            android:inputType="number"
-                            android:maxLines="1"
-                            android:singleLine="true" />
-
-                        <com.google.android.material.button.MaterialButton
-                            android:id="@+id/battery_bar_edge_offset_plus"
-                            style="?attr/materialButtonOutlinedStyle"
-                            android:layout_width="40dp"
-                            android:layout_height="wrap_content"
-                            android:text="+" />
-                    </LinearLayout>
-
-                    <TextView
-                        android:layout_width="wrap_content"
-                        android:layout_height="wrap_content"
-                        android:layout_marginTop="16dp"
-                        android:text="@string/battery_bar_curved_geometry_title"
-                        android:textAppearance="?attr/textAppearanceBody2" />
-
-                    <RadioGroup
-                        android:id="@+id/battery_bar_curved_geometry_group"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:layout_marginTop="8dp">
-
-                        <RadioButton
-                            android:id="@+id/battery_bar_curved_geometry_off"
-                            android:layout_width="match_parent"
-                            android:layout_height="wrap_content"
-                            android:minHeight="36dp"
-                            android:text="@string/battery_bar_curved_geometry_off" />
-
-                        <RadioButton
-                            android:id="@+id/battery_bar_curved_geometry_horizontal"
-                            android:layout_width="match_parent"
-                            android:layout_height="wrap_content"
-                            android:minHeight="36dp"
-                            android:text="@string/battery_bar_curved_geometry_horizontal" />
-
-                        <RadioButton
-                            android:id="@+id/battery_bar_curved_geometry_length"
-                            android:layout_width="match_parent"
-                            android:layout_height="wrap_content"
-                            android:minHeight="36dp"
-                            android:text="@string/battery_bar_curved_geometry_length" />
-                    </RadioGroup>
-                </LinearLayout>
-            </com.google.android.material.card.MaterialCardView>
-
-            <com.google.android.material.card.MaterialCardView
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:layout_marginTop="16dp"
-                app:cardUseCompatPadding="true"
-                app:strokeColor="@color/sbt_card_outline"
-                app:strokeWidth="1dp">
-
-                <LinearLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:orientation="vertical"
-                    android:padding="16dp">
-
-                    <TextView
-                        android:layout_width="wrap_content"
-                        android:layout_height="wrap_content"
                             android:text="@string/battery_bar_alignment_title"
-                        android:textAppearance="?attr/textAppearanceSubtitle1"
-                        android:textAllCaps="true"
-                        android:letterSpacing="0.03"
-                        android:textStyle="bold" />
+                            android:textAppearance="?attr/textAppearanceBody2" />
 
                         <LinearLayout
                             android:id="@+id/battery_bar_alignment_row"
@@ -333,48 +192,101 @@
                                     app:srcCompat="@drawable/sbt_align_rtl" />
                             </LinearLayout>
                         </LinearLayout>
-                </LinearLayout>
-            </com.google.android.material.card.MaterialCardView>
 
-            <com.google.android.material.card.MaterialCardView
+                        <TextView
                             android:layout_width="match_parent"
                             android:layout_height="wrap_content"
                             android:layout_marginTop="16dp"
-                app:cardUseCompatPadding="true"
-                app:strokeColor="@color/sbt_card_outline"
-                app:strokeWidth="1dp">
-
-                <LinearLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:orientation="vertical"
-                    android:padding="16dp">
-
-                    <TextView
-                        android:layout_width="wrap_content"
-                        android:layout_height="wrap_content"
-                        android:letterSpacing="0.03"
-                        android:text="@string/battery_bar_scenario_overrides_title"
-                        android:textAllCaps="true"
-                        android:textAppearance="?attr/textAppearanceSubtitle1"
-                        android:textStyle="bold" />
-
-                    <TextView
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:layout_marginTop="8dp"
-                        android:text="@string/battery_bar_scenario_overrides_hint"
+                            android:text="@string/battery_bar_thickness_title"
                             android:textAppearance="?attr/textAppearanceBody2" />
 
                         <LinearLayout
-                        android:id="@+id/battery_bar_scenario_overrides_container"
-                        android:layout_width="match_parent"
+                            android:layout_width="wrap_content"
                             android:layout_height="wrap_content"
                             android:layout_marginTop="8dp"
-                        android:orientation="vertical" />
+                            android:gravity="center_vertical"
+                            android:orientation="horizontal">
+
+                        <com.google.android.material.button.MaterialButton
+                            android:id="@+id/battery_bar_thickness_minus"
+                            style="?attr/materialButtonOutlinedStyle"
+                            android:layout_width="40dp"
+                            android:layout_height="wrap_content"
+                            android:text="-" />
+
+                        <EditText
+                            android:id="@+id/battery_bar_thickness_input"
+                            android:layout_width="72dp"
+                            android:layout_height="wrap_content"
+                            android:layout_marginStart="8dp"
+                            android:layout_marginEnd="8dp"
+                            android:ems="3"
+                            android:gravity="center"
+                            android:importantForAutofill="no"
+                            android:inputType="number"
+                            android:maxLines="1"
+                            android:singleLine="true" />
+
+                        <com.google.android.material.button.MaterialButton
+                            android:id="@+id/battery_bar_thickness_plus"
+                            style="?attr/materialButtonOutlinedStyle"
+                            android:layout_width="40dp"
+                            android:layout_height="wrap_content"
+                            android:text="+" />
+                        </LinearLayout>
+
+                        <TextView
+                            android:layout_width="match_parent"
+                            android:layout_height="wrap_content"
+                            android:layout_marginTop="16dp"
+                            android:text="@string/battery_bar_edge_offset_title"
+                            android:textAppearance="?attr/textAppearanceBody2" />
+
+                        <LinearLayout
+                            android:layout_width="wrap_content"
+                            android:layout_height="wrap_content"
+                            android:layout_marginTop="8dp"
+                            android:gravity="center_vertical"
+                            android:orientation="horizontal">
+
+                        <com.google.android.material.button.MaterialButton
+                            android:id="@+id/battery_bar_edge_offset_minus"
+                            style="?attr/materialButtonOutlinedStyle"
+                            android:layout_width="40dp"
+                            android:layout_height="wrap_content"
+                            android:text="-" />
+
+                        <EditText
+                            android:id="@+id/battery_bar_edge_offset_input"
+                            android:layout_width="72dp"
+                            android:layout_height="wrap_content"
+                            android:layout_marginStart="8dp"
+                            android:layout_marginEnd="8dp"
+                            android:ems="3"
+                            android:gravity="center"
+                            android:importantForAutofill="no"
+                            android:inputType="number"
+                            android:maxLines="1"
+                            android:singleLine="true" />
+
+                        <com.google.android.material.button.MaterialButton
+                            android:id="@+id/battery_bar_edge_offset_plus"
+                            style="?attr/materialButtonOutlinedStyle"
+                            android:layout_width="40dp"
+                            android:layout_height="wrap_content"
+                            android:text="+" />
+                        </LinearLayout>
+
+                    </LinearLayout>
                 </LinearLayout>
             </com.google.android.material.card.MaterialCardView>
 
+            <LinearLayout
+                android:id="@+id/battery_bar_scenario_cards_container"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical" />
+
             <com.google.android.material.card.MaterialCardView
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
@@ -569,6 +481,25 @@
                         android:layout_height="wrap_content"
                         android:layout_marginTop="8dp"
                         android:text="@string/battery_bar_default_charge_colour" />
+
+                    <TextView
+                        android:id="@+id/battery_bar_colour_help_toggle"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="12dp"
+                        android:text="@string/battery_bar_colour_help_show"
+                        android:textAppearance="?attr/textAppearanceBody1"
+                        android:textColor="@color/sbt_accent_dark"
+                        android:textStyle="bold" />
+
+                    <TextView
+                        android:id="@+id/battery_bar_colour_help"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="8dp"
+                        android:visibility="gone"
+                        android:text="@string/battery_bar_colour_help_text"
+                        android:textAppearance="?attr/textAppearanceBody2" />
                 </LinearLayout>
             </com.google.android.material.card.MaterialCardView>
 

app/src/main/res/layout/fragment_block_app_notification_icons.xml

@@ -9,6 +9,7 @@
         android:id="@+id/hidden_apps_title"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
+        android:tag="statusbartweak.page.title"
         android:text="@string/hidden_apps_page_title"
         android:textAppearance="?attr/textAppearanceHeadline6"
         android:textStyle="bold" />

app/src/main/res/layout/fragment_clock.xml

@@ -13,10 +13,12 @@
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:tag="statusbartweak.page.title"
             android:text="@string/clock_title"
             android:textAppearance="?attr/textAppearanceHeadline5" />
 
         <com.google.android.material.card.MaterialCardView
+            android:id="@+id/clock_custom_format_card"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_marginTop="16dp"
@@ -53,17 +55,24 @@
                     android:orientation="vertical"
                     android:visibility="gone">
 
-                    <EditText
-                        android:id="@+id/clock_custom_format_input"
-                        android:layout_width="match_parent"
+                    <se.ajpanton.statusbartweak.shell.ui.ClockPatternPreviewView
+                        android:id="@+id/clock_custom_format_preview"
+                        android:layout_width="wrap_content"
                         android:layout_height="wrap_content"
                         android:layout_marginTop="8dp"
+                        android:background="@drawable/sbt_clock_preview_background" />
+
+                    <EditText
+                        android:id="@+id/clock_custom_format_input"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="8dp"
+                        android:background="@drawable/sbt_clock_input_background"
                         android:gravity="top|start"
-                        android:hint="@string/clock_custom_format_hint"
                         android:importantForAutofill="no"
                         android:inputType="textMultiLine|textNoSuggestions"
-                        android:maxLines="4"
-                        android:minLines="2"
+                        android:minWidth="120dp"
+                        android:minLines="1"
                         android:scrollHorizontally="false"
                         android:singleLine="false" />
                 </LinearLayout>
@@ -71,6 +80,7 @@
         </com.google.android.material.card.MaterialCardView>
 
         <com.google.android.material.card.MaterialCardView
+            android:id="@+id/drawer_clock_custom_format_card"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_marginTop="16dp"
@@ -107,17 +117,24 @@
                     android:orientation="vertical"
                     android:visibility="gone">
 
-                    <EditText
-                        android:id="@+id/drawer_clock_custom_format_input"
-                        android:layout_width="match_parent"
+                    <se.ajpanton.statusbartweak.shell.ui.ClockPatternPreviewView
+                        android:id="@+id/drawer_clock_custom_format_preview"
+                        android:layout_width="wrap_content"
                         android:layout_height="wrap_content"
                         android:layout_marginTop="8dp"
+                        android:background="@drawable/sbt_clock_preview_background" />
+
+                    <EditText
+                        android:id="@+id/drawer_clock_custom_format_input"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="8dp"
+                        android:background="@drawable/sbt_clock_input_background"
                         android:gravity="top|start"
-                        android:hint="@string/clock_custom_format_hint"
                         android:importantForAutofill="no"
                         android:inputType="textMultiLine|textNoSuggestions"
-                        android:maxLines="4"
-                        android:minLines="2"
+                        android:minWidth="120dp"
+                        android:minLines="1"
                         android:scrollHorizontally="false"
                         android:singleLine="false" />
                 </LinearLayout>
@@ -125,6 +142,7 @@
         </com.google.android.material.card.MaterialCardView>
 
         <com.google.android.material.card.MaterialCardView
+            android:id="@+id/drawer_date_custom_format_card"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_marginTop="16dp"
@@ -161,17 +179,24 @@
                     android:orientation="vertical"
                     android:visibility="gone">
 
-                    <EditText
-                        android:id="@+id/drawer_date_custom_format_input"
-                        android:layout_width="match_parent"
+                    <se.ajpanton.statusbartweak.shell.ui.ClockPatternPreviewView
+                        android:id="@+id/drawer_date_custom_format_preview"
+                        android:layout_width="wrap_content"
                         android:layout_height="wrap_content"
                         android:layout_marginTop="8dp"
+                        android:background="@drawable/sbt_clock_preview_background" />
+
+                    <EditText
+                        android:id="@+id/drawer_date_custom_format_input"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="8dp"
+                        android:background="@drawable/sbt_clock_input_background"
                         android:gravity="top|start"
-                        android:hint="@string/clock_custom_format_hint"
                         android:importantForAutofill="no"
                         android:inputType="textMultiLine|textNoSuggestions"
-                        android:maxLines="4"
-                        android:minLines="2"
+                        android:minWidth="120dp"
+                        android:minLines="1"
                         android:scrollHorizontally="false"
                         android:singleLine="false" />
                 </LinearLayout>
@@ -209,6 +234,14 @@
                     android:layout_marginTop="8dp"
                     android:text="@string/clock_font_picker_button" />
 
+                <com.google.android.material.button.MaterialButton
+                    android:id="@+id/clock_restore_stored_patterns_button"
+                    style="?attr/materialButtonOutlinedStyle"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="8dp"
+                    android:text="@string/clock_restore_stored_patterns" />
+
                 <TextView
                     android:id="@+id/clock_custom_format_help_toggle"
                     android:layout_width="match_parent"

app/src/main/res/layout/fragment_icons_debug.xml

@@ -13,6 +13,7 @@
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:tag="statusbartweak.page.title"
             android:text="@string/debug_title"
             android:textAppearance="?attr/textAppearanceHeadline5" />
 
@@ -110,6 +111,13 @@
                     android:layout_marginTop="12dp"
                     android:text="@string/debug_restart_systemui" />
 
+                <com.google.android.material.switchmaterial.SwitchMaterial
+                    android:id="@+id/debug_experimental_aod_statusbar_root_switch"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="8dp"
+                    android:text="@string/debug_experimental_aod_statusbar_root" />
+
             </LinearLayout>
         </com.google.android.material.card.MaterialCardView>
 

app/src/main/res/layout/fragment_layout.xml

@@ -13,6 +13,7 @@
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:tag="statusbartweak.page.title"
             android:text="@string/layout_title"
             android:textAppearance="?attr/textAppearanceHeadline5" />
 

app/src/main/res/layout/fragment_misc.xml

@@ -13,6 +13,7 @@
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:tag="statusbartweak.page.title"
             android:text="@string/misc_title"
             android:textAppearance="?attr/textAppearanceHeadline5" />
 

app/src/main/res/layout/fragment_status_chips.xml

@@ -13,6 +13,7 @@
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:tag="statusbartweak.page.title"
             android:text="@string/status_chips_title"
             android:textAppearance="?attr/textAppearanceHeadline5" />
 
@@ -47,6 +48,12 @@
                     android:layout_width="match_parent"
                     android:layout_height="wrap_content"
                     android:text="@string/status_chips_hide_call_unlocked_label" />
+
+                <com.google.android.material.switchmaterial.SwitchMaterial
+                    android:id="@+id/status_chips_hide_battery_switch"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:text="@string/status_chips_hide_battery_label" />
             </LinearLayout>
         </com.google.android.material.card.MaterialCardView>
 

app/src/main/res/layout/fragment_system_icons.xml

@@ -13,6 +13,7 @@
         <TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
+            android:tag="statusbartweak.page.title"
             android:text="@string/system_icons_title"
             android:textAppearance="?attr/textAppearanceHeadline5" />
 

app/src/main/res/values/dimens.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="sbt_navigation_drawer_width">216dp</dimen>
+    <dimen name="sbt_folded_portrait_width">360dp</dimen>
+    <dimen name="sbt_navigation_menu_item_height">48dp</dimen>
+    <dimen name="sbt_drawer_header_height">86dp</dimen>
+    <dimen name="sbt_drawer_header_min_height">86dp</dimen>
+    <dimen name="sbt_drawer_header_max_height">172dp</dimen>
+    <dimen name="sbt_drawer_header_padding">16dp</dimen>
+</resources>

app/src/main/res/values/ids.xml

@@ -1,3 +1,4 @@
 <resources>
     <item name="sbt_debug_container_bounds" type="id" />
+    <item name="sbt_debug_drawer_clock_container" type="id" />
 </resources>

app/src/main/res/values/strings.xml

@@ -30,6 +30,7 @@
     <string name="debug_visualize_aod_stock_containers">AOD stock containers and derived statusbar</string>
     <string name="debug_section_systemui">SystemUI</string>
     <string name="debug_restart_systemui">Restart SystemUI</string>
+    <string name="debug_experimental_aod_statusbar_root">Experimental non-Samsung AOD statusbar layout</string>
     <string name="debug_restart_systemui_started">SystemUI restart requested.</string>
     <string name="debug_restart_systemui_failed">Could not restart SystemUI. Root shell failed.</string>
     <string name="debug_notification_style_cards">Cards</string>
@@ -44,7 +45,7 @@
     <string name="debug_notification_permission_required">Notification permission is required for debug icons.</string>
     <string name="debug_camera_current_title">Current camera</string>
     <string name="debug_camera_other_title">Other overridden cameras</string>
-    <string name="debug_camera_identified_as">Identified as %1$s</string>
+    <string name="debug_camera_identified_as">Identified as %1$s\n%2$s</string>
     <string name="debug_camera_overridden_as">Overridden as %1$s</string>
     <string name="debug_camera_action_wrong">This is wrong</string>
     <string name="debug_camera_action_undo">↶</string>
@@ -131,12 +132,14 @@
     <string name="status_chips_hide_media_unlocked_label">Hide media chip (unlocked)</string>
     <string name="status_chips_hide_navigation_unlocked_label">Hide navigation chip (unlocked)</string>
     <string name="status_chips_hide_call_unlocked_label">Hide call chip (unlocked)</string>
+    <string name="status_chips_hide_battery_label">Hide charging battery chip (unlocked)</string>
     <string name="misc_title">Misc</string>
     <string name="battery_bar_title">Battery bar</string>
-    <string name="battery_bar_master_toggle_title">Master toggle</string>
+    <string name="battery_bar_base_settings_title">Base settings</string>
     <string name="battery_bar_enabled">Enable battery bar</string>
+    <string name="battery_bar_use_base_settings">Use base settings</string>
     <string name="battery_bar_position_title">Position</string>
-    <string name="battery_bar_position_top">Top</string>
+    <string name="battery_bar_position_top">Top edge of screen</string>
     <string name="battery_bar_position_bottom">Bottom of status bar</string>
     <string name="battery_bar_alignment_title">Alignment</string>
     <string name="battery_bar_alignment_ltr">&#8594;</string>
@@ -144,19 +147,10 @@
     <string name="battery_bar_alignment_center">&#8596;</string>
     <string name="battery_bar_thickness_title">Thickness (dp)</string>
     <string name="battery_bar_edge_offset_title">Edge offset (dp)</string>
-    <string name="battery_bar_curved_geometry_title">Curved top geometry</string>
-    <string name="battery_bar_curved_geometry_off">Off</string>
-    <string name="battery_bar_curved_geometry_horizontal">On, horizontal position only</string>
-    <string name="battery_bar_curved_geometry_length">On, actual curve length</string>
-    <string name="battery_bar_scenario_overrides_title">Scenario overrides</string>
-    <string name="battery_bar_scenario_overrides_hint">Optional geometry overrides. Disabled scenarios use the default geometry above.</string>
-    <string name="battery_bar_scenario_group_unlocked">Unlocked</string>
+    <string name="battery_bar_curved_geometry_length">Follow screen edges</string>
     <string name="battery_bar_scenario_group_transparent">Transparent statusbar</string>
     <string name="battery_bar_scenario_group_fullscreen">Fullscreen</string>
     <string name="battery_bar_lockscreen_override">Lockscreen</string>
-    <string name="battery_bar_edit_override">Edit</string>
-    <string name="battery_bar_override_dialog_title">Edit %1$s geometry</string>
-    <string name="battery_bar_override_summary">%1$s, %2$s, %3$ddp thick</string>
     <string name="battery_bar_mapping_title">Battery mapping</string>
     <string name="battery_bar_mapping_min_label">...0 at %1$d%%</string>
     <string name="battery_bar_mapping_max_label">...full at %1$d%%</string>
@@ -164,11 +158,13 @@
     <string name="battery_bar_colours_title">Default colours</string>
     <string name="battery_bar_default_discharge_colour">Discharge colour</string>
     <string name="battery_bar_default_charge_colour">Charge colour</string>
+    <string name="battery_bar_button_label_discharge">Discharge</string>
+    <string name="battery_bar_button_label_charge">Charge</string>
     <string name="battery_bar_thresholds_title">Threshold colours</string>
     <string name="battery_bar_thresholds_hint">Below a threshold, the first matching colour overrides the default.</string>
     <string name="battery_bar_add_threshold">Add threshold</string>
     <string name="battery_bar_colour_dialog_title">Set colour</string>
-    <string name="battery_bar_colour_dialog_hint">Examples: FA0, 80FA, or FFAA00</string>
+    <string name="battery_bar_colour_dialog_hint">Examples: #FA0, FA0, or #FA0 ; invRGB 0.5 *RGB</string>
     <string name="battery_bar_threshold_percent_title">Threshold percent</string>
     <string name="battery_bar_threshold_percent_hint">Applies when battery is at or below this percent.</string>
     <string name="battery_bar_threshold_change_percent">Change threshold %</string>
@@ -178,7 +174,10 @@
     <string name="battery_bar_threshold_remove">Remove threshold</string>
     <string name="battery_bar_colour_auto">Auto</string>
     <string name="battery_bar_colour_same_as_discharge">Same as discharge</string>
-    <string name="battery_bar_colour_same_as_default">Same as default</string>
+    <string name="battery_bar_colour_same_as_default">Default</string>
+    <string name="battery_bar_colour_help_show">Show colour syntax</string>
+    <string name="battery_bar_colour_help_hide">Hide colour syntax</string>
+    <string name="battery_bar_colour_help_text">Colour values:\n#FA0, #FFAA00, #80FFAA00, FA0, or [255, 255, 170, 0]\n\nPostfix math:\n#FA0 1.2 *RGB clip\n#FA0 invRGB\n\nOperators:\n+  -  *  /  ^  inv  min  max  sqrt  clip  dup\n\nChannels:\nAdd A, R, G, or B to limit vector operations.\nExamples: invRGB, *A, +RB\n\nTint variants:\nUse ; for a dark-tint expression.\nThe dark expression starts with the result from the bright expression.</string>
     <string name="battery_bar_threshold_duplicate">A threshold at that percentage already exists.</string>
     <string name="battery_bar_threshold_reordered">That threshold moved to a new position in the list.</string>
     <string name="battery_bar_threshold_charge_note">Leave the field empty and press OK for \"Same as discharge\", or use the button below for \"Same as default\".</string>
@@ -202,6 +201,7 @@
     <string name="layout_chip_height_steps">Chip height (% of statusbar)</string>
     <string name="layout_locked_notifications_title">Locked notifications mode</string>
     <string name="layout_locked_notifications_hint">Mirrors the Samsung notification display style for AOD and lockscreen.</string>
+    <string name="layout_locked_notifications_hint_icons_only">This SystemUI exposes notification icons only.</string>
     <string name="layout_misc_title">Misc</string>
     <string name="label_max_unlocked_icons_per_row">Max unlocked icons per row</string>
     <string name="layout_padding_title">Padding</string>
@@ -242,14 +242,18 @@
     <string name="clock_custom_format_enabled">Enable custom date/time pattern</string>
     <string name="drawer_clock_custom_format_enabled">Enable custom date/time pattern</string>
     <string name="drawer_date_custom_format_enabled">Enable custom date/time pattern</string>
-    <string name="clock_custom_format_hint">Examples: HH:mm, EEE d MMM HH:mm:ss, {color(#batterybar 1.2 * ; invRGB 0.5 *RGB) big @sans-serif-condensed}HH:mm</string>
     <string name="clock_custom_format_help_common">Date/time patterns:\n\u2022 Uses Java SimpleDateFormat-style pattern letters\n\u2022 Common symbols: yyyy yy MMMM MMM MM EEEE EEE dd d HH hh mm ss a\n\nTags:\n\u2022 Supported tags: &lt;i&gt;, &lt;u&gt;, &lt;small&gt;, &lt;big&gt;, &lt;font color=\'...\'&gt;, &lt;font face=\'...\'&gt;\n\u2022 &lt;b&gt; is not supported\n\u2022 Custom font tags: &lt;sans&gt;, &lt;serif&gt;, &lt;mono&gt;, &lt;condensed&gt;\n\u2022 {/font} closes any open &lt;font ...&gt; tag\n\u2022 Opening a new colour or font face automatically closes the previous one</string>
     <string name="clock_custom_format_help_styling">Shorthand blocks:\n\u2022 {#FA0 big @sans-serif-condensed} is shorthand for opening multiple tags in order\n\u2022 {#FA0} is shorthand for {color(#FA0)}\n\u2022 In shorthand: / closes a tag, color(...) sets font colour, @ sets font face\n\u2022 Each whitespace-separated token inside {} becomes its own tag, except color(...) which may contain spaces\n\nLine breaks:\n\u2022 Use \\n, {\\n} or {\\n15}; the number is the line-height delta in statusbar units\n\u2022 Omit the number to use the default row spacing\n\u2022 { /\\n } style line breaks are written without spaces: {/\\n} or {/\\n15}\n\u2022 Normal line breaks propagate open tags onto the next row\n\u2022 A / line break ends all currently open tags before the next row starts\n\nPipes and grouping:\n\u2022 Maximum two pipes per row; more than two is a syntax error for that row only\n\u2022 Pipes inside single quotes or {} do not split the row\n\u2022 One pipe splits into left and right segments\n\u2022 Two pipes remove the middle section, then split using the outer pipes\n\u2022 Tags are logically continued across pipe splits, even if the middle section is ignored\n\u2022 Rows without pipes are independent; rows with pipes share one common pipe group\n\u2022 A syntax-error row becomes the text Syntax error, with no whole-clock fallback\n\nColours:\n\u2022 Supported operands: #RGB, #ARGB, #RRGGBB, #AARRGGBB, #batterybar, [R,G,B], [A,R,G,B], and numbers\n\u2022 Colour expressions use reverse Polish notation: operands first, operator last\n\u2022 Use ; to separate bright/dark variants; the dark side starts with the raw result from the bright side on the stack\n\u2022 Operators: + - * / ^ inv min max sqrt clip dup\n\u2022 Operators can be channel-filtered, for example +A, *RGB, invRGB, maxRGB, clipA\n\u2022 Final values are clipped to 0..255; a final number becomes opaque grayscale</string>
     <string name="clock_custom_format_help_examples">Examples:\n\u2022 &lt;small&gt;EEE d MMM&lt;/small&gt; HH:mm\n\u2022 HH&lt;small&gt;:mm&lt;/small&gt;\n\u2022 &lt;font color=\'#FA0\'&gt;ss&lt;/font&gt;\n\u2022 {color(#FA0 ; invRGB 0.8 *RGB)}ss\n\u2022 {color(#batterybar 1.2 * ; invRGB 0.5 *RGB) big u @sans-serif-condensed}HH:mm\n\u2022 {color([255, 255, 170, 0] ; invRGB)}HH:mm\n\u2022 HH:mm{\\n12 small}EEE d MMM\n\u2022 HH|mm aligns the pipe position across every piped row\n\u2022 left||right removes the middle section before split alignment\n\u2022 {/font}{/\\n big}HH:mm starts a new row without carrying the previous font tags forward</string>
     <string name="clock_font_picker_button">Browse font families</string>
+    <string name="clock_restore_stored_patterns">Restore stored patterns</string>
+    <string name="clock_stored_patterns_show">Show stored patterns</string>
+    <string name="clock_stored_patterns_hide">Hide stored patterns</string>
+    <string name="clock_stored_patterns_hint">Tap a preview to use it</string>
+    <string name="clock_store_current_pattern">Store current pattern</string>
     <string name="clock_custom_format_help_show">▾ Show pattern instructions</string>
     <string name="clock_custom_format_help_hide">▴ Hide pattern instructions</string>
-    <string name="clock_font_picker_title">Font families</string>
+    <string name="clock_font_picker_title">Font families (tap to copy)</string>
     <string name="clock_font_picker_hint">Search font family</string>
     <string name="clock_font_picker_copied">Copied: %1$s</string>
     <string name="clock_custom_format_help_link">Date/time pattern reference only: https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html</string>

app/src/test/java/se/ajpanton/statusbartweak/runtime/features/clock/ClockColorResolverTest.java

@@ -49,4 +49,38 @@ public final class ClockColorResolverTest {
     public void rejectsMoreThanTwoColorVariants() {
         resolver.resolveColor(null, "#123 ; #456 ; #789", WHITE_REFERENCE, 0xffffffff);
     }
+
+    @Test
+    public void batteryBarOptionsAllowBareHexColours() {
+        assertEquals(
+                0xff808080,
+                resolver.resolveColor(
+                        null,
+                        "808080",
+                        WHITE_REFERENCE,
+                        0xffffffff,
+                        ClockColorResolver.Options.batteryBar()));
+    }
+
+    @Test
+    public void batteryBarOptionsKeepThreeDigitNumbersAsNumbers() {
+        assertEquals(
+                0xffffffff,
+                resolver.resolveColor(
+                        null,
+                        "255",
+                        WHITE_REFERENCE,
+                        0xffffffff,
+                        ClockColorResolver.Options.batteryBar()));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void batteryBarOptionsRejectBatteryBarOperand() {
+        resolver.resolveColor(
+                null,
+                "#batterybar",
+                WHITE_REFERENCE,
+                0xffffffff,
+                ClockColorResolver.Options.batteryBar());
+    }
 }

app/src/test/java/se/ajpanton/statusbartweak/runtime/features/clock/ClockPatternParserTest.java

@@ -0,0 +1,21 @@
+package se.ajpanton.statusbartweak.runtime.features.clock;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public final class ClockPatternParserTest {
+    private final ClockPatternParser parser = new ClockPatternParser();
+
+    @Test
+    public void lineBreakBlockAcceptsFollowingShorthandTags() {
+        ClockParsedPattern combined = parser.parse("HH{\\n30 big}mm");
+        ClockParsedPattern split = parser.parse("HH{\\n30}{big}mm");
+
+        assertEquals(split.rows.size(), combined.rows.size());
+        assertEquals(2, combined.rows.size());
+        assertEquals(split.rows.get(1).gapBeforePx, combined.rows.get(1).gapBeforePx);
+        assertEquals(30, combined.rows.get(1).gapBeforePx);
+        assertEquals(split.rows.get(1).markup, combined.rows.get(1).markup);
+    }
+}

settings.gradle.kts

@@ -21,3 +21,4 @@ dependencyResolutionManagement {
 
 rootProject.name = "StatusBarTweak"
 include(":app")
+include(":test-harness")

test-harness/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    id("com.android.application")
+}
+
+android {
+    namespace = "se.ajpanton.statusbartweak.harness"
+    compileSdk = 36
+
+    defaultConfig {
+        applicationId = "se.ajpanton.statusbartweak.harness"
+        minSdk = 26
+        targetSdk = 36
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+}

test-harness/src/main/AndroidManifest.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <uses-feature
+        android:name="android.hardware.camera"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.microphone"
+        android:required="false" />
+
+    <application
+        android:allowBackup="false"
+        android:icon="@drawable/ic_harness"
+        android:label="@string/app_name"
+        android:theme="@style/Theme.StatusBarTweakHarness">
+        <service
+            android:name=".HarnessForegroundService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync|mediaPlayback" />
+        <activity
+            android:name=".ScenarioActivity"
+            android:configChanges="keyboardHidden|orientation|screenSize"
+            android:exported="true"
+            android:launchMode="singleTop" />
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

test-harness/src/main/java/se/ajpanton/statusbartweak/harness/HarnessForegroundService.java

@@ -0,0 +1,143 @@
+package se.ajpanton.statusbartweak.harness;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Intent;
+import android.content.pm.ServiceInfo;
+import android.media.MediaMetadata;
+import android.media.session.MediaSession;
+import android.media.session.PlaybackState;
+import android.os.Build;
+import android.os.IBinder;
+
+public final class HarnessForegroundService extends Service {
+    public static final String ACTION_START_MEDIA = "se.ajpanton.statusbartweak.harness.START_MEDIA";
+    public static final String ACTION_START_FOREGROUND =
+            "se.ajpanton.statusbartweak.harness.START_FOREGROUND";
+    public static final String ACTION_STOP = "se.ajpanton.statusbartweak.harness.STOP";
+
+    private static final String CHANNEL_ID = "sbt_harness_foreground";
+    private static final int NOTIFICATION_ID = 42_000;
+
+    private MediaSession mediaSession;
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        String action = intent != null ? intent.getAction() : null;
+        if (ACTION_STOP.equals(action)) {
+            stopSelf();
+            return START_NOT_STICKY;
+        }
+        if (ACTION_START_MEDIA.equals(action)) {
+            startMediaState();
+            return START_STICKY;
+        }
+        startForegroundState();
+        return START_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        if (mediaSession != null) {
+            mediaSession.setActive(false);
+            mediaSession.release();
+            mediaSession = null;
+        }
+        super.onDestroy();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    private void startMediaState() {
+        ensureChannel();
+        if (mediaSession == null) {
+            mediaSession = new MediaSession(this, "StatusBarTweakHarness");
+        }
+        mediaSession.setMetadata(new MediaMetadata.Builder()
+                .putString(MediaMetadata.METADATA_KEY_TITLE, "Harness media")
+                .putString(MediaMetadata.METADATA_KEY_ARTIST, "StatusBarTweak")
+                .build());
+        mediaSession.setPlaybackState(new PlaybackState.Builder()
+                .setState(PlaybackState.STATE_PLAYING, 0, 1f)
+                .setActions(PlaybackState.ACTION_PLAY_PAUSE | PlaybackState.ACTION_STOP)
+                .build());
+        mediaSession.setActive(true);
+
+        Notification.Builder builder = baseBuilder("Harness media", "MediaSession playback active")
+                .setCategory(Notification.CATEGORY_TRANSPORT)
+                .setOngoing(true)
+                .setStyle(new Notification.MediaStyle()
+                        .setMediaSession(mediaSession.getSessionToken())
+                        .setShowActionsInCompactView(0))
+                .addAction(R.drawable.ic_notify, "Stop", stopIntent());
+        startForegroundCompat(builder.build(), ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK);
+    }
+
+    private void startForegroundState() {
+        ensureChannel();
+        Notification notification = baseBuilder(
+                "Harness foreground service",
+                "Generic foreground service notification active")
+                .setCategory(Notification.CATEGORY_SERVICE)
+                .setOngoing(true)
+                .addAction(R.drawable.ic_notify, "Stop", stopIntent())
+                .build();
+        startForegroundCompat(notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC);
+    }
+
+    private Notification.Builder baseBuilder(String title, String text) {
+        Intent launch = new Intent(this, MainActivity.class);
+        PendingIntent launchIntent = PendingIntent.getActivity(
+                this,
+                1,
+                launch,
+                PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
+        return new Notification.Builder(this, CHANNEL_ID)
+                .setSmallIcon(R.drawable.ic_notify)
+                .setContentTitle(title)
+                .setContentText(text)
+                .setContentIntent(launchIntent)
+                .setShowWhen(true);
+    }
+
+    private PendingIntent stopIntent() {
+        Intent stop = new Intent(this, HarnessForegroundService.class);
+        stop.setAction(ACTION_STOP);
+        return PendingIntent.getService(
+                this,
+                2,
+                stop,
+                PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
+    }
+
+    private void startForegroundCompat(Notification notification, int type) {
+        if (Build.VERSION.SDK_INT >= 29) {
+            startForeground(NOTIFICATION_ID, notification, type);
+        } else {
+            startForeground(NOTIFICATION_ID, notification);
+        }
+    }
+
+    private void ensureChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+        NotificationManager nm = getSystemService(NotificationManager.class);
+        if (nm == null) {
+            return;
+        }
+        NotificationChannel channel = new NotificationChannel(
+                CHANNEL_ID,
+                "StatusBarTweak harness foreground",
+                NotificationManager.IMPORTANCE_DEFAULT);
+        channel.setDescription("Foreground and media scenarios for StatusBarTweak testing");
+        channel.setShowBadge(false);
+        nm.createNotificationChannel(channel);
+    }
+}

test-harness/src/main/java/se/ajpanton/statusbartweak/harness/MainActivity.java

@@ -0,0 +1,374 @@
+package se.ajpanton.statusbartweak.harness;
+
+import android.Manifest;
+import android.app.Activity;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.graphics.Color;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.ScrollView;
+import android.widget.TextView;
+
+public final class MainActivity extends Activity {
+    public static final String EXTRA_COMMAND = "command";
+    public static final String COMMAND_POST_NORMAL = "post_normal";
+    public static final String COMMAND_POST_ONGOING = "post_ongoing";
+    public static final String COMMAND_POST_GROUPED = "post_grouped";
+    public static final String COMMAND_UPDATE = "update";
+    public static final String COMMAND_START_CHRONOMETER = "start_chronometer";
+    public static final String COMMAND_START_CHURN = "start_churn";
+    public static final String COMMAND_STOP_CHURN = "stop_churn";
+    public static final String COMMAND_START_MEDIA = "start_media";
+    public static final String COMMAND_START_FOREGROUND = "start_foreground";
+    public static final String COMMAND_STOP_SERVICE = "stop_service";
+    public static final String COMMAND_CLEAR = "clear";
+
+    private static final String CHANNEL_ID = "sbt_harness";
+    private static final int NOTIFICATION_BASE_ID = 41_000;
+    private final Handler handler = new Handler(Looper.getMainLooper());
+    private int updatingCounter = 0;
+    private int churnCounter = 0;
+    private Runnable churnRunnable;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestNotificationPermissionIfNeeded();
+        setContentView(createContent());
+        handleCommand(getIntent());
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        setIntent(intent);
+        handleCommand(intent);
+    }
+
+    private View createContent() {
+        ScrollView scroll = new ScrollView(this);
+        scroll.setBackgroundColor(0xfff7efe5);
+        LinearLayout root = new LinearLayout(this);
+        root.setOrientation(LinearLayout.VERTICAL);
+        root.setPadding(dp(20), dp(20), dp(20), dp(28));
+        scroll.addView(root, new ScrollView.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        TextView title = new TextView(this);
+        title.setText("StatusBarTweak Test Harness");
+        title.setTextColor(Color.BLACK);
+        title.setTextSize(24);
+        title.setGravity(Gravity.START);
+        root.addView(title, matchWrap());
+
+        TextView description = new TextView(this);
+        description.setText(
+                "Open a scenario, then observe StatusBarTweak behavior. "
+                        + "The same APK can be used on emulators and physical devices.");
+        description.setTextColor(0xff333333);
+        description.setTextSize(15);
+        description.setPadding(0, dp(8), 0, dp(12));
+        root.addView(description, matchWrap());
+
+        addSection(root, "Statusbar surfaces");
+        addScenario(root, "Opaque light statusbar", ScenarioActivity.SCENARIO_OPAQUE_LIGHT);
+        addScenario(root, "Opaque dark statusbar", ScenarioActivity.SCENARIO_OPAQUE_DARK);
+        addScenario(root, "Transparent statusbar", ScenarioActivity.SCENARIO_TRANSPARENT);
+        addScenario(root, "Fullscreen portrait", ScenarioActivity.SCENARIO_FULLSCREEN_PORTRAIT);
+        addScenario(root, "Fullscreen landscape", ScenarioActivity.SCENARIO_FULLSCREEN_LANDSCAPE);
+
+        addSection(root, "Privacy indicators");
+        addScenario(root, "Camera privacy indicator", ScenarioActivity.SCENARIO_CAMERA);
+        addScenario(root, "Microphone privacy indicator", ScenarioActivity.SCENARIO_MICROPHONE);
+        addScenario(root, "Camera + microphone indicators", ScenarioActivity.SCENARIO_CAMERA_MICROPHONE);
+
+        addSection(root, "Chip-like public states");
+        addButton(root, "Start media session", v -> startHarnessService(
+                HarnessForegroundService.ACTION_START_MEDIA));
+        addButton(root, "Start foreground service", v -> startHarnessService(
+                HarnessForegroundService.ACTION_START_FOREGROUND));
+        addButton(root, "Post stopwatch/chronometer", v -> postChronometerNotification());
+        addButton(root, "Stop media/foreground service", v -> stopHarnessService());
+
+        addSection(root, "Notifications");
+        addButton(root, "Post normal notification", v -> postNotification(1, false, false, "Normal"));
+        addButton(root, "Post ongoing notification", v -> postNotification(2, true, false, "Ongoing"));
+        addButton(root, "Post grouped notifications", v -> postGroupedNotifications());
+        addButton(root, "Update notification text", v -> {
+            updatingCounter++;
+            postNotification(3, false, true, "Updated " + updatingCounter);
+        });
+        addButton(root, "Start notification churn", v -> startNotificationChurn());
+        addButton(root, "Stop notification churn", v -> stopNotificationChurn());
+        addButton(root, "Clear harness notifications", v -> {
+            stopNotificationChurn();
+            clearNotifications();
+        });
+
+        return scroll;
+    }
+
+    private void handleCommand(Intent intent) {
+        if (intent == null) {
+            return;
+        }
+        String command = intent.getStringExtra(EXTRA_COMMAND);
+        if (command == null) {
+            return;
+        }
+        switch (command) {
+            case COMMAND_POST_NORMAL:
+                postNotification(1, false, false, "Normal");
+                break;
+            case COMMAND_POST_ONGOING:
+                postNotification(2, true, false, "Ongoing");
+                break;
+            case COMMAND_POST_GROUPED:
+                postGroupedNotifications();
+                break;
+            case COMMAND_UPDATE:
+                updatingCounter++;
+                postNotification(3, false, true, "Updated " + updatingCounter);
+                break;
+            case COMMAND_START_CHRONOMETER:
+                postChronometerNotification();
+                break;
+            case COMMAND_START_CHURN:
+                startNotificationChurn();
+                break;
+            case COMMAND_STOP_CHURN:
+                stopNotificationChurn();
+                break;
+            case COMMAND_START_MEDIA:
+                startHarnessService(HarnessForegroundService.ACTION_START_MEDIA);
+                break;
+            case COMMAND_START_FOREGROUND:
+                startHarnessService(HarnessForegroundService.ACTION_START_FOREGROUND);
+                break;
+            case COMMAND_STOP_SERVICE:
+                stopHarnessService();
+                break;
+            case COMMAND_CLEAR:
+                stopNotificationChurn();
+                clearNotifications();
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void addScenario(LinearLayout root, String label, String scenario) {
+        addButton(root, label, v -> {
+            Intent intent = new Intent(this, ScenarioActivity.class);
+            intent.putExtra(ScenarioActivity.EXTRA_SCENARIO, scenario);
+            startActivity(intent);
+        });
+    }
+
+    private void addSection(LinearLayout root, String label) {
+        TextView view = new TextView(this);
+        view.setText(label);
+        view.setTextColor(0xff444444);
+        view.setTextSize(17);
+        view.setPadding(0, dp(18), 0, dp(6));
+        root.addView(view, matchWrap());
+    }
+
+    private void addButton(LinearLayout root, String label, View.OnClickListener listener) {
+        Button button = new Button(this);
+        button.setText(label);
+        button.setAllCaps(false);
+        button.setOnClickListener(listener);
+        LinearLayout.LayoutParams params = matchWrap();
+        params.setMargins(0, dp(4), 0, dp(4));
+        root.addView(button, params);
+    }
+
+    private void postNotification(int slot, boolean ongoing, boolean alertOnlyOnce, String label) {
+        requestNotificationPermissionIfNeeded();
+        NotificationManager nm = getSystemService(NotificationManager.class);
+        if (nm == null || !canPostNotifications()) {
+            return;
+        }
+        ensureChannel(nm);
+        Intent launch = new Intent(this, MainActivity.class);
+        PendingIntent pendingIntent = PendingIntent.getActivity(
+                this,
+                slot,
+                launch,
+                PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
+        Notification.Builder builder = new Notification.Builder(this, CHANNEL_ID)
+                .setSmallIcon(R.drawable.ic_notify)
+                .setContentTitle("Harness " + label)
+                .setContentText("Package: " + getPackageName())
+                .setContentIntent(pendingIntent)
+                .setShowWhen(true)
+                .setOnlyAlertOnce(alertOnlyOnce)
+                .setCategory(Notification.CATEGORY_STATUS);
+        if (ongoing) {
+            builder.setOngoing(true);
+        }
+        nm.notify(NOTIFICATION_BASE_ID + slot, builder.build());
+    }
+
+    private void postGroupedNotifications() {
+        requestNotificationPermissionIfNeeded();
+        NotificationManager nm = getSystemService(NotificationManager.class);
+        if (nm == null || !canPostNotifications()) {
+            return;
+        }
+        ensureChannel(nm);
+        String group = "sbt_harness_group";
+        for (int i = 0; i < 3; i++) {
+            Notification notification = new Notification.Builder(this, CHANNEL_ID)
+                    .setSmallIcon(R.drawable.ic_notify)
+                    .setContentTitle("Harness grouped " + (i + 1))
+                    .setContentText("Grouped notification")
+                    .setGroup(group)
+                    .setShowWhen(false)
+                    .build();
+            nm.notify(NOTIFICATION_BASE_ID + 10 + i, notification);
+        }
+        Notification summary = new Notification.Builder(this, CHANNEL_ID)
+                .setSmallIcon(R.drawable.ic_notify)
+                .setContentTitle("Harness group")
+                .setContentText("Group summary")
+                .setGroup(group)
+                .setGroupSummary(true)
+                .build();
+        nm.notify(NOTIFICATION_BASE_ID + 20, summary);
+    }
+
+    private void postChronometerNotification() {
+        requestNotificationPermissionIfNeeded();
+        NotificationManager nm = getSystemService(NotificationManager.class);
+        if (nm == null || !canPostNotifications()) {
+            return;
+        }
+        ensureChannel(nm);
+        Notification notification = new Notification.Builder(this, CHANNEL_ID)
+                .setSmallIcon(R.drawable.ic_notify)
+                .setContentTitle("Harness stopwatch")
+                .setContentText("Chronometer notification active")
+                .setWhen(System.currentTimeMillis())
+                .setUsesChronometer(true)
+                .setOngoing(true)
+                .setOnlyAlertOnce(true)
+                .setCategory(Notification.CATEGORY_STATUS)
+                .build();
+        nm.notify(NOTIFICATION_BASE_ID + 30, notification);
+    }
+
+    private void startNotificationChurn() {
+        requestNotificationPermissionIfNeeded();
+        if (!canPostNotifications()) {
+            return;
+        }
+        if (churnRunnable != null) {
+            return;
+        }
+        churnRunnable = new Runnable() {
+            @Override
+            public void run() {
+                churnCounter++;
+                postNotification(40, false, true, "Churn " + churnCounter);
+                postNotification(41, true, true, "Ongoing churn " + churnCounter);
+                if (churnCounter % 2 == 0) {
+                    postNotification(42, false, true, "Intermittent " + churnCounter);
+                } else {
+                    NotificationManager nm = getSystemService(NotificationManager.class);
+                    if (nm != null) {
+                        nm.cancel(NOTIFICATION_BASE_ID + 42);
+                    }
+                }
+                handler.postDelayed(this, 1000);
+            }
+        };
+        churnRunnable.run();
+    }
+
+    private void stopNotificationChurn() {
+        if (churnRunnable != null) {
+            handler.removeCallbacks(churnRunnable);
+            churnRunnable = null;
+        }
+    }
+
+    private void startHarnessService(String action) {
+        requestNotificationPermissionIfNeeded();
+        if (!canPostNotifications()) {
+            return;
+        }
+        Intent intent = new Intent(this, HarnessForegroundService.class);
+        intent.setAction(action);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            startForegroundService(intent);
+        } else {
+            startService(intent);
+        }
+    }
+
+    private void stopHarnessService() {
+        Intent intent = new Intent(this, HarnessForegroundService.class);
+        intent.setAction(HarnessForegroundService.ACTION_STOP);
+        startService(intent);
+    }
+
+    private void clearNotifications() {
+        NotificationManager nm = getSystemService(NotificationManager.class);
+        if (nm != null) {
+            nm.cancelAll();
+        }
+        stopHarnessService();
+    }
+
+    private void ensureChannel(NotificationManager nm) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+        NotificationChannel channel = new NotificationChannel(
+                CHANNEL_ID,
+                "StatusBarTweak harness",
+                NotificationManager.IMPORTANCE_DEFAULT);
+        channel.setDescription("Scenario notifications for StatusBarTweak compatibility testing");
+        channel.setShowBadge(false);
+        nm.createNotificationChannel(channel);
+    }
+
+    private void requestNotificationPermissionIfNeeded() {
+        if (Build.VERSION.SDK_INT < 33 || canPostNotifications()) {
+            return;
+        }
+        requestPermissions(new String[]{Manifest.permission.POST_NOTIFICATIONS}, 200);
+    }
+
+    private boolean canPostNotifications() {
+        return Build.VERSION.SDK_INT < 33
+                || checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS)
+                == PackageManager.PERMISSION_GRANTED;
+    }
+
+    private LinearLayout.LayoutParams matchWrap() {
+        return new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+    }
+
+    private int dp(int value) {
+        return Math.round(value * getResources().getDisplayMetrics().density);
+    }
+}

test-harness/src/main/java/se/ajpanton/statusbartweak/harness/ScenarioActivity.java

@@ -0,0 +1,483 @@
+package se.ajpanton.statusbartweak.harness;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.PackageManager;
+import android.graphics.Color;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.MediaRecorder;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowInsets;
+import android.view.WindowInsetsController;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+public final class ScenarioActivity extends Activity {
+    public static final String EXTRA_SCENARIO = "scenario";
+    public static final String SCENARIO_OPAQUE_LIGHT = "opaque_light";
+    public static final String SCENARIO_OPAQUE_DARK = "opaque_dark";
+    public static final String SCENARIO_TRANSPARENT = "transparent";
+    public static final String SCENARIO_FULLSCREEN_PORTRAIT = "fullscreen_portrait";
+    public static final String SCENARIO_FULLSCREEN_LANDSCAPE = "fullscreen_landscape";
+    public static final String SCENARIO_CAMERA = "camera";
+    public static final String SCENARIO_MICROPHONE = "microphone";
+    public static final String SCENARIO_CAMERA_MICROPHONE = "camera_microphone";
+
+    private static final int REQUEST_CAMERA = 301;
+    private static final int REQUEST_MICROPHONE = 302;
+    private static final int REQUEST_CAMERA_MICROPHONE = 303;
+
+    private HandlerThread cameraThread;
+    private Handler cameraHandler;
+    private CameraDevice cameraDevice;
+    private AudioRecord audioRecord;
+    private Thread audioThread;
+    private volatile boolean audioRunning;
+    private TextView statusText;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        applyScenario(getIntent());
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        setIntent(intent);
+        stopCamera();
+        stopMicrophone();
+        applyScenario(intent);
+    }
+
+    private void applyScenario(Intent intent) {
+        String scenario = intent != null ? intent.getStringExtra(EXTRA_SCENARIO) : null;
+        if (scenario == null) {
+            scenario = SCENARIO_OPAQUE_LIGHT;
+        }
+        final String activeScenario = scenario;
+        boolean lightBars = configureWindow(activeScenario);
+        View content = createScenarioView(activeScenario);
+        setContentView(content);
+        content.post(() -> {
+            setLightBars(lightBars);
+            if (isFullscreen(activeScenario)) {
+                hideSystemBars();
+            }
+        });
+        startScenarioIfNeeded(activeScenario);
+    }
+
+    @Override
+    protected void onDestroy() {
+        stopCamera();
+        stopMicrophone();
+        super.onDestroy();
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        boolean granted = true;
+        for (int result : grantResults) {
+            granted &= result == PackageManager.PERMISSION_GRANTED;
+        }
+        granted &= grantResults.length > 0;
+        if (!granted) {
+            setStatus("Permission denied.");
+            return;
+        }
+        if (requestCode == REQUEST_CAMERA) {
+            startCamera();
+        } else if (requestCode == REQUEST_MICROPHONE) {
+            startMicrophone();
+        } else if (requestCode == REQUEST_CAMERA_MICROPHONE) {
+            startCameraAndMicrophone();
+        }
+    }
+
+    private boolean configureWindow(String scenario) {
+        Window window = getWindow();
+        if (Build.VERSION.SDK_INT >= 28) {
+            window.getAttributes().layoutInDisplayCutoutMode =
+                    android.view.WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
+        }
+
+        if (SCENARIO_FULLSCREEN_LANDSCAPE.equals(scenario)) {
+            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+        } else if (SCENARIO_FULLSCREEN_PORTRAIT.equals(scenario)) {
+            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+        }
+
+        if (SCENARIO_OPAQUE_LIGHT.equals(scenario)) {
+            window.setStatusBarColor(Color.WHITE);
+            window.setNavigationBarColor(Color.WHITE);
+            return true;
+        } else if (SCENARIO_OPAQUE_DARK.equals(scenario)) {
+            window.setStatusBarColor(Color.BLACK);
+            window.setNavigationBarColor(Color.BLACK);
+            return false;
+        } else if (SCENARIO_TRANSPARENT.equals(scenario)) {
+            window.setStatusBarColor(Color.TRANSPARENT);
+            window.setNavigationBarColor(Color.TRANSPARENT);
+            if (Build.VERSION.SDK_INT >= 30) {
+                window.setDecorFitsSystemWindows(false);
+            }
+            return false;
+        } else if (isFullscreen(scenario)) {
+            window.setStatusBarColor(Color.TRANSPARENT);
+            window.setNavigationBarColor(Color.BLACK);
+            if (Build.VERSION.SDK_INT >= 30) {
+                window.setDecorFitsSystemWindows(false);
+            }
+            return false;
+        } else {
+            window.setStatusBarColor(0xff202124);
+            window.setNavigationBarColor(0xff202124);
+            return false;
+        }
+    }
+
+    private View createScenarioView(String scenario) {
+        LinearLayout root = new LinearLayout(this);
+        root.setOrientation(LinearLayout.VERTICAL);
+        root.setGravity(Gravity.CENTER);
+        root.setPadding(dp(24), dp(60), dp(24), dp(60));
+        root.setBackgroundColor(backgroundColor(scenario));
+
+        TextView title = new TextView(this);
+        title.setText(titleFor(scenario));
+        title.setTextColor(textColor(scenario));
+        title.setTextSize(28);
+        title.setGravity(Gravity.CENTER);
+        root.addView(title, matchWrap());
+
+        statusText = new TextView(this);
+        statusText.setText(statusFor(scenario));
+        statusText.setTextColor(textColor(scenario));
+        statusText.setAlpha(0.85f);
+        statusText.setTextSize(16);
+        statusText.setGravity(Gravity.CENTER);
+        statusText.setPadding(0, dp(12), 0, dp(20));
+        root.addView(statusText, matchWrap());
+
+        if (isFullscreen(scenario)) {
+            addButton(root, "Temporarily show system bars", v -> showSystemBarsBriefly());
+        }
+        if (SCENARIO_CAMERA.equals(scenario)) {
+            addButton(root, "Start camera privacy indicator", v -> startCamera());
+            addButton(root, "Stop camera", v -> stopCamera());
+        }
+        if (SCENARIO_MICROPHONE.equals(scenario)) {
+            addButton(root, "Start microphone privacy indicator", v -> startMicrophone());
+            addButton(root, "Stop microphone", v -> stopMicrophone());
+        }
+        if (SCENARIO_CAMERA_MICROPHONE.equals(scenario)) {
+            addButton(root, "Start both indicators", v -> startCameraAndMicrophone());
+            addButton(root, "Stop both", v -> {
+                stopCamera();
+                stopMicrophone();
+            });
+        }
+        addButton(root, "Finish scenario", v -> finish());
+        return root;
+    }
+
+    private void startScenarioIfNeeded(String scenario) {
+        if (SCENARIO_CAMERA.equals(scenario)) {
+            startCamera();
+        } else if (SCENARIO_MICROPHONE.equals(scenario)) {
+            startMicrophone();
+        } else if (SCENARIO_CAMERA_MICROPHONE.equals(scenario)) {
+            startCameraAndMicrophone();
+        }
+    }
+
+    private int backgroundColor(String scenario) {
+        if (SCENARIO_OPAQUE_LIGHT.equals(scenario)) {
+            return Color.WHITE;
+        }
+        if (SCENARIO_TRANSPARENT.equals(scenario)) {
+            return 0xff0d47a1;
+        }
+        if (isFullscreen(scenario)) {
+            return 0xff1b5e20;
+        }
+        return 0xff101214;
+    }
+
+    private int textColor(String scenario) {
+        return SCENARIO_OPAQUE_LIGHT.equals(scenario) ? Color.BLACK : Color.WHITE;
+    }
+
+    private String titleFor(String scenario) {
+        switch (scenario) {
+            case SCENARIO_OPAQUE_LIGHT:
+                return "Opaque light statusbar";
+            case SCENARIO_OPAQUE_DARK:
+                return "Opaque dark statusbar";
+            case SCENARIO_TRANSPARENT:
+                return "Transparent statusbar";
+            case SCENARIO_FULLSCREEN_PORTRAIT:
+                return "Fullscreen portrait";
+            case SCENARIO_FULLSCREEN_LANDSCAPE:
+                return "Fullscreen landscape";
+            case SCENARIO_CAMERA:
+                return "Camera privacy indicator";
+            case SCENARIO_MICROPHONE:
+                return "Microphone privacy indicator";
+            case SCENARIO_CAMERA_MICROPHONE:
+                return "Camera + microphone indicators";
+            default:
+                return "Scenario";
+        }
+    }
+
+    private String statusFor(String scenario) {
+        if (isFullscreen(scenario)) {
+            return "System bars are hidden. Swipe from an edge or use the button below to reveal them.";
+        }
+        if (SCENARIO_TRANSPARENT.equals(scenario)) {
+            return "Content is laid out behind a transparent statusbar.";
+        }
+        if (SCENARIO_CAMERA.equals(scenario)) {
+            return "Camera should stay open until stopped or this screen is closed.";
+        }
+        if (SCENARIO_MICROPHONE.equals(scenario)) {
+            return "AudioRecord should stay active until stopped or this screen is closed.";
+        }
+        if (SCENARIO_CAMERA_MICROPHONE.equals(scenario)) {
+            return "Camera and AudioRecord should stay active until stopped or this screen is closed.";
+        }
+        return "This screen uses a normal app statusbar.";
+    }
+
+    private void startCamera() {
+        if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+            requestPermissions(new String[]{Manifest.permission.CAMERA}, REQUEST_CAMERA);
+            return;
+        }
+        if (cameraDevice != null) {
+            setStatus("Camera already active.");
+            return;
+        }
+        CameraManager manager = getSystemService(CameraManager.class);
+        if (manager == null) {
+            setStatus("CameraManager unavailable.");
+            return;
+        }
+        try {
+            String[] ids = manager.getCameraIdList();
+            if (ids.length == 0) {
+                setStatus("No camera reported by this device.");
+                return;
+            }
+            cameraThread = new HandlerThread("SbtHarnessCamera");
+            cameraThread.start();
+            cameraHandler = new Handler(cameraThread.getLooper());
+            manager.openCamera(ids[0], new CameraDevice.StateCallback() {
+                @Override
+                public void onOpened(CameraDevice camera) {
+                    cameraDevice = camera;
+                    setStatus("Camera active: " + ids[0]);
+                }
+
+                @Override
+                public void onDisconnected(CameraDevice camera) {
+                    stopCamera();
+                    setStatus("Camera disconnected.");
+                }
+
+                @Override
+                public void onError(CameraDevice camera, int error) {
+                    stopCamera();
+                    setStatus("Camera error: " + error);
+                }
+            }, cameraHandler);
+        } catch (CameraAccessException | SecurityException | IllegalArgumentException e) {
+            stopCamera();
+            setStatus("Camera failed: " + e.getClass().getSimpleName());
+        }
+    }
+
+    private void startCameraAndMicrophone() {
+        boolean hasCamera = checkSelfPermission(Manifest.permission.CAMERA)
+                == PackageManager.PERMISSION_GRANTED;
+        boolean hasMic = checkSelfPermission(Manifest.permission.RECORD_AUDIO)
+                == PackageManager.PERMISSION_GRANTED;
+        if (!hasCamera || !hasMic) {
+            requestPermissions(
+                    new String[]{Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO},
+                    REQUEST_CAMERA_MICROPHONE);
+            return;
+        }
+        startCamera();
+        startMicrophone();
+    }
+
+    private void stopCamera() {
+        if (cameraDevice != null) {
+            cameraDevice.close();
+            cameraDevice = null;
+        }
+        if (cameraThread != null) {
+            cameraThread.quitSafely();
+            cameraThread = null;
+            cameraHandler = null;
+        }
+        setStatus("Camera stopped.");
+    }
+
+    private void startMicrophone() {
+        if (checkSelfPermission(Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
+            requestPermissions(new String[]{Manifest.permission.RECORD_AUDIO}, REQUEST_MICROPHONE);
+            return;
+        }
+        if (audioRecord != null) {
+            setStatus("Microphone already active.");
+            return;
+        }
+        int sampleRate = 8000;
+        int minBuffer = AudioRecord.getMinBufferSize(
+                sampleRate,
+                AudioFormat.CHANNEL_IN_MONO,
+                AudioFormat.ENCODING_PCM_16BIT);
+        int bufferSize = Math.max(minBuffer, 2048);
+        try {
+            audioRecord = new AudioRecord(
+                    MediaRecorder.AudioSource.MIC,
+                    sampleRate,
+                    AudioFormat.CHANNEL_IN_MONO,
+                    AudioFormat.ENCODING_PCM_16BIT,
+                    bufferSize);
+            audioRecord.startRecording();
+            audioRunning = true;
+            audioThread = new Thread(() -> {
+                byte[] buffer = new byte[bufferSize];
+                while (audioRunning && audioRecord != null) {
+                    audioRecord.read(buffer, 0, buffer.length);
+                }
+            }, "SbtHarnessMic");
+            audioThread.start();
+            setStatus("Microphone active.");
+        } catch (SecurityException | IllegalStateException | IllegalArgumentException e) {
+            stopMicrophone();
+            setStatus("Microphone failed: " + e.getClass().getSimpleName());
+        }
+    }
+
+    private void stopMicrophone() {
+        audioRunning = false;
+        if (audioRecord != null) {
+            try {
+                audioRecord.stop();
+            } catch (IllegalStateException ignored) {
+            }
+            audioRecord.release();
+            audioRecord = null;
+        }
+        audioThread = null;
+        setStatus("Microphone stopped.");
+    }
+
+    private void setStatus(String status) {
+        if (statusText != null) {
+            runOnUiThread(() -> statusText.setText(status));
+        }
+    }
+
+    private boolean isFullscreen(String scenario) {
+        return SCENARIO_FULLSCREEN_PORTRAIT.equals(scenario)
+                || SCENARIO_FULLSCREEN_LANDSCAPE.equals(scenario);
+    }
+
+    private void hideSystemBars() {
+        if (Build.VERSION.SDK_INT >= 30) {
+            WindowInsetsController controller = getWindow().getInsetsController();
+            if (controller != null) {
+                controller.setSystemBarsBehavior(
+                        WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
+                controller.hide(WindowInsets.Type.systemBars());
+            }
+        } else {
+            getWindow().getDecorView().setSystemUiVisibility(
+                    View.SYSTEM_UI_FLAG_FULLSCREEN
+                            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                            | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+                            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                            | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
+        }
+    }
+
+    private void showSystemBarsBriefly() {
+        if (Build.VERSION.SDK_INT >= 30) {
+            WindowInsetsController controller = getWindow().getInsetsController();
+            if (controller != null) {
+                controller.show(WindowInsets.Type.systemBars());
+            }
+        } else {
+            getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
+        }
+        getWindow().getDecorView().postDelayed(this::hideSystemBars, 2500);
+    }
+
+    private void setLightBars(boolean lightBars) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            WindowInsetsController controller = getWindow().getInsetsController();
+            if (controller != null) {
+                int mask = WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS
+                        | WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS;
+                controller.setSystemBarsAppearance(lightBars ? mask : 0, mask);
+            }
+        } else if (Build.VERSION.SDK_INT >= 23) {
+            int flags = getWindow().getDecorView().getSystemUiVisibility();
+            if (lightBars) {
+                flags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
+                if (Build.VERSION.SDK_INT >= 26) {
+                    flags |= View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
+                }
+            } else {
+                flags &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
+                if (Build.VERSION.SDK_INT >= 26) {
+                    flags &= ~View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
+                }
+            }
+            getWindow().getDecorView().setSystemUiVisibility(flags);
+        }
+    }
+
+    private void addButton(LinearLayout root, String label, View.OnClickListener listener) {
+        Button button = new Button(this);
+        button.setText(label);
+        button.setAllCaps(false);
+        button.setOnClickListener(listener);
+        LinearLayout.LayoutParams params = matchWrap();
+        params.setMargins(0, dp(8), 0, 0);
+        root.addView(button, params);
+    }
+
+    private LinearLayout.LayoutParams matchWrap() {
+        return new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+    }
+
+    private int dp(int value) {
+        return Math.round(value * getResources().getDisplayMetrics().density);
+    }
+}

test-harness/src/main/res/drawable/ic_harness.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="48dp"
+    android:height="48dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <path
+        android:fillColor="#202124"
+        android:pathData="M4,4h40v40h-40z" />
+    <path
+        android:fillColor="#00E676"
+        android:pathData="M4,4h32v5h-32z" />
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M8,16h32v4h-32zM8,24h24v4h-24zM8,32h16v4h-16z" />
+</vector>

test-harness/src/main/res/drawable/ic_notify.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M4,5h16v11h-12l-4,4z" />
+</vector>

test-harness/src/main/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="harness_accent">#00E676</color>
+</resources>

test-harness/src/main/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">SBT Test Harness</string>
+</resources>

test-harness/src/main/res/values/themes.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.StatusBarTweakHarness" parent="@android:style/Theme.Material.NoActionBar">
+        <item name="android:fontFamily">sans</item>
+        <item name="android:windowActionModeOverlay">true</item>
+        <item name="android:navigationBarColor">#111111</item>
+        <item name="android:colorAccent">@color/harness_accent</item>
+    </style>
+</resources>

version.properties

@@ -1 +1 @@
-version=0.1
+version=0.6