Release 0.7

.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
+StatusBarTweak is an Xposed/LSPosed module originally built for Samsung
-making the status bar, lockscreen, and Always On Display more configurable while
+SystemUI. It focuses on making the status bar, lockscreen, and Always On
-still keeping Samsung's own icons and visual style where possible.
+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
+The project is physically tested only on a Samsung Galaxy Z Fold5 running One UI
-8.0 / Android 16. Expect device- and One UI-version-specific behaviour.
+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 rooted Android 14+ device or emulator. Actual feature support depends on
-- A modern Xposed implementation such as LSPosed.
+  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
+The module is developed and manually tested on a Samsung Galaxy Z Fold5 running
-non-Samsung SystemUI, and updates to One UI may require fixes.
+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,
+Some behavior cannot be fully verified on emulators. Emulator testing can still
-such as drawing a custom battery bar or parsing custom clock text, could be
+verify whether hooks load, whether SystemUI stays stable, whether settings apply,
-ported elsewhere. The layout engine itself depends on Samsung's SystemUI,
+whether excessive background work appears in logs, and whether the steady state
-lockscreen, AOD service, notification display modes, status icons, and status
+looks the way it should.
-chip implementation.
 
-Plain Android or other OEM skins would need separate hooks and probably a
+`⚠️ Experimental` means best-effort support exists, but the emulator cannot
-different source-collection layer. They should be treated as unsupported rather
+expose the required hardware or state for real verification.
-than untested-compatible.
+
+| 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
+The repository also includes a small companion app for compatibility testing.
-design decisions, device testing, and final behaviour are still manually
+It is not required for normal use of the module. It creates repeatable
-reviewed.
+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)
+        if (!SystemUiCapabilities.isHandledProcessName(processName)) {
-                && !PACKAGE_ANDROID.equals(processName)
-                && !PACKAGE_SYSTEM.equals(processName)
-                && !PACKAGE_AODSERVICE.equals(processName)) {
             return;
         }
         standaloneFeatureRegistry.onModuleLoaded(param);
@@ -54,9 +47,6 @@ public final class ModuleCoordinator {
     }
 
     private static boolean shouldHandlePackage(String packageName) {
-        return PACKAGE_SYSTEMUI.equals(packageName)
+        return SystemUiCapabilities.isHandledPackageName(packageName);
-                || PACKAGE_ANDROID.equals(packageName)
-                || PACKAGE_SYSTEM.equals(packageName)
-                || PACKAGE_AODSERVICE.equals(packageName);
     }
 }

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

@@ -0,0 +1,66 @@
+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 static final boolean SAMSUNG_ONE_UI = "samsung".equalsIgnoreCase(Build.MANUFACTURER);
+
+    private SystemUiCapabilities() {
+    }
+
+    public static boolean isSamsungOneUi() {
+        return SAMSUNG_ONE_UI;
+    }
+
+    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

@@ -1,5 +1,6 @@
 package se.ajpanton.statusbartweak.runtime;
 
+import android.annotation.SuppressLint;
 import android.content.res.Resources;
 import android.view.View;
 
@@ -7,8 +8,9 @@ public final class ViewIdNames {
     private ViewIdNames() {
     }
 
+    @SuppressLint("ResourceType") // Foreign SystemUI ids are opaque integers, not this app's R.id values.
     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;
@@ -55,8 +59,8 @@ final class BatteryBarController {
     private final Map<View, OverlayBatteryBar> overlayBatteryBars = new WeakHashMap<>();
     private final Map<View, View.OnLayoutChangeListener> rootLayoutListeners = new WeakHashMap<>();
     private final Set<View> pendingOverlayRetries = Collections.newSetFromMap(new WeakHashMap<>());
-    private final Map<View, String> lastSignatures = new WeakHashMap<>();
+    private final Map<View, RenderSignature> lastSignatures = new WeakHashMap<>();
-    private final Map<View, String> lastOverlaySignatures = new WeakHashMap<>();
+    private final Map<View, RenderSignature> lastOverlaySignatures = new WeakHashMap<>();
     private final Map<View, Integer> lastRootTransformSignatures = new WeakHashMap<>();
     private int systemBarAppearance;
     private int systemBarBehavior;
@@ -83,7 +87,7 @@ final class BatteryBarController {
         installRootTransformHooks();
         installSystemBarAttributeListener(classLoader);
         installTransientBarListener(classLoader);
-        runtimeContext.getModeStateRepository().addSceneListener((previous, current) -> refreshAllRoots());
+        runtimeContext.getModeStateRepository().addSceneListener((previous, current) -> postRefreshAllRoots());
         hooksInstalled = true;
     }
 
@@ -145,17 +149,18 @@ final class BatteryBarController {
             }
             return result;
         });
-        XposedHookSupport.hookAllMethodsIfExists(framework, View.class, "setY", chain -> {
-            Object result = chain.proceed();
-            Object target = chain.getThisObject();
-            if (target instanceof View root && roots.contains(root)) {
-                applyBatteryBarAfterRootTransform(root);
-            }
-            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 +276,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();
@@ -360,10 +366,6 @@ final class BatteryBarController {
     }
 
     private void applyBatteryBar(View root) {
-        applyBatteryBarInternal(root);
-    }
-
-    private void applyBatteryBarInternal(View root) {
         if (!(root instanceof ViewGroup rootGroup)) {
             removeBatteryBarView(root);
             return;
@@ -373,21 +375,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);
@@ -395,15 +402,15 @@ final class BatteryBarController {
             return;
         }
         removeOverlayBatteryBar(root);
-        String signature = buildSignature(root, settings, color, geometry, scenario);
+        RenderSignature signature = RenderSignature.of(
+                root, scenario, batteryLevel, plugged, color, geometry, settings);
         BatteryBarView existingView = batteryBarViews.get(root);
-        String lastSignature = lastSignatures.get(root);
+        RenderSignature lastSignature = lastSignatures.get(root);
         if (signature.equals(lastSignature) && existingView != null && existingView.getParent() == rootGroup) {
             existingView.bringToFront();
             return;
         }
         applyEmbeddedBatteryBar(rootGroup, settings, geometry, scenario, color);
-        lastSignatures.put(root, signature);
     }
 
     private void applyEmbeddedBatteryBar(
@@ -415,10 +422,12 @@ 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));
+        lastSignatures.put(
+                rootGroup,
+                RenderSignature.of(rootGroup, scenario, batteryLevel, plugged, color, geometry, settings));
     }
 
     private void applyOverlayBatteryBar(
@@ -428,7 +437,8 @@ final class BatteryBarController {
             BatteryBarGeometry.Scenario scenario,
             int color
     ) {
-        String signature = buildSignature(root, settings, color, geometry, scenario);
+        RenderSignature signature = RenderSignature.of(
+                root, scenario, batteryLevel, plugged, color, geometry, settings);
         OverlayBatteryBar overlay = overlayBatteryBars.get(root);
         if (overlay == null) {
             overlay = new OverlayBatteryBar(root.getContext());
@@ -442,7 +452,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);
@@ -515,39 +525,21 @@ final class BatteryBarController {
         );
     }
 
-    private String buildSignature(
-            View root,
-            SbtSettings settings,
-            int color,
-            BatteryBarGeometry geometry,
-            BatteryBarGeometry.Scenario scenario
-    ) {
-        return root.getWidth() + "|"
-                + root.getHeight() + "|"
-                + scenario + "|"
-                + batteryLevel + "|"
-                + plugged + "|"
-                + color + "|"
-                + settings.batteryBarEnabled + "|"
-                + settings.batteryBarPosition + "|"
-                + settings.batteryBarAlignment + "|"
-                + settings.batteryBarThicknessDp + "|"
-                + settings.batteryBarEdgeOffsetDp + "|"
-                + settings.batteryBarCurvedGeometryMode + "|"
-                + (geometry != null ? geometry.signature() : "") + "|"
-                + settings.batteryBarMinLevel + "|"
-                + settings.batteryBarMaxLevel + "|"
-                + settings.batteryBarDefaultDischargeColor + "|"
-                + settings.batteryBarDefaultChargeColor + "|"
-                + BatteryBarStyle.encodeThresholds(settings.batteryBarThresholds);
-    }
-
     private BatteryBarGeometry.Scenario scenarioForRoot(View root) {
         if (isKeyguardRoot(root)) {
             return BatteryBarGeometry.Scenario.LOCKSCREEN;
         }
+        SceneKey scene = runtimeContext.getModeStateRepository().getActiveScene();
+        if (isPhoneRoot(root)
+                && scene != null
+                && scene.isLockscreen()
+                && isKeyguardLocked(root.getContext())
+                && !isStatusBarSurfaceHidden(root)
+                && !isFullscreenSystemBarState()) {
+            return BatteryBarGeometry.Scenario.LOCKSCREEN;
+        }
         boolean fullscreen = isPhoneRoot(root)
-                && isUnlockedScene()
+                && (isUnlockedScene() || isLockedPhoneFullscreenRoot(root))
                 && (isStatusBarSurfaceHidden(root) || isFullscreenSystemBarState());
         boolean landscape = isLandscapeForRoot(root, fullscreen);
         if (fullscreen) {
@@ -565,6 +557,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 +595,26 @@ final class BatteryBarController {
             return scene == null || !scene.isUnlocked();
         }
         if (isPhoneRoot(root)) {
-            return scene == null || scene.isUnlocked();
+            if (scene == null || scene.isUnlocked()) {
+                return true;
+            }
+            if (isLockedPhoneStatusBarRoot(root)) {
+                return isLockedPhoneFullscreenRoot(root)
+                        || (!isStatusBarSurfaceHidden(root) && !isFullscreenSystemBarState());
+            }
+            return false;
         }
         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 +628,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();
     }
@@ -632,7 +671,15 @@ final class BatteryBarController {
     }
 
     private boolean shouldRenderVisibleFullscreenBar(View root) {
-        return root != null && isFullscreenSystemBarState() && statusBarTransientShown;
+        return root != null
+                && isFullscreenSystemBarState()
+                && statusBarTransientShown
+                && isStatusBarWindowVisible(root);
+    }
+
+    private boolean isStatusBarWindowVisible(View root) {
+        WindowInsets insets = root.getRootWindowInsets();
+        return insets == null || insets.isVisible(WindowInsets.Type.statusBars());
     }
 
     private void updateTransientBarState(java.util.List<Object> args, boolean visible) {
@@ -670,13 +717,7 @@ final class BatteryBarController {
     }
 
     private OverlayBounds fullscreenOverlayBounds(View root) {
-        int width = root.getWidth();
+        return new OverlayBounds(root.getWidth(), root.getHeight());
-        int height = root.getHeight();
-        Rect bounds = currentWindowBounds(root.getContext());
-        if (bounds.width() > 0) {
-            width = bounds.width();
-        }
-        return new OverlayBounds(width, height);
     }
 
     private static Rect currentWindowBounds(Context context) {
@@ -698,6 +739,47 @@ final class BatteryBarController {
     private record OverlayBounds(int width, int height) {
     }
 
+    private record RenderSignature(
+            int width,
+            int height,
+            BatteryBarGeometry.Scenario scenario,
+            int batteryLevel,
+            boolean plugged,
+            int color,
+            String position,
+            String alignment,
+            int thicknessDp,
+            int edgeOffsetDp,
+            String curvedGeometryMode,
+            int minLevel,
+            int maxLevel
+    ) {
+        static RenderSignature of(
+                View root,
+                BatteryBarGeometry.Scenario scenario,
+                int batteryLevel,
+                boolean plugged,
+                int color,
+                BatteryBarGeometry geometry,
+                SbtSettings settings
+        ) {
+            return new RenderSignature(
+                    root.getWidth(),
+                    root.getHeight(),
+                    scenario,
+                    batteryLevel,
+                    plugged,
+                    color,
+                    geometry.position,
+                    geometry.alignment,
+                    geometry.thicknessDp,
+                    geometry.edgeOffsetDp,
+                    geometry.curvedGeometryMode,
+                    settings.batteryBarMinLevel,
+                    settings.batteryBarMaxLevel);
+        }
+    }
+
     private void updateSystemBarState(java.util.List<Object> args) {
         if (args == null || args.size() < 2) {
             return;
@@ -758,6 +840,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 +1030,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 +1057,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 +1073,7 @@ final class BatteryBarController {
 
         void update(
                 ViewGroup host,
+                View roundedCornerSource,
                 SbtSettings settings,
                 BatteryBarGeometry geometry,
                 int batteryLevel,
@@ -971,6 +1081,7 @@ final class BatteryBarController {
                 int color
         ) {
             this.host = host;
+            this.roundedCornerSource = roundedCornerSource;
             this.settings = settings;
             this.geometry = geometry;
             this.batteryLevel = batteryLevel;
@@ -996,7 +1107,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 +1129,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 +1150,47 @@ final class BatteryBarController {
                 return false;
             }
             return !SbtSettings.BATTERY_BAR_CURVED_GEOMETRY_OFF.equals(
-                    settings.batteryBarCurvedGeometryMode);
+                    geometry.curvedGeometryMode);
         }
 
         private void buildCurvedPath(
-                int left,
+                int width,
-                int right,
                 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;
+            buildFullCurvePath(width, height, thickness);
-            float leftCenter = left + halfStroke;
-            float rightCenter = right - halfStroke;
-            if (rightCenter <= leftCenter) {
-                return;
-            }
-            buildFullCurvePath(leftCenter, rightCenter, height, thickness);
             pathMeasure.setPath(fullCurvePath, false);
             float fullLength = pathMeasure.getLength();
             if (fullLength <= 0f) {
                 return;
             }
-            float targetLength = SbtSettings.BATTERY_BAR_CURVED_GEOMETRY_LENGTH.equals(
+            float pathOffset = Math.min(Math.max(0f, edgeOffset), fullLength / 2f);
-                    settings.batteryBarCurvedGeometryMode)
+            float usableStart = pathOffset;
-                    ? fullLength * fraction
+            float usableEnd = fullLength - pathOffset;
-                    : targetDistanceForHorizontalFraction(
+            float usableLength = usableEnd - usableStart;
-                            leftCenter,
+            if (usableLength <= 0f) {
-                            rightCenter,
+                return;
-                            fullLength,
+            }
-                            fraction);
+            float targetLength = usableLength * fraction;
             if (targetLength <= 0f) {
                 return;
             }
-            targetLength = Math.min(fullLength, targetLength);
+            targetLength = Math.min(usableLength, targetLength);
-            float start = 0f;
+            float start = usableStart;
-            float end = targetLength;
+            float end = usableStart + targetLength;
             if ("rtl".equals(alignment)) {
-                start = fullLength - targetLength;
+                start = usableEnd - targetLength;
-                end = fullLength;
+                end = usableEnd;
             } else if ("center".equals(alignment)) {
-                float center = fullLength / 2f;
+                float center = (usableStart + usableEnd) / 2f;
-                start = Math.max(0f, center - targetLength / 2f);
+                start = Math.max(usableStart, center - targetLength / 2f);
-                end = Math.min(fullLength, center + targetLength / 2f);
+                end = Math.min(usableEnd, center + targetLength / 2f);
             }
             if (end <= start) {
                 return;
@@ -1089,64 +1200,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);
+            float outerRadius = Math.min(
-            fullCurvePath.moveTo(left, bottomY);
+                    resolveTopCornerRadius(verticalSpan + halfStroke),
-            if (radius <= 0f) {
+                    width / 2f);
-                fullCurvePath.lineTo(right, topY);
+            float curveRadius = outerRadius - halfStroke;
+            if (curveRadius <= 0f) {
+                buildSharpTopPath(width, topY, bottomY, halfStroke);
                 return;
             }
-            fullCurvePath.lineTo(left, topY + radius);
+            float leftTopX = outerRadius;
-            fullCurvePath.quadTo(left, topY, left + radius, topY);
+            float rightTopX = width - outerRadius;
-            fullCurvePath.lineTo(right - radius, topY);
+            if (rightTopX <= leftTopX) {
-            fullCurvePath.quadTo(right, topY, right, topY + radius);
+                buildSharpTopPath(width, topY, bottomY, halfStroke);
-            fullCurvePath.lineTo(right, bottomY);
+                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(
+        private float resolveTopCornerRadius(float fallback) {
-                float left,
+            WindowInsets insets = roundedCornerSource != null
-                float right,
+                    ? roundedCornerSource.getRootWindowInsets()
-                float fullLength,
+                    : null;
-                float fraction
+            if (insets == null) {
-        ) {
+                insets = getRootWindowInsets();
-            if (fraction >= 1f) {
-                return fullLength;
             }
-            float horizontalSpan = right - left;
+            if (insets == null) {
-            if (horizontalSpan <= 0f) {
+                return fallback;
-                return fullLength * fraction;
+            }
+            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;
+        private int roundedCornerRadius(WindowInsets insets, int position) {
-            float previousX = left;
+            RoundedCorner corner = insets.getRoundedCorner(position);
-            float accumulatedHorizontal = 0f;
+            if (corner == null) {
-            for (int step = 1; step <= steps; step++) {
+                return 0;
-                float distance = fullLength * step / steps;
-                if (!pathMeasure.getPosTan(distance, pathPoint, null)) {
-                    continue;
             }
-                float dx = Math.abs(pathPoint[0] - previousX);
+            return stableDensityRadius(Math.max(0, corner.getRadius()));
-                if (accumulatedHorizontal + dx >= targetHorizontal) {
-                    if (dx <= 0f) {
-                        return distance;
         }
-                    float ratio = (targetHorizontal - accumulatedHorizontal) / dx;
+
-                    return previousDistance + (distance - previousDistance) * ratio;
+        private int stableDensityRadius(int radius) {
+            if (radius <= 0 || getResources() == null) {
+                return radius;
             }
-                accumulatedHorizontal += dx;
+            DisplayMetrics metrics = getResources().getDisplayMetrics();
-                previousDistance = distance;
+            int currentDpi = metrics != null ? metrics.densityDpi : 0;
-                previousX = pathPoint[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 {
@@ -103,6 +104,10 @@ final class DrawerClockTextController {
         untrackDisabledRoles(clockEnabled, dateEnabled);
 
         SurfaceMode surfaceMode = scene != null ? scene.surfaceMode() : null;
+        if (!root.isLayoutRequested()
+                && hasAttachedCachedCandidates(root, clockEnabled, dateEnabled, surfaceMode)) {
+            return;
+        }
         if (hasValidTrackedCandidates(root, clockEnabled, dateEnabled, surfaceMode)) {
             return;
         }
@@ -199,11 +204,34 @@ final class DrawerClockTextController {
         return false;
     }
 
+    private boolean hasAttachedCachedCandidates(
+            View root,
+            boolean clockEnabled,
+            boolean dateEnabled,
+            SurfaceMode surfaceMode
+    ) {
+        CandidateCache cache = candidateCacheByRoot.get(root);
+        if (cache == null || cache.surfaceMode != surfaceMode) {
+            return false;
+        }
+        return (!clockEnabled || isAttachedCachedCandidate(cache.clockView, Role.CLOCK))
+                && (!dateEnabled || isAttachedCachedCandidate(cache.dateView, Role.DATE));
+    }
+
+    private boolean isAttachedCachedCandidate(WeakReference<TextView> reference, Role role) {
+        TextView textView = reference != null ? reference.get() : null;
+        return textView != null
+                && textView.isAttachedToWindow()
+                && trackedRoles.get(textView) == role
+                && ownedTexts.contains(textView);
+    }
+
     private void track(TextView textView, Role role) {
         if (textView == null || role == null) {
             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 +242,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 =
+    private static final String[] CLOCK_CLASS_NAMES = {
-            "com.android.systemui.statusbar.policy.QSClockIndicatorView";
+            "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() {
+    private void suspendOwnedClockTickers() {
-        for (TextView clockView : new ArrayList<>(trackedClocks)) {
+        for (TextView clockView : new ArrayList<>(ownedClocks)) {
-            removeRowOverlay(clockView);
+            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);
+        Class<?> containerClass = ReflectionSupport.findClassIfExists(CONTAINER_CLASS_NAME, classLoader);
-        XposedHookSupport.hookAllMethods(runtimeContext.getFramework(), containerClass, "onAttachedToWindow", chain -> {
+        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/InstanceStateStore.java

@@ -1,43 +0,0 @@
-package se.ajpanton.statusbartweak.runtime.hooks;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.WeakHashMap;
-
-/**
- * Replacement for legacy Xposed additional-instance-field helpers.
- */
-public final class InstanceStateStore {
-
-    private final WeakHashMap<Object, Map<String, Object>> state = new WeakHashMap<>();
-
-    public synchronized Object get(Object target, String key) {
-        if (target == null || key == null) {
-            return null;
-        }
-        Map<String, Object> fields = state.get(target);
-        return fields != null ? fields.get(key) : null;
-    }
-
-    public synchronized void put(Object target, String key, Object value) {
-        if (target == null || key == null) {
-            return;
-        }
-        Map<String, Object> fields = state.computeIfAbsent(target, ignored -> new HashMap<>());
-        fields.put(key, value);
-    }
-
-    public synchronized void remove(Object target, String key) {
-        if (target == null || key == null) {
-            return;
-        }
-        Map<String, Object> fields = state.get(target);
-        if (fields == null) {
-            return;
-        }
-        fields.remove(key);
-        if (fields.isEmpty()) {
-            state.remove(target);
-        }
-    }
-}

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

@@ -17,6 +17,7 @@ import se.ajpanton.statusbartweak.runtime.render.StatusBarTintTarget;
 final class DarkIconDispatcherGuard {
     private final RuntimeContext runtimeContext;
     private final BooleanSupplier lockscreenSceneSupplier;
+    private final BooleanSupplier lockscreenDarkIconsSupplier;
     private final Runnable refreshAllRoots;
     private final Set<Object> dispatchers =
             Collections.newSetFromMap(new WeakHashMap<>());
@@ -25,15 +26,17 @@ final class DarkIconDispatcherGuard {
     DarkIconDispatcherGuard(
             RuntimeContext runtimeContext,
             BooleanSupplier lockscreenSceneSupplier,
+            BooleanSupplier lockscreenDarkIconsSupplier,
             Runnable refreshAllRoots
     ) {
         this.runtimeContext = runtimeContext;
         this.lockscreenSceneSupplier = lockscreenSceneSupplier;
+        this.lockscreenDarkIconsSupplier = lockscreenDarkIconsSupplier;
         this.refreshAllRoots = refreshAllRoots;
     }
 
     void install(Class<?> darkIconDispatcherClass) {
-        XposedHookSupport.hookAllConstructors(
+        XposedHookSupport.hookAllConstructorsIfExists(
                 runtimeContext.getFramework(),
                 darkIconDispatcherClass,
                 chain -> {
@@ -48,7 +51,7 @@ final class DarkIconDispatcherGuard {
                 chain -> {
                     Object dispatcher = chain.getThisObject();
                     track(dispatcher);
-                    if (isLockscreenScene()) {
+                    if (isLockscreenScene() && !shouldUseDarkLockscreenIcons()) {
                         forceLightState(dispatcher);
                     }
                     Object result = chain.proceed();
@@ -63,7 +66,11 @@ final class DarkIconDispatcherGuard {
             return;
         }
         for (Object dispatcher : new ArrayList<>(dispatchers)) {
+            if (shouldUseDarkLockscreenIcons()) {
+                restoreState(dispatcher, forcedStates.remove(dispatcher));
+            } else {
                 forceLightState(dispatcher);
+            }
             ReflectionSupport.invokeMethod(dispatcher, "applyIconTint");
         }
     }
@@ -85,6 +92,10 @@ final class DarkIconDispatcherGuard {
         return lockscreenSceneSupplier.getAsBoolean();
     }
 
+    private boolean shouldUseDarkLockscreenIcons() {
+        return lockscreenDarkIconsSupplier.getAsBoolean();
+    }
+
     private void track(Object dispatcher) {
         if (dispatcher != null) {
             dispatchers.add(dispatcher);
@@ -92,6 +103,10 @@ final class DarkIconDispatcherGuard {
     }
 
     private void updateTintTarget(Object dispatcher) {
+        if (isLockscreenScene() && shouldUseDarkLockscreenIcons()) {
+            StatusBarTintTarget.setDarkIcons(true);
+            return;
+        }
         Object intensity = ReflectionSupport.getFieldValue(dispatcher, "mDarkIntensity");
         if (intensity instanceof Number number) {
             StatusBarTintTarget.setDarkIcons(number.floatValue() > 0.5f);

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) {
+    private Boolean firstBooleanArg(List<Object> args) {
-        return args != null && !args.isEmpty() && Boolean.TRUE.equals(args.get(0));
+        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() {
     }
@@ -483,4 +484,13 @@ final class LayoutPlan {
                 notificationPlacements,
                 carrierPlacement);
     }
+
+    LayoutPlan withCarrierPlacement(ClockPlacement placement) {
+        return new LayoutPlan(
+                clockPlacement,
+                chipPlacements,
+                statusPlacements,
+                notificationPlacements,
+                placement);
+    }
 }

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;
@@ -62,6 +65,7 @@ public final class UnlockedIconSnapshotRenderController {
             ViewGroup statusHost,
             ViewGroup notificationHost,
             SceneKey scene,
+            boolean statusBarTintTargetEnabled,
             boolean forceStockRefresh,
             TextView externalCarrierView
     ) {
@@ -71,8 +75,13 @@ 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());
+        setStatusBarTintTargetEnabled(statusBarTintTargetEnabled);
         layoutHostToRoot(root, clockHost);
         layoutHostToRoot(root, carrierHost);
         layoutHostToRoot(root, chipHost);
@@ -96,7 +105,7 @@ public final class UnlockedIconSnapshotRenderController {
                 root,
                 settings,
                 scene,
-                ViewGeometry.middleCutout(root),
+                EffectiveCutoutSupport.layoutMiddleCutout(root, settings),
                 anchors,
                 previousIcons);
         LayoutInputSignature previousSignature = lastLayoutSignatureByRoot.get(root);
@@ -154,12 +163,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 +202,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);
@@ -227,6 +236,7 @@ public final class UnlockedIconSnapshotRenderController {
         lastClockSourceGeometryByRoot.put(root, currentClockSourceGeometry);
         layoutPlan = withCurrentDotColors(layoutPlan, collectedIcons);
         layoutPlan = withCurrentClockAppearance(root, layoutPlan, collectedIcons, settings);
+        layoutPlan = withCurrentCarrierAppearance(layoutPlan);
         lastLayoutPlanByRoot.put(root, layoutPlan);
         if (clockEnabledForScene(settings, scene) && layoutPlan.clockPlacement != null) {
             clockRenderer.render(clockHost, layoutPlan.clockPlacement);
@@ -339,7 +349,8 @@ public final class UnlockedIconSnapshotRenderController {
     public boolean refreshUnlockedClockText(
             View root,
             ViewGroup clockHost,
-            SceneKey scene
+            SceneKey scene,
+            boolean statusBarTintTargetEnabled
     ) {
         if (root == null
                 || clockHost == null
@@ -353,7 +364,7 @@ public final class UnlockedIconSnapshotRenderController {
             return false;
         }
         SbtSettings settings = RuntimeSettingsCache.get(root.getContext());
-        setStatusBarTintTargetEnabled(scene.isUnlocked());
+        setStatusBarTintTargetEnabled(statusBarTintTargetEnabled);
         if (!clockEnabledForScene(settings, scene)) {
             return false;
         }
@@ -392,6 +403,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 +468,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;
     }
@@ -577,6 +598,24 @@ public final class UnlockedIconSnapshotRenderController {
         return plan.withClockPlacement(updatedClock);
     }
 
+    private LayoutPlan withCurrentCarrierAppearance(LayoutPlan plan) {
+        int targetColor = statusBarTintTargetColor();
+        if (plan == null
+                || plan.carrierPlacement == null
+                || !hasAlpha(targetColor)
+                || plan.carrierPlacement.textColorOverride == targetColor) {
+            return plan;
+        }
+        ClockPlacement previous = plan.carrierPlacement;
+        return plan.withCarrierPlacement(new ClockPlacement(
+                previous.source,
+                previous.contentDescription,
+                previous.rows,
+                previous.bounds,
+                targetColor,
+                previous.textSizePx));
+    }
+
     private int clockReferenceColor(ClockPlacement placement, CollectedIcons icons) {
         int targetColor = statusBarTintTargetColor();
         if (hasAlpha(targetColor)) {
@@ -724,7 +763,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)
+                ? aodCutoutBounds(root, layoutCutout, settings.layoutPaddingCutoutPx)
-                : cutoutBounds(cutout, settings.layoutPaddingCutoutPx);
+                : cutoutBounds(layoutCutout, settings.layoutPaddingCutoutPx);
         Bounds clockCutoutBounds = scene != null && scene.isAod()
-                ? aodCutoutBounds(root, cutout, settings.clockMiddleCutoutGapPx)
+                ? aodCutoutBounds(root, clockCutout, settings.clockMiddleCutoutGapPx)
-                : cutoutBounds(cutout, 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
+                    && SystemUiCapabilities.supportsExperimentalGenericAodStatusbarRoot(settings))) {
                 return 0;
             }
             return settings.layoutNotifEnabledAod ? settings.layoutNotifAodCount : 0;
@@ -1112,7 +1122,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 +1142,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 +1402,7 @@ final class UnlockedLayoutPlanner {
             View root,
             SbtSettings settings,
             RootAnchors anchors,
+            CollectedIcons collectedIcons,
             SceneKey scene,
             Bounds aodStatusAnchorBounds
     ) {
@@ -1407,11 +1429,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
+            if (isAodIconNotificationStyle(scene, settings)) {
-                    || scene.notificationDisplayStyle() == NotificationDisplayStyle.DOT) {
                 notificationIcons.addAll(
                         LockscreenCardsNotificationIconSourceStore.snapshotSourcesForAodIconsRoot(root));
                 if (notificationIcons.isEmpty()
@@ -87,6 +92,13 @@ final class UnlockedStockSourceCollector {
                             LockscreenCardsNotificationIconSourceStore
                                     .snapshotAodNotificationPackageSources(root));
                 }
+                if (notificationIcons.isEmpty()
+                        && SystemUiCapabilities.supportsExperimentalGenericAodStatusbarRoot(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 +118,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
+                && isAodIconNotificationStyle(scene, settings);
-                || scene.notificationDisplayStyle() == NotificationDisplayStyle.DOT);
         View excludedNotificationContainer = iconMode
                 ? LockscreenCardsNotificationIconSourceStore.sourceContainerForAodIconsRoot(root)
                 : LockscreenCardsNotificationIconSourceStore.sourceContainerForRoot(root);
@@ -124,6 +136,17 @@ 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 String reflectString(View view, String methodName, String... fieldNames) {
         Object methodValue = ReflectionSupport.invokeMethod(view, methodName);
         if (methodValue != null) {
@@ -185,9 +208,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 +256,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
+                && isAodIconNotificationStyle(scene, settings);
-                || scene.notificationDisplayStyle() == NotificationDisplayStyle.DOT);
         View notificationContainer = iconMode
                 ? LockscreenCardsNotificationIconSourceStore.sourceContainerForAodIconsRoot(root)
                 : LockscreenCardsNotificationIconSourceStore.sourceContainerForRoot(root);
@@ -283,7 +311,7 @@ final class UnlockedStockSourceCollector {
                     return;
                 }
                 if (isStatusChipMetricCandidate(root, source.view(), true)
-                        && hasVisibleStatusChipContent(source.view())) {
+                        && hasRenderableStatusChipContent(source.view())) {
                     metricOut.add(source);
                     return;
                 }
@@ -311,7 +339,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 +392,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 +914,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 +1216,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 +1239,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 +1254,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 +1267,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 +1330,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 +1345,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 +1544,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 +1564,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 +1688,7 @@ final class UnlockedStockSourceCollector {
                 settings.clockCustomFormatEnabled,
                 settings.clockCustomFormat,
                 settings.clockIgnoreUnderDisplayCameras,
+                settings.clockCameraTypeOverrides,
                 settings.layoutPaddingCutoutPx,
                 settings.layoutPaddingLeftPx,
                 settings.layoutPaddingRightPx,
@@ -1556,7 +1751,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,21 +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() {
-        return encode();
     }
 
     public static String enabledKey(Scenario scenario) {
@@ -104,6 +126,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());
+                setIntField(input, "rotation", info.rotation);
-            }
-            int width = root.getWidth();
-            if (width <= 0 && root.getRootView() != null) {
-                width = root.getRootView().getWidth();
             }
             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 se.ajpanton.statusbartweak.runtime.features.clock.ClockColorResolver;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public final class ColourExpressionSupport {
-    private static final Pattern OPERATION_PATTERN =
+    private static final ClockColorResolver RESOLVER = new ClockColorResolver();
-            Pattern.compile("([+\\-*/])\\s*(" + hexOperandPattern() + "|\\d+(?:\\.\\d+)?|\\.\\d+)");
+    private static final ClockColorResolver.Options OPTIONS = ClockColorResolver.Options.batteryBar();
-    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 ColourExpressionSupport() {
     }
 
     public static String normaliseExpression(String raw, boolean assumeHashPrefix) {
-        if (raw == null) {
+        String value = normaliseSeparators(raw);
-            return "";
-        }
-        String value = raw.trim();
         if (value.isEmpty()) {
             return "";
         }
-        int variantSplit = findVariantSplit(value);
+        try {
-        String left = value;
+            RESOLVER.resolveColor(null, value, Color.WHITE, Color.WHITE, OPTIONS);
-        String right = null;
+            RESOLVER.resolveColor(null, value, Color.BLACK, Color.WHITE, OPTIONS);
-        if (variantSplit >= 0) {
+            return value;
-            left = value.substring(0, variantSplit).trim();
+        } catch (IllegalArgumentException ignored) {
-            right = value.substring(variantSplit + 1).trim();
-        }
-        if (!isValidSegment(left, assumeHashPrefix, false, Color.WHITE)) {
             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) {
+            boolean assumeHashPrefix
-        String value = normaliseExpression(raw, assumeHashPrefix);
+    ) {
+        String value = normaliseSeparators(raw);
         if (value.isEmpty()) {
             return fallbackColor;
         }
-        int variantSplit = findVariantSplit(value);
+        try {
-        if (variantSplit < 0) {
+            return RESOLVER.resolveColor(null, value, referenceColor, fallbackColor, OPTIONS);
-            return resolveSegment(value, fallbackColor, assumeHashPrefix, false);
+        } 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) {
+            boolean assumeHashPrefix
-        int resolved = resolveColor(raw, referenceColor, fallbackColor, assumeHashPrefix);
+    ) {
-        int alpha = Color.alpha(resolved);
+        String value = normaliseSeparators(raw);
-        if (alpha >= 255) {
+        if (value.isEmpty()) {
-            return String.format(Locale.ROOT, "#%06X", resolved & 0xFFFFFF);
+            return hexFor(fallbackColor);
-        }
-        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;
         }
         try {
-            resolveSegment(segment, baseColor, assumeHashPrefix, allowInheritedBase);
+            return RESOLVER.resolveColorHex(null, value, referenceColor, fallbackColor, OPTIONS);
-            return true;
         } catch (IllegalArgumentException ignored) {
-            return false;
+            return hexFor(fallbackColor);
         }
     }
 
-    private static int resolveSegment(String segment,
+    private static String normaliseSeparators(String raw) {
-                                      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) {
         String value = raw != null ? raw.trim() : "";
         if (value.isEmpty()) {
-            throw new IllegalArgumentException("Empty colour");
+            return "";
         }
-        if (assumeHashPrefix && value.charAt(0) != '#') {
+        int split = findTopLevelPipe(value);
-            value = "#" + value;
+        if (split < 0) {
-        }
+            return 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);
         }
+        return value.substring(0, split).trim() + " ; " + value.substring(split + 1).trim();
     }
 
-    private static String expandShortHex(String hex) {
+    private static int findTopLevelPipe(String value) {
-        StringBuilder out = new StringBuilder(hex.length() * 2);
+        boolean inVector = false;
-        for (int i = 0; i < hex.length(); i++) {
+        int split = -1;
-            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;
         for (int i = 0; i < value.length(); i++) {
             char c = value.charAt(i);
-            if (c == '\'') {
+            if (inVector) {
-                quoted = !quoted;
+                if (c == ']') {
+                    inVector = false;
+                }
                 continue;
             }
-            if (!quoted && c == '|') {
+            if (c == '[') {
-                return i;
+                inVector = true;
-            }
+                continue;
             }
+            if (c == '|') {
+                if (split >= 0) {
                     return -1;
                 }
-
+                split = i;
-    private static boolean isDark(int color) {
+            }
-        double brightness = (Color.red(color) * 299d
+        }
-                + Color.green(color) * 587d
+        return split;
-                + Color.blue(color) * 114d) / 1000d;
-        return brightness < 128d;
     }
 
-    private static String hexOperandPattern() {
+    private static String hexFor(int color) {
-        return "#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{4}|[0-9a-fA-F]{3})";
+        if (Color.alpha(color) >= 255) {
-    }
+            return String.format(java.util.Locale.ROOT, "#%06X", color & 0xFFFFFF);
-
-    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;
         }
+        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/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(
+                            SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT));
-                                    SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_UNLOCKED,
-                                    SbtDefaults.LAYOUT_NOTIF_ENABLED_UNLOCKED_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
             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(
+                            SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT));
-                                    SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_LOCKSCREEN,
-                                    SbtDefaults.LAYOUT_NOTIF_ENABLED_LOCKSCREEN_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
             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(
+                            SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT));
-                                    SbtSettings.KEY_LAYOUT_NOTIF_ENABLED_AOD,
-                                    SbtDefaults.LAYOUT_NOTIF_ENABLED_AOD_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
             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(
+                            SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT));
-                                    SbtSettings.KEY_LAYOUT_STATUS_ENABLED_UNLOCKED,
-                                    SbtDefaults.LAYOUT_STATUS_ENABLED_UNLOCKED_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
             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(
+                            SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT));
-                                    SbtSettings.KEY_LAYOUT_STATUS_ENABLED_LOCKSCREEN,
-                                    SbtDefaults.LAYOUT_STATUS_ENABLED_LOCKSCREEN_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
             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(
+                            SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT));
-                                    SbtSettings.KEY_LAYOUT_STATUS_ENABLED_AOD,
-                                    SbtDefaults.LAYOUT_STATUS_ENABLED_AOD_DEFAULT)
-                                    ? SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT
-                                    : 0));
             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);
+        previewBindings.clear();
-        customFormatInput.setText(customFormatValue);
+        storedPatternBindings.clear();
-        updateCustomFormatVisibility(customFormatContainer, customFormatEnabledValue);
+        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;
 
@@ -39,7 +40,7 @@ public final class LayoutFragment extends Fragment {
         View root = inflater.inflate(R.layout.fragment_layout, container, false);
         SharedPreferences prefs = requireContext()
                 .getSharedPreferences(SbtSettings.PREFS_NAME, Context.MODE_PRIVATE);
-        hideUnlockedSubpageObsoleteControls(root);
+        configureUnlockedOnlyModeControls(root);
         reorderItemCards(root, prefs);
 
         setupPositionSection(root,
@@ -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);
-                    countDefault,
-                    legacyEnabledDefault);
             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) {
@@ -516,7 +508,7 @@ public final class LayoutFragment extends Fragment {
         }
     }
 
-    private void hideUnlockedSubpageObsoleteControls(View root) {
+    private void configureUnlockedOnlyModeControls(View root) {
         hide(root, R.id.clock_position_mode_lockscreen);
         hide(root, R.id.notif_position_mode_aod);
         hide(root, R.id.notif_position_mode_lockscreen);
@@ -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);
-                    1,
-                    legacyEnabledDefault);
             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 NavigationView drawerNavigationView;
-    private Integer navigationBasePaddingLeft;
+    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);
+        drawerNavigationView = findViewById(R.id.nav_view_drawer);
-        navigationView.setNavigationItemSelectedListener(this);
+        permanentNavigationView = findViewById(R.id.nav_view_permanent);
-        navigationView.getMenu().setGroupCheckable(0, true, true);
+        setupNavigationView(drawerNavigationView);
+        setupNavigationView(permanentNavigationView);
         applyNavigationDrawerInsets();
-
+        drawerToggle = new ActionBarDrawerToggle(
-        ActionBarDrawerToggle toggle = new ActionBarDrawerToggle(
                 this,
                 drawerLayout,
                 toolbar,
                 R.string.nav_open,
                 R.string.nav_close
         );
-        drawerLayout.addDrawerListener(toggle);
+        drawerLayout.addDrawerListener(drawerToggle);
-        toggle.syncState();
+        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) {
+        drawerNavigationBasePaddingLeft = applyNavigationLeftPadding(
-            navigationBasePaddingLeft = navigationView.getPaddingLeft();
+                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
-            int defaultCount,
-            boolean legacyEnabledDefault
     ) {
-        int fallback = prefs.getBoolean(legacyEnabledKey, legacyEnabledDefault) ? defaultCount : 0;
+        return SbtSettings.clampIconContainerCount(prefs.getInt(countKey, defaultCount));
-        return SbtSettings.clampIconContainerCount(prefs.getInt(countKey, fallback));
     }
 
     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:id="@+id/nav_view_drawer"
-        android:layout_width="wrap_content"
+        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,151 +98,15 @@
                             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:textAppearance="?attr/textAppearanceBody2" />
-                        android:textAllCaps="true"
-                        android:letterSpacing="0.03"
-                        android:textStyle="bold" />
 
                         <LinearLayout
                             android:id="@+id/battery_bar_alignment_row"
                             android:layout_width="match_parent"
                             android:layout_height="wrap_content"
                             android:layout_marginTop="8dp"
+                            android:baselineAligned="false"
                             android:orientation="horizontal">
 
                             <LinearLayout
@@ -333,48 +193,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"
+                            android:text="@string/battery_bar_thickness_title"
-                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:textAppearance="?attr/textAppearanceBody2" />
 
                         <LinearLayout
-                        android:id="@+id/battery_bar_scenario_overrides_container"
+                            android:layout_width="wrap_content"
-                        android:layout_width="match_parent"
                             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 +482,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
+                    <se.ajpanton.statusbartweak.shell.ui.ClockPatternPreviewView
-                        android:id="@+id/clock_custom_format_input"
+                        android:id="@+id/clock_custom_format_preview"
-                        android:layout_width="match_parent"
+                        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:minWidth="120dp"
-                        android:minLines="2"
+                        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
+                    <se.ajpanton.statusbartweak.shell.ui.ClockPatternPreviewView
-                        android:id="@+id/drawer_clock_custom_format_input"
+                        android:id="@+id/drawer_clock_custom_format_preview"
-                        android:layout_width="match_parent"
+                        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:minWidth="120dp"
-                        android:minLines="2"
+                        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
+                    <se.ajpanton.statusbartweak.shell.ui.ClockPatternPreviewView
-                        android:id="@+id/drawer_date_custom_format_input"
+                        android:id="@+id/drawer_date_custom_format_preview"
-                        android:layout_width="match_parent"
+                        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:minWidth="120dp"
-                        android:minLines="2"
+                        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/layout/item_hidden_app.xml

@@ -3,6 +3,7 @@
     android:id="@+id/hidden_item_root"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
+    android:baselineAligned="false"
     android:foreground="?attr/selectableItemBackground"
     android:gravity="center_vertical"
     android:minHeight="56dp"

app/src/main/res/values-night/colors.xml

@@ -8,7 +8,6 @@
     <color name="sbt_background_top">#FF110B07</color>
     <color name="sbt_background_bottom">#FF1B0F08</color>
     <color name="sbt_surface">#FF20140D</color>
-    <color name="sbt_surface_variant">#FF302012</color>
     <color name="sbt_on_primary">#FFFFFFFF</color>
     <color name="sbt_on_surface">#FFEAF0F3</color>
     <color name="sbt_on_surface_variant">#FFE3D3B6</color>

app/src/main/res/values-night/themes.xml

@@ -1,23 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <style name="Theme.StatusBarTweak" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <item name="colorPrimary">@color/sbt_primary</item>
-        <item name="colorPrimaryVariant">@color/sbt_primary_dark</item>
-        <item name="colorOnPrimary">@color/sbt_on_primary</item>
-        <item name="colorSecondary">@color/sbt_accent</item>
-        <item name="colorSecondaryVariant">@color/sbt_accent_dark</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <item name="colorSurface">@color/sbt_surface</item>
-        <item name="colorOnSurface">@color/sbt_on_surface</item>
-        <item name="android:colorAccent">@color/sbt_accent</item>
-        <item name="android:fontFamily">sans-serif</item>
-        <item name="android:windowBackground">@drawable/sbt_window_background</item>
-        <item name="android:navigationBarColor">@color/sbt_primary_dark</item>
-        <item name="android:statusBarColor">@color/sbt_primary_dark</item>
-        <item name="android:windowLightStatusBar">false</item>
-        <item name="materialCardViewStyle">@style/Widget.StatusBarTweak.Card</item>
-        <item name="materialButtonOutlinedStyle">@style/Widget.StatusBarTweak.OutlinedButton</item>
-        <item name="materialAlertDialogTheme">@style/ThemeOverlay.StatusBarTweak.MaterialAlertDialog</item>
-        <item name="sliderStyle">@style/Widget.StatusBarTweak.Slider</item>
-        <item name="switchStyle">@style/Widget.StatusBarTweak.Switch</item>
-    </style>
-</resources>

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

@@ -8,12 +8,10 @@
     <color name="sbt_background_top">#FFFFF4E8</color>
     <color name="sbt_background_bottom">#FFF5E5D2</color>
     <color name="sbt_surface">#FFFFFFFF</color>
-    <color name="sbt_surface_variant">#FFFFF1E0</color>
     <color name="sbt_on_primary">#FFFFFFFF</color>
     <color name="sbt_on_surface">#FF111820</color>
     <color name="sbt_on_surface_variant">#FF62553F</color>
     <color name="black">#FF000000</color>
-    <color name="white">#FFFFFFFF</color>
     <color name="sbt_card_outline">#24000000</color>
     <color name="sbt_panel_outline">#4D000000</color>
     <color name="sbt_hidden_item_active_bg">#1AE65100</color>

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

@@ -14,7 +14,6 @@
     <string name="nav_layout_lockscreen">&#160;&#160;&#160;&#160;Lockscreen</string>
     <string name="nav_layout_aod">&#160;&#160;&#160;&#160;AOD</string>
     <string name="nav_battery_bar">Battery bar</string>
-    <string name="nav_block_app_notification_icons">Hide notification icons</string>
     <string name="nav_status_chips">Status chips</string>
     <string name="nav_misc">Misc</string>
     <string name="debug_title">Debugging</string>
@@ -30,6 +29,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,13 +44,12 @@
     <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>
     <string name="debug_camera_other_item">%1$s  •  %2$s</string>
     <string name="debug_camera_unknown">unknown</string>
-    <string name="notification_icons_title">Notification icons</string>
     <string name="system_icons_title">Hide status icons</string>
     <string name="system_icons_hint">Status-icon rules for the custom layout engine.</string>
     <string name="system_icons_hide_hint">Icons represent, in order:\nAOD, Lockscreen, Unlocked.</string>
@@ -71,43 +70,27 @@
     <string name="system_icon_bluetooth">Bluetooth</string>
     <string name="system_icon_data_saver">Data saver</string>
     <string name="system_icon_do_not_disturb">Do not disturb</string>
-    <string name="system_icon_enhanced_processing">Enhanced processing</string>
-    <string name="system_icon_home_carrier">Homescreen carrier</string>
     <string name="system_icon_hotspot">Mobile hotspot</string>
-    <string name="system_icon_ims">IMS network icons</string>
     <string name="system_icon_location">Location</string>
-    <string name="system_icon_lock_carrier">Lockscreen carrier</string>
-    <string name="system_icon_lockscreen_mum">Two phone user icon</string>
-    <string name="system_icon_managed_profile">Managed profile</string>
     <string name="system_icon_mobile">Mobile data signal</string>
-    <string name="system_icon_modes">Modes</string>
     <string name="system_icon_nfc">NFC</string>
-    <string name="system_icon_panel_carrier">Expanded panel carrier</string>
-    <string name="system_icon_power_saver">Power saver</string>
-    <string name="system_icon_rcs">RCS</string>
-    <string name="system_icon_two_phone_mode">Two phone mode icon</string>
     <string name="system_icon_volume">Volume</string>
     <string name="system_icon_vpn">VPN</string>
     <string name="system_icon_wifi">Wi-Fi</string>
     <string name="section_unlocked">Unlocked</string>
-    <string name="section_icons_mode">Icons mode</string>
-    <string name="section_cards_mode">Cards mode</string>
     <string name="section_aod">AOD</string>
     <string name="section_lockscreen">Lockscreen</string>
     <string name="label_max_icons_per_row">Max icons per row</string>
     <string name="label_max_rows">Max rows</string>
     <string name="label_even_distribution">Even distribution</string>
     <string name="label_limit_screen_width">Limit to screen width</string>
-    <string name="label_cutout_aware">Cutout aware</string>
     <string name="label_aod_keep_visible_during_call">Keep AOD visible during calls</string>
     <string name="label_aod_keep_visible_during_call_hint">Prevents SystemUI from suppressing AOD while an active call is in progress.</string>
-    <string name="hidden_apps_dialog_title">Notification icon app blocks</string>
     <string name="hidden_apps_page_title">Hide notification icons</string>
     <string name="hidden_apps_dialog_subtitle">Pull down to refresh session apps. List contents are fixed until refresh.</string>
     <string name="hidden_apps_page_hint">Icons represent, in order:\nAOD, Lockscreen, Unlocked</string>
     <string name="hidden_apps_clear_session">Clear session list</string>
     <string name="hidden_apps_empty">No apps yet. Generate a notification first.</string>
-    <string name="hidden_apps_close">Close</string>
     <string name="hidden_apps_exception_regex_input_hint">Regex</string>
     <plurals name="hidden_apps_package_with_exceptions">
         <item quantity="one">%1$s  \u2022  %2$d exception</item>
@@ -125,38 +108,27 @@
     <string name="hidden_apps_mode_unlock">Unlocked</string>
     <string name="hidden_apps_package_unknown">(unknown package)</string>
     <string name="status_chips_title">Status chips</string>
-    <string name="status_chips_hint">Hide Samsung/SystemUI status chips (music, maps/navigation, call) in the top status area.</string>
     <string name="status_chips_hide_all_label">Hide other status chips (unlocked)</string>
     <string name="status_chips_hide_all_hint">Hides detected status chips that are not media, navigation or call. Privacy indicators are excluded.</string>
     <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>
-    <string name="battery_bar_alignment_rtl">&#8592;</string>
-    <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_length">Follow screen edges</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_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,21 +136,23 @@
     <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, FA0, or #FA0 ; invRGB 0.5 *RGB</string>
-    <string name="battery_bar_colour_dialog_hint">Examples: FA0, 80FA, or FFAA00</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>
     <string name="battery_bar_threshold_label">Below %1$d%%</string>
     <string name="battery_bar_threshold_discharge_colour">Discharge colour</string>
     <string name="battery_bar_threshold_charge_colour">Charge colour</string>
-    <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>
@@ -186,9 +160,7 @@
     <string name="layout_home_title">Layout</string>
     <string name="layout_title">Unlocked</string>
     <string name="layout_master_toggle_title">Master toggle</string>
-    <string name="clock_enabled">Use custom clock</string>
     <string name="layout_enabled">Use custom layout</string>
-    <string name="clock_position_title">Clock position</string>
     <string name="layout_clock_position_title">Clock</string>
     <string name="layout_carrier_position_title">Carrier</string>
     <string name="layout_chip_position_title">Status chip</string>
@@ -202,6 +174,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>
@@ -234,7 +207,6 @@
     <string name="clock_vertical_offset_label">Vertical position</string>
     <string name="clock_middle_side_left">Left side</string>
     <string name="clock_middle_side_right">Right side</string>
-    <string name="clock_custom_format_title">Custom format</string>
     <string name="clock_custom_format_statusbar_title">Statusbar clock</string>
     <string name="clock_custom_format_drawer_clock_title">Drawer clock</string>
     <string name="clock_custom_format_drawer_date_title">Drawer date</string>
@@ -242,18 +214,21 @@
     <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>
-    <string name="clock_custom_format_invalid">Invalid pattern</string>
     <string name="label_battery_lockscreen_unplugged_percent">Unplugged battery % on lockscreen</string>
     <string name="label_battery_lockscreen_unplugged_percent_hint">Shows the plain battery percentage on the lockscreen when unplugged.</string>
     <string name="label_battery_aod_unplugged_percent">Unplugged battery % on AOD</string>

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

@@ -1,26 +1,4 @@
 <resources xmlns:tools="http://schemas.android.com/tools">
-    <style name="Theme.StatusBarTweak" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <item name="colorPrimary">@color/sbt_primary</item>
-        <item name="colorPrimaryVariant">@color/sbt_primary_dark</item>
-        <item name="colorOnPrimary">@color/sbt_on_primary</item>
-        <item name="colorSecondary">@color/sbt_accent</item>
-        <item name="colorSecondaryVariant">@color/sbt_accent_dark</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <item name="colorSurface">@color/sbt_surface</item>
-        <item name="colorOnSurface">@color/sbt_on_surface</item>
-        <item name="android:colorAccent">@color/sbt_accent</item>
-        <item name="android:fontFamily">sans-serif</item>
-        <item name="android:windowBackground">@drawable/sbt_window_background</item>
-        <item name="android:navigationBarColor">@color/sbt_primary_dark</item>
-        <item name="android:statusBarColor">@color/sbt_primary_dark</item>
-        <item name="android:windowLightStatusBar">false</item>
-        <item name="materialCardViewStyle">@style/Widget.StatusBarTweak.Card</item>
-        <item name="materialButtonOutlinedStyle">@style/Widget.StatusBarTweak.OutlinedButton</item>
-        <item name="materialAlertDialogTheme">@style/ThemeOverlay.StatusBarTweak.MaterialAlertDialog</item>
-        <item name="sliderStyle">@style/Widget.StatusBarTweak.Slider</item>
-        <item name="switchStyle">@style/Widget.StatusBarTweak.Switch</item>
-    </style>
-
     <style name="Theme.StatusBarTweak.NoActionBar" parent="Theme.MaterialComponents.DayNight.NoActionBar">
         <item name="colorPrimary">@color/sbt_primary</item>
         <item name="colorPrimaryVariant">@color/sbt_primary_dark</item>

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);
+    }
+}

app/src/test/java/se/ajpanton/statusbartweak/shell/settings/SbtSettingsTest.java

@@ -0,0 +1,115 @@
+package se.ajpanton.statusbartweak.shell.settings;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public final class SbtSettingsTest {
+    @Test
+    public void emptySourceMatchesRepresentativeDefaults() {
+        SbtSettings defaults = SbtSettings.defaults();
+        SbtSettings decoded = SbtSettings.fromSource(new MapSource());
+
+        assertEquals(SbtDefaults.CLOCK_ENABLED_DEFAULT, defaults.clockEnabled);
+        assertEquals(SbtDefaults.CLOCK_CUSTOM_FORMAT_DEFAULT, defaults.clockCustomFormat);
+        assertEquals(SbtDefaults.BATTERY_BAR_POSITION_DEFAULT, defaults.batteryBarPosition);
+        assertEquals(SbtDefaults.BATTERY_BAR_THICKNESS_DP_DEFAULT, defaults.batteryBarThicknessDp);
+        assertEquals(
+                SbtDefaults.LAYOUT_NOTIF_UNLOCKED_COUNT_DEFAULT,
+                defaults.layoutNotifUnlockedCount);
+        assertEquals(
+                SbtDefaults.LAYOUT_STATUS_UNLOCKED_COUNT_DEFAULT,
+                defaults.layoutStatusUnlockedCount);
+        assertEquals(defaults.clockEnabled, decoded.clockEnabled);
+        assertEquals(defaults.clockCustomFormat, decoded.clockCustomFormat);
+        assertEquals(defaults.batteryBarPosition, decoded.batteryBarPosition);
+        assertEquals(defaults.batteryBarThicknessDp, decoded.batteryBarThicknessDp);
+        assertEquals(defaults.layoutNotifUnlockedCount, decoded.layoutNotifUnlockedCount);
+        assertEquals(defaults.layoutStatusUnlockedCount, decoded.layoutStatusUnlockedCount);
+        assertEquals(defaults.systemIconBlockedModes, decoded.systemIconBlockedModes);
+    }
+
+    @Test
+    public void sourceDecodingPreservesSettingsNormalization() {
+        MapSource source = new MapSource();
+        source.put(SbtSettings.KEY_CLOCK_ENABLED, false);
+        source.put(SbtSettings.KEY_CLOCK_CUSTOM_FORMAT, "H:mm:ss");
+        source.put(SbtSettings.KEY_UNLOCKED_MAX_ICONS_PER_ROW, 0);
+        source.put(SbtSettings.KEY_CLOCK_VERTICAL_OFFSET_PX, 500);
+        source.put(SbtSettings.KEY_BATTERY_BAR_CURVED_GEOMETRY_MODE, "unsupported");
+        source.put(SbtSettings.KEY_LAYOUT_NOTIF_UNLOCKED_COUNT, 100);
+        source.put(SbtSettings.KEY_SYSTEM_ICON_DUAL_SIM_SIGNAL_MODE, "unsupported");
+        source.put(
+                SystemIconRules.PREF_KEY_BLOCKED_MODES,
+                setOf("wifi|5", "invalid", "wifi|not-a-number"));
+        source.put(
+                SbtSettings.KEY_APP_ICON_BLOCKED_MODES,
+                setOf("app.example|1|0|1", "bad-entry"));
+
+        SbtSettings decoded = SbtSettings.fromSource(source);
+
+        assertFalse(decoded.clockEnabled);
+        assertEquals("H:mm:ss", decoded.clockCustomFormat);
+        assertEquals(SbtDefaults.UNLOCKED_MAX_ICONS_PER_ROW_MIN, decoded.unlockedMaxIconsPerRow);
+        assertEquals(500, decoded.clockVerticalOffsetPx);
+        assertEquals(SbtSettings.BATTERY_BAR_CURVED_GEOMETRY_OFF, decoded.batteryBarCurvedGeometryMode);
+        assertEquals(SbtDefaults.LAYOUT_ICON_CONTAINER_COUNT_MAX, decoded.layoutNotifUnlockedCount);
+        assertEquals(
+                SbtDefaults.SYSTEM_ICON_DUAL_SIM_SIGNAL_MODE_DEFAULT,
+                decoded.systemIconDualSimSignalMode);
+        assertEquals(Integer.valueOf(5), decoded.systemIconBlockedModes.get("wifi"));
+        assertEquals(Integer.valueOf(AppIconRules.MODE_AOD | AppIconRules.MODE_UNLOCK),
+                decoded.appIconBlockedModes.get("app.example"));
+    }
+
+    private static Set<String> setOf(String... values) {
+        HashSet<String> result = new HashSet<>();
+        Collections.addAll(result, values);
+        return result;
+    }
+
+    private static final class MapSource implements SbtSettings.SettingsSource {
+        private final Map<String, Object> values = new HashMap<>();
+
+        void put(String key, Object value) {
+            values.put(key, value);
+        }
+
+        @Override
+        public boolean getBoolean(String key, boolean defaultValue) {
+            Object value = values.get(key);
+            return value instanceof Boolean ? (Boolean) value : defaultValue;
+        }
+
+        @Override
+        public int getInt(String key, int defaultValue) {
+            Object value = values.get(key);
+            return value instanceof Integer ? (Integer) value : defaultValue;
+        }
+
+        @Override
+        public String getString(String key, String defaultValue) {
+            Object value = values.get(key);
+            return value instanceof String ? (String) value : defaultValue;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public Set<String> getStringSet(String key) {
+            Object value = values.get(key);
+            return value instanceof Set ? (Set<String>) value : Collections.emptySet();
+        }
+
+        @Override
+        public boolean contains(String key) {
+            return values.containsKey(key);
+        }
+    }
+}

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,140 @@
+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() {
+        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,367 @@
+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);
+        startForegroundService(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) {
+        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,479 @@
+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 {
+            int flags = getWindow().getDecorView().getSystemUiVisibility();
+            if (lightBars) {
+                flags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
+                flags |= View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
+            } else {
+                flags &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
+                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.7