009: Closure wave 3 deblob, handoff, and optional wave4/malloc bacons.

Ship script gates wave 4 behind AXP_DEBLOB_WAVE4, documents secrets cert path,
and adds deblob appliers plus tests; docs capture Swissquote fix and parity.

Co-authored-by: Cursor <cursoragent@cursor.com>

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/frameworks_base/0014-Automatic_Reboot.patch

@@ -0,0 +1,153 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: anupritaisno1 <www.anuprita804@gmail.com>
+Date: Mon, 18 Oct 2021 01:35:40 +0300
+Subject: [PATCH] automatically reboot device after timeout if set
+
+Signed-off-by: anupritaisno1 <www.anuprita804@gmail.com>
+Change-Id: If891bfbcc144c9336ba013260bad2b7c7a59c054
+---
+ core/java/android/provider/Settings.java      |  7 ++++
+ data/etc/com.android.systemui.xml             |  1 +
+ packages/SystemUI/AndroidManifest.xml         |  3 ++
+ .../keyguard/KeyguardViewMediator.java        | 35 +++++++++++++++++++
+ 4 files changed, 46 insertions(+)
+
+diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
+index 783483d8e491..48913891ac52 100644
+--- a/core/java/android/provider/Settings.java
++++ b/core/java/android/provider/Settings.java
+@@ -19027,6 +19027,13 @@ public final class Settings {
+         public static final String REVIEW_PERMISSIONS_NOTIFICATION_STATE =
+                 "review_permissions_notification_state";
+ 
++        /**
++         * Whether to automatically reboot the device after a user defined timeout
++         *
++         * @hide
++         */
++        public static final String SETTINGS_REBOOT_AFTER_TIMEOUT = "settings_reboot_after_timeout";
++
+         /**
+          * Whether repair mode is active on the device.
+          * <p>
+diff --git a/data/etc/com.android.systemui.xml b/data/etc/com.android.systemui.xml
+index ce2543a47cf5..67108d16e099 100644
+--- a/data/etc/com.android.systemui.xml
++++ b/data/etc/com.android.systemui.xml
+@@ -54,6 +54,7 @@
+         <permission name="android.permission.READ_PRECISE_PHONE_STATE"/>
+         <permission name="android.permission.READ_WALLPAPER_INTERNAL"/>
+         <permission name="android.permission.REAL_GET_TASKS"/>
++        <permission name="android.permission.REBOOT"/>
+         <permission name="android.permission.REQUEST_NETWORK_SCORES"/>
+         <permission name="android.permission.RECEIVE_MEDIA_RESOURCE_USAGE"/>
+         <permission name="android.permission.SATELLITE_COMMUNICATION"/>
+diff --git a/packages/SystemUI/AndroidManifest.xml b/packages/SystemUI/AndroidManifest.xml
+index 351cce0929b7..00604a316019 100644
+--- a/packages/SystemUI/AndroidManifest.xml
++++ b/packages/SystemUI/AndroidManifest.xml
+@@ -356,6 +356,9 @@
+ 
+     <uses-permission android:name="android.permission.SET_UNRESTRICTED_KEEP_CLEAR_AREAS" />
+ 
++    <!-- Permission to allow rebooting the device after a user configurable amount of time -->
++    <uses-permission android:name="android.permission.REBOOT" />
++
+     <uses-permission android:name="android.permission.MONITOR_KEYBOARD_BACKLIGHT" />
+ 
+     <uses-permission android:name="android.permission.MONITOR_STICKY_MODIFIER_STATE" />
+diff --git a/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java b/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java
+index 6034e92be873..67dd84e8ae8f 100644
+--- a/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java
++++ b/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java
+@@ -240,6 +240,8 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+ 
+     private final static String TAG = "KeyguardViewMediator";
+ 
++    private static final String DELAYED_REBOOT_ACTION =
++        "com.android.internal.policy.impl.PhoneWindowManager.DELAYED_REBOOT";
+     public static final String DELAYED_KEYGUARD_ACTION =
+         "com.android.internal.policy.impl.PhoneWindowManager.DELAYED_KEYGUARD";
+     private static final String DELAYED_LOCK_PROFILE_ACTION =
+@@ -417,6 +419,11 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+      */
+     private int mDelayedProfileShowingSequence;
+ 
++    /**
++     * Same as {@link #mDelayedProfileShowingSequence}, but used for our reboot implementation
++     */
++    private int mDelayedRebootSequence;
++
+     private final DismissCallbackRegistry mDismissCallbackRegistry;
+ 
+     // the properties of the keyguard
+@@ -1503,6 +1510,7 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+         final IntentFilter delayedActionFilter = new IntentFilter();
+         delayedActionFilter.addAction(DELAYED_KEYGUARD_ACTION);
+         delayedActionFilter.addAction(DELAYED_LOCK_PROFILE_ACTION);
++        delayedActionFilter.addAction(DELAYED_REBOOT_ACTION);
+         delayedActionFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
+         mContext.registerReceiver(mDelayedLockBroadcastReceiver, delayedActionFilter,
+                 SYSTEMUI_PERMISSION, null /* scheduler */,
+@@ -1866,6 +1874,18 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+         }
+     }
+ 
++    private void doRebootForOwnerAfterTimeoutIfEnabled(long rebootAfterTimeout) {
++        long when = mSystemClock.elapsedRealtime() + rebootAfterTimeout;
++        Intent rebootIntent = new Intent(DELAYED_REBOOT_ACTION);
++        rebootIntent.putExtra("seq", mDelayedRebootSequence);
++        rebootIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
++        PendingIntent sender = PendingIntent.getBroadcast(mContext,
++                0, rebootIntent, PendingIntent.FLAG_CANCEL_CURRENT |  PendingIntent.FLAG_IMMUTABLE);
++        mAlarmManager.setExactAndAllowWhileIdle(AlarmManager.ELAPSED_REALTIME_WAKEUP, when, sender);
++        if (DEBUG) Log.d(TAG, "setting alarm to reboot device, timeout = "
++                         + String.valueOf(rebootAfterTimeout));
++    }
++
+     private void doKeyguardForChildProfilesLocked() {
+         for (UserInfo profile : mUserTracker.getUserProfiles()) {
+             if (!profile.isEnabled()) continue;
+@@ -1884,6 +1904,10 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+         mDelayedProfileShowingSequence++;
+     }
+ 
++    private void cancelDoRebootForOwnerAfterTimeoutIfEnabled() {
++        mDelayedRebootSequence++;
++    }
++
+     /**
+      * It will let us know when the device is waking up.
+      */
+@@ -2298,6 +2322,10 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+ 
+         if (DEBUG) Log.d(TAG, "doKeyguard: showing the lock screen");
+         showKeyguard(options);
++        final long rebootAfterTimeout = Settings.Global.getLong(mContext.getContentResolver(), Settings.Global.SETTINGS_REBOOT_AFTER_TIMEOUT, 0);
++        if (rebootAfterTimeout >= 1) {
++            doRebootForOwnerAfterTimeoutIfEnabled(rebootAfterTimeout);
++        }
+     }
+ 
+     @SuppressLint("MissingPermission")
+@@ -2478,6 +2506,12 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+                         }
+                     }
+                 }
++            } else if (DELAYED_REBOOT_ACTION.equals(intent.getAction())) {
++                final int sequence = intent.getIntExtra("seq", 0);
++                if (sequence == mDelayedRebootSequence) {
++                    PowerManager pm = mContext.getSystemService(PowerManager.class);
++                    pm.reboot(null);
++                }
+             }
+         }
+     };
+@@ -3200,6 +3234,7 @@ public class KeyguardViewMediator implements CoreStartable, Dumpable,
+         mHideAnimationRun = false;
+         adjustStatusBarLocked();
+         sendUserPresentBroadcast();
++        cancelDoRebootForOwnerAfterTimeoutIfEnabled();
+     }
+ 
+     private Configuration.Builder createInteractionJankMonitorConf(int cuj) {

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/frameworks_base/0015-Bluetooth_Timeout-Fix.patch

@@ -0,0 +1,62 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dmitry Muhomor <muhomor.dmitry@gmail.com>
+Date: Tue, 6 Sep 2022 16:48:26 +0300
+Subject: [PATCH] bugfix: Bluetooth auto turn off ignored connected BLE devices
+
+Previous attempt at fixing this didn't work properly, because getConnectionStateLeAware() didn't
+actually report BLE state.
+---
+ .../android/server/ext/BluetoothAutoOff.java  | 20 ++++++++++++++-----
+ 1 file changed, 15 insertions(+), 5 deletions(-)
+
+diff --git a/services/core/java/com/android/server/ext/BluetoothAutoOff.java b/services/core/java/com/android/server/ext/BluetoothAutoOff.java
+index 4e7dbc042f37..a091b006214f 100644
+--- a/services/core/java/com/android/server/ext/BluetoothAutoOff.java
++++ b/services/core/java/com/android/server/ext/BluetoothAutoOff.java
+@@ -3,6 +3,7 @@ package com.android.server.ext;
+ import android.annotation.Nullable;
+ import android.bluetooth.BluetoothAdapter;
+ import android.bluetooth.BluetoothManager;
++import android.bluetooth.BluetoothProfile;
+ import android.content.BroadcastReceiver;
+ import android.content.Context;
+ import android.content.Intent;
+@@ -12,12 +13,14 @@ import android.provider.Settings;
+ import android.util.Slog;
+ 
+ class BluetoothAutoOff extends DelayedConditionalAction {
++    private final BluetoothManager manager;
+     @Nullable
+     private final BluetoothAdapter adapter;
+ 
+     BluetoothAutoOff(SystemServerExt sse) {
+         super(sse, sse.bgHandler);
+-        adapter = sse.context.getSystemService(BluetoothManager.class).getAdapter();
++        manager = sse.context.getSystemService(BluetoothManager.class);
++        adapter = manager.getAdapter();
+     }
+ 
+     @Override
+@@ -51,11 +54,18 @@ class BluetoothAutoOff extends DelayedConditionalAction {
+ 
+     private boolean isAdapterOnAndDisconnected() {
+         if (adapter != null) {
+-            int state = adapter.getLeStateSysApi(); // getState() converts BLE states into STATE_OFF
++            if (adapter.isLeEnabled()) {
++                if (adapter.getConnectionState() == BluetoothAdapter.STATE_DISCONNECTED) {
++                    // Bluetooth GATT Profile (Bluetooth LE) connection state is ignored
++                    // by getConnectionState()
++                    return manager.getConnectedDevices(BluetoothProfile.GATT).size() == 0;
++                }
++            }
+ 
+-            if (state == BluetoothAdapter.STATE_ON || state == BluetoothAdapter.STATE_BLE_ON) {
+-                // getConnectionState() converts BLE states into STATE_DISCONNECTED
+-                return adapter.getConnectionStateLeAware() == BluetoothAdapter.STATE_DISCONNECTED;
++            // isLeEnabled() currently implies isEnabled(), but check again anyway in case
++            // this changes in the future
++            if (adapter.isEnabled()) {
++                return adapter.getConnectionState() == BluetoothAdapter.STATE_DISCONNECTED;
+             }
+         }
+ 

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/frameworks_base/0015-Bluetooth_Timeout.patch

@@ -0,0 +1,120 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dmitry Muhomor <muhomor.dmitry@gmail.com>
+Date: Sun, 31 Jul 2022 11:19:33 +0300
+Subject: [PATCH] Bluetooth auto turn off
+
+Co-authored-by: Pratyush <codelab@pratyush.dev>
+---
+ core/java/android/provider/Settings.java      |  6 ++
+ .../android/server/ext/BluetoothAutoOff.java  | 69 +++++++++++++++++++
+ .../android/server/ext/SystemServerExt.java   |  4 ++
+ 3 files changed, 79 insertions(+)
+ create mode 100644 services/core/java/com/android/server/ext/BluetoothAutoOff.java
+
+diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
+index 49f59950b9e0..58f1077af988 100644
+--- a/core/java/android/provider/Settings.java
++++ b/core/java/android/provider/Settings.java
+@@ -19549,6 +19549,12 @@ public final class Settings {
+          */
+         public static final String WIFI_OFF_TIMEOUT = "wifi_off_timeout";
+ 
++        /**
++         * The amount of time in milliseconds before a disconnected Bluetooth adapter is turned off
++         * @hide
++         */
++        public static final String BLUETOOTH_OFF_TIMEOUT = "bluetooth_off_timeout";
++
+         /**
+          * Whether repair mode is active on the device.
+          * <p>
+diff --git a/services/core/java/com/android/server/ext/BluetoothAutoOff.java b/services/core/java/com/android/server/ext/BluetoothAutoOff.java
+new file mode 100644
+index 000000000000..4e7dbc042f37
+--- /dev/null
++++ b/services/core/java/com/android/server/ext/BluetoothAutoOff.java
+@@ -0,0 +1,69 @@
++package com.android.server.ext;
++
++import android.annotation.Nullable;
++import android.bluetooth.BluetoothAdapter;
++import android.bluetooth.BluetoothManager;
++import android.content.BroadcastReceiver;
++import android.content.Context;
++import android.content.Intent;
++import android.content.IntentFilter;
++import android.os.Build;
++import android.provider.Settings;
++import android.util.Slog;
++
++class BluetoothAutoOff extends DelayedConditionalAction {
++    @Nullable
++    private final BluetoothAdapter adapter;
++
++    BluetoothAutoOff(SystemServerExt sse) {
++        super(sse, sse.bgHandler);
++        adapter = sse.context.getSystemService(BluetoothManager.class).getAdapter();
++    }
++
++    @Override
++    protected boolean shouldScheduleAlarm() {
++        return isAdapterOnAndDisconnected();
++    }
++
++    @Override
++    protected void alarmTriggered() {
++        if (isAdapterOnAndDisconnected()) {
++            adapter.disable();
++        }
++    }
++
++    @Override
++    protected void registerStateListener() {
++        IntentFilter f = new IntentFilter();
++        f.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
++        f.addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED);
++
++        sse.registerReceiver(new BroadcastReceiver() {
++            @Override
++            public void onReceive(Context broadcastContext, Intent intent) {
++                if (Build.isDebuggable()) {
++                    Slog.d("BtAutoOff", "" + intent + ", extras " + intent.getExtras().deepCopy());
++                }
++                update();
++            }
++        }, f, handler);
++    }
++
++    private boolean isAdapterOnAndDisconnected() {
++        if (adapter != null) {
++            int state = adapter.getLeStateSysApi(); // getState() converts BLE states into STATE_OFF
++
++            if (state == BluetoothAdapter.STATE_ON || state == BluetoothAdapter.STATE_BLE_ON) {
++                // getConnectionState() converts BLE states into STATE_DISCONNECTED
++                return adapter.getConnectionStateLeAware() == BluetoothAdapter.STATE_DISCONNECTED;
++            }
++        }
++
++        return false;
++    }
++
++    @Override
++    protected String getDelayGlobalSettingsKey() {
++        return Settings.Global.BLUETOOTH_OFF_TIMEOUT;
++    }
++}
+diff --git a/services/core/java/com/android/server/ext/SystemServerExt.java b/services/core/java/com/android/server/ext/SystemServerExt.java
+index 66350e2b7f74..3c341ed25f4e 100644
+--- a/services/core/java/com/android/server/ext/SystemServerExt.java
++++ b/services/core/java/com/android/server/ext/SystemServerExt.java
+@@ -53,6 +53,10 @@ public final class SystemServerExt {
+         if (packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI, 0)) {
+             new WifiAutoOff(this);
+         }
++
++        if (packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH, 0)) {
++            new BluetoothAutoOff(this);
++        }
+     }
+ 
+     public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter, Handler handler) {

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/frameworks_base/0015-System_Server_Extensions.patch

@@ -0,0 +1,231 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dmitry Muhomor <muhomor.dmitry@gmail.com>
+Date: Sun, 31 Jul 2022 10:06:14 +0300
+Subject: [PATCH] infrastructure for system_server extensions
+
+---
+ .../server/ext/DelayedConditionalAction.java  | 135 ++++++++++++++++++
+ .../android/server/ext/SystemServerExt.java   |  58 ++++++++
+ .../java/com/android/server/SystemServer.java |   2 +
+ 3 files changed, 195 insertions(+)
+ create mode 100644 services/core/java/com/android/server/ext/DelayedConditionalAction.java
+ create mode 100644 services/core/java/com/android/server/ext/SystemServerExt.java
+
+diff --git a/services/core/java/com/android/server/ext/DelayedConditionalAction.java b/services/core/java/com/android/server/ext/DelayedConditionalAction.java
+new file mode 100644
+index 000000000000..d72f302e9d42
+--- /dev/null
++++ b/services/core/java/com/android/server/ext/DelayedConditionalAction.java
+@@ -0,0 +1,135 @@
++/*
++ * Copyright (C) 2022 GrapheneOS
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package com.android.server.ext;
++
++import android.app.AlarmManager;
++import android.content.ContentResolver;
++import android.content.Context;
++import android.database.ContentObserver;
++import android.net.Uri;
++import android.os.Build;
++import android.os.Handler;
++import android.os.Looper;
++import android.os.SystemClock;
++import android.provider.Settings;
++import android.util.Slog;
++
++/**
++ * Infrastructure for actions that:
++ * - happen after a user-configurable device-wide (Settings.Global) delay
++ * - need to be taken even when the device is in deep sleep
++ * - need to be rescheduled based on some listenable event
++ */
++public abstract class DelayedConditionalAction {
++    private static final String TAG = "DelayedConditionalAction";
++
++    protected final SystemServerExt sse;
++    protected final Thread thread;
++    protected final Handler handler;
++
++    protected final ContentResolver contentResolver;
++    protected final AlarmManager alarmManager;
++    private final AlarmManager.OnAlarmListener alarmListener;
++
++    protected DelayedConditionalAction(SystemServerExt sse, Handler handler) {
++        this.sse = sse;
++
++        Looper looper = handler.getLooper();
++        thread = looper.getThread();
++        this.handler = handler;
++
++        if (Build.isDebuggable()) {
++            if (thread != Thread.currentThread()) {
++                throw new IllegalStateException("all calls should happen on the same thread");
++            }
++        }
++
++        Context ctx = sse.context;
++        contentResolver = ctx.getContentResolver();
++        alarmManager = ctx.getSystemService(AlarmManager.class);
++
++        alarmListener = () -> {
++            if (delayDurationMillis() == 0) {
++                return;
++            }
++
++            alarmTriggered();
++        };
++
++        registerStateListener();
++
++        Uri delaySettingUri = Settings.Global.getUriFor(getDelayGlobalSettingsKey());
++
++        ContentObserver delayChangeListener = new ContentObserver(handler) {
++            @Override
++            public void onChange(boolean selfChange) {
++                update();
++            }
++        };
++
++        contentResolver.registerContentObserver(delaySettingUri, false, delayChangeListener);
++    }
++
++    private boolean alarmScheduled;
++
++    protected final void update() {
++        final Thread curThread = Thread.currentThread();
++        if (curThread != thread) {
++            String msg = "update() called on an unknown thread " + curThread;
++            if (Build.isDebuggable()) {
++                throw new IllegalStateException(msg);
++            } else {
++                Slog.e(TAG, msg, new Throwable());
++                return;
++            }
++        }
++
++        if (alarmScheduled) {
++            alarmManager.cancel(alarmListener);
++            alarmScheduled = false;
++        }
++
++        if (!shouldScheduleAlarm()) {
++            return;
++        }
++
++        long delayMillis = delayDurationMillis();
++
++        if (delayMillis == 0) {
++            return;
++        }
++
++        final long triggerAt = SystemClock.elapsedRealtime() + delayMillis;
++        alarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAt,
++                    getClass().getName(), alarmListener, handler);
++        alarmScheduled = true;
++    }
++
++    private long delayDurationMillis() {
++        return Settings.Global.getLong(contentResolver, getDelayGlobalSettingsKey(), 0);
++    }
++
++    // Make sure to use the same Handler that is used for all other callbacks;
++    // call update() to reschedule / cancel the alarm
++    protected abstract void registerStateListener();
++
++    protected abstract boolean shouldScheduleAlarm();
++    protected abstract void alarmTriggered();
++
++    // android.provider.Settings.Global key
++    protected abstract String getDelayGlobalSettingsKey();
++}
+diff --git a/services/core/java/com/android/server/ext/SystemServerExt.java b/services/core/java/com/android/server/ext/SystemServerExt.java
+new file mode 100644
+index 000000000000..83d895650473
+--- /dev/null
++++ b/services/core/java/com/android/server/ext/SystemServerExt.java
+@@ -0,0 +1,58 @@
++/*
++ * Copyright (C) 2022 GrapheneOS
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package com.android.server.ext;
++
++import android.content.BroadcastReceiver;
++import android.content.Context;
++import android.content.IntentFilter;
++import android.os.Handler;
++
++import com.android.internal.os.BackgroundThread;
++import com.android.server.pm.PackageManagerService;
++
++public final class SystemServerExt {
++
++    public final Context context;
++    public final Handler bgHandler;
++    public final PackageManagerService packageManager;
++
++    private SystemServerExt(Context systemContext, PackageManagerService pm) {
++        context = systemContext;
++        bgHandler = BackgroundThread.getHandler();
++        packageManager = pm;
++    }
++
++    /*
++     Called after system server has completed its initialization,
++     but before any of the apps are started.
++
++     Call from com.android.server.SystemServer#startOtherServices(), at the end of lambda
++     that is passed into mActivityManagerService.systemReady()
++     */
++    public static void init(Context systemContext, PackageManagerService pm) {
++        SystemServerExt sse = new SystemServerExt(systemContext, pm);
++        sse.bgHandler.post(sse::initBgThread);
++    }
++
++    void initBgThread() {
++
++    }
++
++    public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter, Handler handler) {
++        context.registerReceiver(receiver, filter, null, handler);
++    }
++}
+diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java
+index e92ba3ed7dc3..df60c628ccdb 100644
+--- a/services/java/com/android/server/SystemServer.java
++++ b/services/java/com/android/server/SystemServer.java
+@@ -3454,6 +3454,8 @@ public final class SystemServer implements Dumpable {
+                 reportWtf("Triggering OdsignStatsLogger", e);
+             }
+             t.traceEnd();
++
++            com.android.server.ext.SystemServerExt.init(mSystemContext, mPackageManagerService);
+         }, t);
+ 
+         t.traceBegin("LockSettingsThirdPartyAppsStarted");

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/frameworks_base/0015-WiFi_Timeout.patch

@@ -0,0 +1,128 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dmitry Muhomor <muhomor.dmitry@gmail.com>
+Date: Sun, 31 Jul 2022 10:06:14 +0300
+Subject: [PATCH] Wi-Fi auto turn off
+
+Co-authored-by: Pratyush <codelab@pratyush.dev>
+---
+ core/java/android/provider/Settings.java      |  6 ++
+ .../android/server/ext/SystemServerExt.java   |  5 +-
+ .../com/android/server/ext/WifiAutoOff.java   | 69 +++++++++++++++++++
+ 3 files changed, 79 insertions(+), 1 deletion(-)
+ create mode 100644 services/core/java/com/android/server/ext/WifiAutoOff.java
+
+diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
+index 10efaa78e435..49f59950b9e0 100644
+--- a/core/java/android/provider/Settings.java
++++ b/core/java/android/provider/Settings.java
+@@ -19543,6 +19543,12 @@ public final class Settings {
+          */
+         public static final String SETTINGS_REBOOT_AFTER_TIMEOUT = "settings_reboot_after_timeout";
+ 
++        /**
++         * The amount of time in milliseconds before a disconnected Wi-Fi adapter is turned off
++         * @hide
++         */
++        public static final String WIFI_OFF_TIMEOUT = "wifi_off_timeout";
++
+         /**
+          * Whether repair mode is active on the device.
+          * <p>
+diff --git a/services/core/java/com/android/server/ext/SystemServerExt.java b/services/core/java/com/android/server/ext/SystemServerExt.java
+index 83d895650473..66350e2b7f74 100644
+--- a/services/core/java/com/android/server/ext/SystemServerExt.java
++++ b/services/core/java/com/android/server/ext/SystemServerExt.java
+@@ -19,6 +19,7 @@ package com.android.server.ext;
+ import android.content.BroadcastReceiver;
+ import android.content.Context;
+ import android.content.IntentFilter;
++import android.content.pm.PackageManager;
+ import android.os.Handler;
+ 
+ import com.android.internal.os.BackgroundThread;
+@@ -49,7 +50,9 @@ public final class SystemServerExt {
+     }
+ 
+     void initBgThread() {
+-
++        if (packageManager.hasSystemFeature(PackageManager.FEATURE_WIFI, 0)) {
++            new WifiAutoOff(this);
++        }
+     }
+ 
+     public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter, Handler handler) {
+diff --git a/services/core/java/com/android/server/ext/WifiAutoOff.java b/services/core/java/com/android/server/ext/WifiAutoOff.java
+new file mode 100644
+index 000000000000..c7a3c05fe766
+--- /dev/null
++++ b/services/core/java/com/android/server/ext/WifiAutoOff.java
+@@ -0,0 +1,69 @@
++package com.android.server.ext;
++
++import android.content.BroadcastReceiver;
++import android.content.Context;
++import android.content.Intent;
++import android.content.IntentFilter;
++import android.net.wifi.WifiInfo;
++import android.net.wifi.WifiManager;
++import android.os.Build;
++import android.provider.Settings;
++import android.util.Slog;
++
++class WifiAutoOff extends DelayedConditionalAction {
++    private final WifiManager wifiManager;
++
++    WifiAutoOff(SystemServerExt sse) {
++        super(sse, sse.bgHandler);
++        wifiManager = sse.context.getSystemService(WifiManager.class);
++    }
++
++    @Override
++    protected boolean shouldScheduleAlarm() {
++        return isWifiEnabledAndNotConnected();
++    }
++
++    @Override
++    protected void alarmTriggered() {
++        if (isWifiEnabledAndNotConnected()) {
++            wifiManager.setWifiEnabled(false);
++        }
++    }
++
++    private boolean isWifiEnabledAndNotConnected() {
++        if (wifiManager.isWifiEnabled()) {
++            WifiInfo i = wifiManager.getConnectionInfo();
++            if (i == null) {
++                return true;
++            }
++            return i.getBSSID() == null;
++        }
++
++        return false;
++    }
++
++    @Override
++    protected void registerStateListener() {
++        IntentFilter f = new IntentFilter();
++        f.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
++        f.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
++        // ConnectivityManager APIs seem unfit for listening to Wi-Fi state specifically, they look
++        // to be higher level than that, eg VPN over Wi-Fi isn't considered to be a Wi-Fi connection
++        // by ConnectivityManager
++
++        sse.registerReceiver(new BroadcastReceiver() {
++            @Override
++            public void onReceive(Context context, Intent intent) {
++                if (Build.isDebuggable()) {
++                    Slog.d("WifiAutoOff", "" + intent + ", extras " + intent.getExtras().deepCopy());
++                }
++                update();
++            }
++        }, f, handler);
++    }
++
++    @Override
++    protected String getDelayGlobalSettingsKey() {
++        return Settings.Global.WIFI_OFF_TIMEOUT;
++    }
++}

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/frameworks_base/0041-tile_restrictions.patch

@@ -0,0 +1,141 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dmitry Muhomor <muhomor.dmitry@gmail.com>
+Date: Mon, 11 Mar 2024 19:40:18 +0200
+Subject: [PATCH] SystemUI: require unlocking to use QS tiles by default
+
+---
+ .../src/com/android/systemui/qs/QSHost.java   |  1 +
+ .../com/android/systemui/qs/QSHostAdapter.kt  |  4 +++
+ .../systemui/qs/tileimpl/QSTileImpl.java      | 36 +++++++++++++++++--
+ .../systemui/qs/QSHostAdapterKosmos.kt        |  2 ++
+ 4 files changed, 40 insertions(+), 3 deletions(-)
+
+diff --git a/packages/SystemUI/src/com/android/systemui/qs/QSHost.java b/packages/SystemUI/src/com/android/systemui/qs/QSHost.java
+index 7c7f48e0d37b..87e87348d0f2 100644
+--- a/packages/SystemUI/src/com/android/systemui/qs/QSHost.java
++++ b/packages/SystemUI/src/com/android/systemui/qs/QSHost.java
+@@ -51,6 +51,7 @@ public interface QSHost {
+     Context getUserContext();
+     int getUserId();
+     Collection<QSTile> getTiles();
++    com.android.systemui.statusbar.policy.KeyguardStateController getKeyguardStateController();
+     void addCallback(Callback callback);
+     void removeCallback(Callback callback);
+     void removeTile(String tileSpec);
+diff --git a/packages/SystemUI/src/com/android/systemui/qs/QSHostAdapter.kt b/packages/SystemUI/src/com/android/systemui/qs/QSHostAdapter.kt
+index dc3b58247152..08f3fc9d7bdb 100644
+--- a/packages/SystemUI/src/com/android/systemui/qs/QSHostAdapter.kt
++++ b/packages/SystemUI/src/com/android/systemui/qs/QSHostAdapter.kt
+@@ -31,6 +31,7 @@ import com.android.systemui.qs.pipeline.domain.interactor.CurrentTilesInteractor
+ import com.android.systemui.qs.pipeline.shared.QSPipelineFlagsRepository
+ import com.android.systemui.qs.pipeline.shared.TileSpec
+ import com.android.systemui.shade.ShadeDisplayAware
++import com.android.systemui.statusbar.policy.KeyguardStateController
+ import javax.inject.Inject
+ import kotlinx.coroutines.CoroutineScope
+ import kotlinx.coroutines.Job
+@@ -53,6 +54,7 @@ constructor(
+     @ShadeDisplayAware private val context: Context,
+     private val tileServiceRequestControllerBuilder: TileServiceRequestController.Builder,
+     @Application private val scope: CoroutineScope,
++    private val keyguardStateController_: KeyguardStateController,
+     dumpManager: DumpManager,
+ ) : QSHost {
+ 
+@@ -72,6 +74,8 @@ constructor(
+         return interactor.currentQSTiles
+     }
+ 
++    override fun getKeyguardStateController() = keyguardStateController_
++
+     override fun getSpecs(): List<String> {
+         return interactor.currentTilesSpecs.map { it.spec }
+     }
+diff --git a/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileImpl.java b/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileImpl.java
+index 1d1e9911884c..e9dc57e4c47d 100644
+--- a/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileImpl.java
++++ b/packages/SystemUI/src/com/android/systemui/qs/tileimpl/QSTileImpl.java
+@@ -71,6 +71,7 @@ import com.android.systemui.qs.QsEventLogger;
+ import com.android.systemui.qs.SideLabelTileLayout;
+ import com.android.systemui.qs.flags.QsInCompose;
+ import com.android.systemui.qs.logging.QSLogger;
++import com.android.systemui.statusbar.policy.KeyguardStateController;
+ 
+ import java.io.PrintWriter;
+ import java.util.Objects;
+@@ -272,6 +273,32 @@ public abstract class QSTileImpl<TState extends State> implements QSTile, Lifecy
+         return true;
+     }
+ 
++    public enum Action {
++        CLICK,
++        SECONDARY_CLICK,
++        LONG_CLICK,
++    }
++
++    public boolean isAllowedWhenLocked(Action action) {
++        return false;
++    }
++
++    void handleAction(Action action, Runnable handler) {
++        if (isAllowedWhenLocked(action)) {
++            handler.run();
++            return;
++        }
++
++        KeyguardStateController ksc = mHost.getKeyguardStateController();
++        boolean hasSecureKeyguard = ksc.isMethodSecure() && ksc.isShowing();
++
++        if (hasSecureKeyguard) {
++            mActivityStarter.postQSRunnableDismissingKeyguard(handler);
++        } else {
++            handler.run();
++        }
++    }
++
+     // safe to call from any thread
+ 
+     public void addCallback(Callback callback) {
+@@ -616,16 +643,19 @@ public abstract class QSTileImpl<TState extends State> implements QSTile, Lifecy
+                         mActivityStarter.postStartActivityDismissingKeyguard(intent, 0);
+                     } else {
+                         mQSLogger.logHandleClick(mTileSpec, msg.arg1);
+-                        handleClick((Expandable) msg.obj);
++                        Expandable view = (Expandable) msg.obj;
++                        handleAction(Action.CLICK, () -> handleClick(view));
+                     }
+                 } else if (msg.what == SECONDARY_CLICK) {
+                     name = "handleSecondaryClick";
+                     mQSLogger.logHandleSecondaryClick(mTileSpec, msg.arg1);
+-                    handleSecondaryClick((Expandable) msg.obj);
++                    Expandable view = (Expandable) msg.obj;
++                    handleAction(Action.SECONDARY_CLICK, () -> handleSecondaryClick(view));
+                 } else if (msg.what == LONG_CLICK) {
+                     name = "handleLongClick";
+                     mQSLogger.logHandleLongClick(mTileSpec, msg.arg1);
+-                    handleLongClick((Expandable) msg.obj);
++                    Expandable view = (Expandable) msg.obj;
++                    handleAction(Action.LONG_CLICK, () -> handleLongClick(view));
+                 } else if (msg.what == REFRESH_STATE) {
+                     name = "handleRefreshState";
+                     handleRefreshState(msg.obj);
+diff --git a/packages/SystemUI/tests/utils/src/com/android/systemui/qs/QSHostAdapterKosmos.kt b/packages/SystemUI/tests/utils/src/com/android/systemui/qs/QSHostAdapterKosmos.kt
+index 0bf801b35ad1..7cb93459077c 100644
+--- a/packages/SystemUI/tests/utils/src/com/android/systemui/qs/QSHostAdapterKosmos.kt
++++ b/packages/SystemUI/tests/utils/src/com/android/systemui/qs/QSHostAdapterKosmos.kt
+@@ -22,6 +22,7 @@ import com.android.systemui.kosmos.Kosmos
+ import com.android.systemui.kosmos.applicationCoroutineScope
+ import com.android.systemui.qs.external.tileServiceRequestControllerBuilder
+ import com.android.systemui.qs.pipeline.domain.interactor.currentTilesInteractor
++import com.android.systemui.statusbar.policy.keyguardStateController
+ 
+ val Kosmos.qsHostAdapter by
+     Kosmos.Fixture {
+@@ -30,6 +31,7 @@ val Kosmos.qsHostAdapter by
+             applicationContext,
+             tileServiceRequestControllerBuilder,
+             applicationCoroutineScope,
++            keyguardStateController,
+             dumpManager,
+         )
+     }

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/settings/0005-Automatic_Reboot.patch

@@ -0,0 +1,196 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: pratyush <codelab@pratyush.dev>
+Date: Mon, 7 Jun 2021 22:15:59 +0100
+Subject: [PATCH] add auto-reboot setting
+
+---
+ res/values/arrays.xml                         | 31 +++++++
+ res/values/strings.xml                        |  3 +
+ res/xml/security_dashboard_settings.xml       | 10 ++-
+ .../AutoRebootPreferenceController.java       | 82 +++++++++++++++++++
+ .../settings/security/SecuritySettings.java   |  1 +
+ 5 files changed, 126 insertions(+), 1 deletion(-)
+ create mode 100644 src/com/android/settings/security/AutoRebootPreferenceController.java
+
+diff --git a/res/values/arrays.xml b/res/values/arrays.xml
+index febdb0412a4..c5df677975d 100644
+--- a/res/values/arrays.xml
++++ b/res/values/arrays.xml
+@@ -105,6 +105,37 @@
+         <item>1800000</item>
+     </string-array>
+ 
++    <!-- Auto reboot settings -->
++    <string-array name="auto_reboot_entries">
++        <item>Off</item>
++        <item>10 minutes</item>
++        <item>30 minutes</item>
++        <item>1 hour</item>
++        <item>2 hours</item>
++        <item>4 hours</item>
++        <item>8 hours</item>
++        <item>12 hours</item>
++        <item>24 hours</item>
++        <item>36 hours</item>
++        <item>48 hours</item>
++        <item>72 hours</item>
++    </string-array>
++
++    <string-array name="auto_reboot_values" translatable="false">
++        <item>0</item>  <!-- Disabled -->
++        <item>600000</item>
++        <item>1800000</item>
++        <item>3600000</item>
++        <item>7200000</item>
++        <item>14400000</item>
++        <item>28800000</item>
++        <item>43200000</item>
++        <item>86400000</item>
++        <item>129600000</item>
++        <item>172800000</item>
++        <item>259200000</item>
++    </string-array>
++
+     <!-- Wi-Fi settings -->
+ 
+     <!-- Match this with the order of NetworkInfo.DetailedState. --> <skip />
+diff --git a/res/values/strings.xml b/res/values/strings.xml
+index 2e44c013a96..b7105938345 100644
+--- a/res/values/strings.xml
++++ b/res/values/strings.xml
+@@ -675,6 +675,9 @@
+     <!-- Text shown for title of owner info setting [CHAR LIMIT=30]-->
+     <string name="owner_info_settings_title">Add text on lock screen</string>
+ 
++    <string name="auto_reboot_title">Auto reboot</string>
++    <string name="auto_reboot_summary">Automatically reboot the device, if the phone hasn\'t been unlocked within the selected number of hours.</string>
++
+     <!-- Text shown for summary of owner info setting (if none set) [CHAR LIMIT=40]-->
+     <string name="owner_info_settings_summary">None</string>
+     <!-- Hint text shown in owner info edit text [CHAR LIMIT=50] -->
+diff --git a/res/xml/security_dashboard_settings.xml b/res/xml/security_dashboard_settings.xml
+index 0550441d3f2..d0aeb27fe53 100644
+--- a/res/xml/security_dashboard_settings.xml
++++ b/res/xml/security_dashboard_settings.xml
+@@ -60,6 +60,14 @@
+             android:title="@string/security_settings_biometric_preference_title"
+             android:summary="@string/summary_placeholder"
+             settings:keywords="@string/keywords_biometric_settings" />
++
++        <ListPreference
++            android:key="auto_reboot"
++            android:title="@string/auto_reboot_title"
++            android:summary="@string/auto_reboot_summary"
++            android:persistent="false"
++            android:entries="@array/auto_reboot_entries"
++            android:entryValues="@array/auto_reboot_values" />
+     </PreferenceCategory>
+ 
+     <Preference
+@@ -71,4 +79,4 @@
+         settings:controller="com.android.settings.security.SecurityAdvancedSettingsController"
+         settings:keywords="@string/security_advanced_settings_keywords" />
+ 
+-</PreferenceScreen>
+\ No newline at end of file
++</PreferenceScreen>
+diff --git a/src/com/android/settings/security/AutoRebootPreferenceController.java b/src/com/android/settings/security/AutoRebootPreferenceController.java
+new file mode 100644
+index 00000000000..c7a75219a5e
+--- /dev/null
++++ b/src/com/android/settings/security/AutoRebootPreferenceController.java
+@@ -0,0 +1,82 @@
++package com.android.settings.security;
++
++import android.content.Context;
++import android.os.UserManager;
++import android.provider.Settings;
++import android.util.Log;
++
++import androidx.preference.ListPreference;
++import androidx.preference.Preference;
++import androidx.preference.PreferenceCategory;
++import androidx.preference.PreferenceScreen;
++
++import com.android.settings.core.PreferenceControllerMixin;
++import com.android.settingslib.core.AbstractPreferenceController;
++import com.android.settingslib.core.lifecycle.events.OnResume;
++
++public class AutoRebootPreferenceController extends AbstractPreferenceController
++    implements PreferenceControllerMixin, OnResume,
++           Preference.OnPreferenceChangeListener {
++
++    private static final String KEY_AUTO_REBOOT = "auto_reboot";
++    private static final String PREF_KEY_SECURITY_CATEGORY = "security_category";
++
++    private PreferenceCategory mSecurityCategory;
++    private boolean mIsAdmin;
++    private final UserManager mUm;
++
++    public AutoRebootPreferenceController(Context context) {
++        super(context);
++        mUm = UserManager.get(context);
++    }
++
++    @Override
++    public void displayPreference(PreferenceScreen screen) {
++        super.displayPreference(screen);
++        mSecurityCategory = screen.findPreference(PREF_KEY_SECURITY_CATEGORY);
++        updatePreferenceState();
++    }
++
++    @Override
++    public boolean isAvailable() {
++        mIsAdmin = mUm.isAdminUser();
++        return mIsAdmin;
++    }
++
++    @Override
++    public String getPreferenceKey() {
++        return KEY_AUTO_REBOOT;
++    }
++
++    // TODO: should we use onCreatePreferences() instead?
++    private void updatePreferenceState() {
++        if (mSecurityCategory == null) {
++            return;
++        }
++
++        if (mIsAdmin) {
++            ListPreference autoReboot =
++                    (ListPreference) mSecurityCategory.findPreference(KEY_AUTO_REBOOT);
++            autoReboot.setValue(Long.toString(Settings.Global.getLong(
++                    mContext.getContentResolver(), Settings.Global.SETTINGS_REBOOT_AFTER_TIMEOUT, 0)));
++        } else {
++            mSecurityCategory.removePreference(
++                    mSecurityCategory.findPreference(KEY_AUTO_REBOOT));
++        }
++    }
++
++    @Override
++    public void onResume() {
++        updatePreferenceState();
++    }
++
++    @Override
++    public boolean onPreferenceChange(Preference preference, Object value) {
++        final String key = preference.getKey();
++        if (KEY_AUTO_REBOOT.equals(key) && mIsAdmin) {
++            long timeout = Long.parseLong((String) value);
++            Settings.Global.putLong(mContext.getContentResolver(), Settings.Global.SETTINGS_REBOOT_AFTER_TIMEOUT, timeout);
++        }
++        return true;
++    }
++}
+diff --git a/src/com/android/settings/security/SecuritySettings.java b/src/com/android/settings/security/SecuritySettings.java
+index 797d3ec621e..3f0645f7dd8 100644
+--- a/src/com/android/settings/security/SecuritySettings.java
++++ b/src/com/android/settings/security/SecuritySettings.java
+@@ -114,6 +114,7 @@ public class SecuritySettings extends DashboardFragment {
+         securityPreferenceControllers.add(new CombinedBiometricStatusPreferenceController(
+                 context, lifecycle));
+         securityPreferenceControllers.add(new ChangeScreenLockPreferenceController(context, host));
++        securityPreferenceControllers.add(new AutoRebootPreferenceController(context));
+         controllers.add(new PreferenceCategoryController(context, SECURITY_CATEGORY)
+                 .setChildren(securityPreferenceControllers));
+         controllers.addAll(securityPreferenceControllers);

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/settings/0006-Bluetooth_Timeout.patch

@@ -0,0 +1,238 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Oliver Scott <olivercscott@gmail.com>
+Date: Fri, 2 Oct 2020 12:37:30 -0400
+Subject: [PATCH] add bluetooth auto-turn-off setting
+
+---
+ res/values/arrays.xml                         |  44 +++++++
+ res/values/strings.xml                        |  19 +++
+ res/xml/connected_devices.xml                 |   8 ++
+ .../BluetoothTimeoutPreferenceController.java | 115 ++++++++++++++++++
+ 4 files changed, 186 insertions(+)
+ create mode 100644 src/com/android/settings/bluetooth/BluetoothTimeoutPreferenceController.java
+
+diff --git a/res/values/arrays.xml b/res/values/arrays.xml
+index c5df677975d..1a2796ad276 100644
+--- a/res/values/arrays.xml
++++ b/res/values/arrays.xml
+@@ -18,6 +18,50 @@
+ */
+ -->
+ <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
++    <!-- Bluetooth settings.  The delay in inactivity before bluetooth is turned off. These are shown in a list dialog. -->
++    <string-array name="bluetooth_timeout_entries">
++        <item>@string/bluetooth_timeout_summary_never</item>
++        <item>@string/bluetooth_timeout_summary_15secs</item>
++        <item>@string/bluetooth_timeout_summary_30secs</item>
++        <item>@string/bluetooth_timeout_summary_1min</item>
++        <item>@string/bluetooth_timeout_summary_2mins</item>
++        <item>@string/bluetooth_timeout_summary_5mins</item>
++        <item>@string/bluetooth_timeout_summary_10mins</item>
++        <item>@string/bluetooth_timeout_summary_30mins</item>
++        <item>@string/bluetooth_timeout_summary_1hour</item>
++        <item>@string/bluetooth_timeout_summary_2hours</item>
++        <item>@string/bluetooth_timeout_summary_4hours</item>
++        <item>@string/bluetooth_timeout_summary_8hours</item>
++    </string-array>
++
++    <!-- Do not translate. -->
++    <string-array name="bluetooth_timeout_values" translatable="false">
++        <!-- Do not translate. -->
++        <item>0</item>
++        <!-- Do not translate. -->
++        <item>15000</item>
++        <!-- Do not translate. -->
++        <item>30000</item>
++        <!-- Do not translate. -->
++        <item>60000</item>
++        <!-- Do not translate. -->
++        <item>120000</item>
++        <!-- Do not translate. -->
++        <item>300000</item>
++        <!-- Do not translate. -->
++        <item>600000</item>
++        <!-- Do not translate. -->
++        <item>1800000</item>
++        <!-- Do not translate. -->
++        <item>3600000</item>
++        <!-- Do not translate. -->
++        <item>7200000</item>
++        <!-- Do not translate. -->
++        <item>14400000</item>
++        <!-- Do not translate. -->
++        <item>28800000</item>
++    </string-array>
++
+     <!-- Display settings.  The delay in inactivity before the screen is turned off. These are shown in a list dialog. -->
+     <string-array name="screen_timeout_entries">
+         <item>15 seconds</item>
+diff --git a/res/values/strings.xml b/res/values/strings.xml
+index b7105938345..cf41793fd42 100644
+--- a/res/values/strings.xml
++++ b/res/values/strings.xml
+@@ -27,6 +27,25 @@
+     <!-- Used in confirmation dialogs as the action that the user will tap to turn on the feature. [CHAR LIMIT=40]-->
+     <string name="confirmation_turn_on">Turn on</string>
+ 
++    <!-- Connected devices screen, setting option name to change bluetooth timeout -->
++    <string name="bluetooth_timeout">Bluetooth timeout</string>
++
++    <!-- Connected devices screen, setting option summary to change bluetooth timeout -->
++    <string name="bluetooth_timeout_summary">Bluetooth will turn off after <xliff:g id="timeout_description">%1$s</xliff:g> if no devices connected</string>
++    <string name="bluetooth_timeout_summary2">Do not automatically turn off Bluetooth</string>
++    <string name="bluetooth_timeout_summary_never">Never</string>
++    <string name="bluetooth_timeout_summary_15secs">15 seconds</string>
++    <string name="bluetooth_timeout_summary_30secs">30 seconds</string>
++    <string name="bluetooth_timeout_summary_1min">1 minute</string>
++    <string name="bluetooth_timeout_summary_2mins">2 minutes</string>
++    <string name="bluetooth_timeout_summary_5mins">5 minutes</string>
++    <string name="bluetooth_timeout_summary_10mins">10 minutes</string>
++    <string name="bluetooth_timeout_summary_30mins">30 minutes</string>
++    <string name="bluetooth_timeout_summary_1hour">1 hour</string>
++    <string name="bluetooth_timeout_summary_2hours">2 hours</string>
++    <string name="bluetooth_timeout_summary_4hours">4 hours</string>
++    <string name="bluetooth_timeout_summary_8hours">8 hours</string>
++
+     <!-- Device Info screen. Used for a status item's value when the proper value is not known -->
+     <string name="device_info_default">Unknown</string>
+     <!-- String for removal of sensitive info on about, depending on tap -->
+diff --git a/res/xml/connected_devices.xml b/res/xml/connected_devices.xml
+index 95aa8773c68..d66915369e4 100644
+--- a/res/xml/connected_devices.xml
++++ b/res/xml/connected_devices.xml
+@@ -60,6 +60,14 @@
+         settings:useAdminDisabledSummary="true"
+         settings:userRestriction="no_config_bluetooth" />
+ 
++    <androidx.preference.ListPreference
++        android:key="bluetooth_timeout"
++        android:title="@string/bluetooth_timeout"
++        android:summary="@string/summary_placeholder"
++        android:entries="@array/bluetooth_timeout_entries"
++        android:entryValues="@array/bluetooth_timeout_values"
++        settings:controller="com.android.settings.bluetooth.BluetoothTimeoutPreferenceController"/>
++
+     <PreferenceCategory
+         android:key="previously_connected_devices"
+         android:title="@string/connected_device_saved_title"
+diff --git a/src/com/android/settings/bluetooth/BluetoothTimeoutPreferenceController.java b/src/com/android/settings/bluetooth/BluetoothTimeoutPreferenceController.java
+new file mode 100644
+index 00000000000..244147948aa
+--- /dev/null
++++ b/src/com/android/settings/bluetooth/BluetoothTimeoutPreferenceController.java
+@@ -0,0 +1,115 @@
++/*
++ * Copyright (C) 2020 The Calyx Institute
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package com.android.settings.bluetooth;
++
++import android.bluetooth.BluetoothAdapter;
++import android.content.Context;
++import android.provider.Settings;
++import android.util.Log;
++
++import androidx.preference.ListPreference;
++import androidx.preference.Preference;
++
++import com.android.settings.R;
++import com.android.settings.core.BasePreferenceController;
++import com.android.settings.core.PreferenceControllerMixin;
++
++public class BluetoothTimeoutPreferenceController extends BasePreferenceController implements
++        PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
++    private static final String TAG = "BluetoothTimeoutPrefCtrl";
++
++    public static final int FALLBACK_BLUETOOTH_TIMEOUT_VALUE = 0;
++
++    private final String mBluetoothTimeoutKey;
++
++    protected BluetoothAdapter mBluetoothAdapter;
++
++    public BluetoothTimeoutPreferenceController(Context context, String key) {
++        super(context, key);
++        mBluetoothTimeoutKey = key;
++
++        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
++        if (mBluetoothAdapter == null) {
++            Log.e(TAG, "Bluetooth is not supported on this device");
++            return;
++        }
++    }
++
++    @Override
++    public int getAvailabilityStatus() {
++        return mBluetoothAdapter != null ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
++    }
++
++    @Override
++    public String getPreferenceKey() {
++        return mBluetoothTimeoutKey;
++    }
++
++    @Override
++    public void updateState(Preference preference) {
++        final ListPreference timeoutListPreference = (ListPreference) preference;
++        final long currentTimeout = Settings.Global.getLong(mContext.getContentResolver(),
++                Settings.Global.BLUETOOTH_OFF_TIMEOUT, FALLBACK_BLUETOOTH_TIMEOUT_VALUE);
++        timeoutListPreference.setValue(String.valueOf(currentTimeout));
++        updateTimeoutPreferenceDescription(timeoutListPreference,
++                Long.parseLong(timeoutListPreference.getValue()));
++    }
++
++    @Override
++    public boolean onPreferenceChange(Preference preference, Object newValue) {
++        try {
++            long value = Long.parseLong((String) newValue);
++            Settings.Global.putLong(mContext.getContentResolver(), Settings.Global.BLUETOOTH_OFF_TIMEOUT, value);
++            updateTimeoutPreferenceDescription((ListPreference) preference, value);
++        } catch (NumberFormatException e) {
++            Log.e(TAG, "could not persist bluetooth timeout setting", e);
++        }
++        return true;
++    }
++
++    public static CharSequence getTimeoutDescription(
++            long currentTimeout, CharSequence[] entries, CharSequence[] values) {
++        if (currentTimeout < 0 || entries == null || values == null
++                || values.length != entries.length) {
++            return null;
++        }
++
++        for (int i = 0; i < values.length; i++) {
++            long timeout = Long.parseLong(values[i].toString());
++            if (currentTimeout == timeout) {
++                return entries[i];
++            }
++        }
++        return null;
++    }
++
++    private void updateTimeoutPreferenceDescription(ListPreference preference,
++                                                    long currentTimeout) {
++        final CharSequence[] entries = preference.getEntries();
++        final CharSequence[] values = preference.getEntryValues();
++        final CharSequence timeoutDescription = getTimeoutDescription(
++                currentTimeout, entries, values);
++        String summary = "";
++        if (timeoutDescription != null) {
++            if (currentTimeout != 0)
++                summary = mContext.getString(R.string.bluetooth_timeout_summary, timeoutDescription);
++            else
++                summary = mContext.getString(R.string.bluetooth_timeout_summary2);
++        }
++        preference.setSummary(summary);
++    }
++}

vendor/sunfish-a16/patches/009-axp-los23-port/a15-src/settings/0007-WiFi_Timeout.patch

@@ -0,0 +1,238 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Oliver Scott <olivercscott@gmail.com>
+Date: Thu, 25 Feb 2021 11:31:14 -0500
+Subject: [PATCH] add Wi-Fi timeout feature
+
+---
+ res/values/arrays.xml                         |  44 +++++++
+ res/values/strings.xml                        |  19 +++
+ res/xml/wifi_configure_settings.xml           |   8 ++
+ .../wifi/WifiTimeoutPreferenceController.java | 115 ++++++++++++++++++
+ 4 files changed, 186 insertions(+)
+ create mode 100644 src/com/android/settings/wifi/WifiTimeoutPreferenceController.java
+
+diff --git a/res/values/arrays.xml b/res/values/arrays.xml
+index 1a2796ad276..9344280a905 100644
+--- a/res/values/arrays.xml
++++ b/res/values/arrays.xml
+@@ -62,6 +62,50 @@
+         <item>28800000</item>
+     </string-array>
+ 
++    <!-- Wifi settings.  The delay in inactivity before wifi is turned off. These are shown in a list dialog. -->
++    <string-array name="wifi_timeout_entries">
++        <item>@string/wifi_timeout_summary_never</item>
++        <item>@string/wifi_timeout_summary_15secs</item>
++        <item>@string/wifi_timeout_summary_30secs</item>
++        <item>@string/wifi_timeout_summary_1min</item>
++        <item>@string/wifi_timeout_summary_2mins</item>
++        <item>@string/wifi_timeout_summary_5mins</item>
++        <item>@string/wifi_timeout_summary_10mins</item>
++        <item>@string/wifi_timeout_summary_30mins</item>
++        <item>@string/wifi_timeout_summary_1hour</item>
++        <item>@string/wifi_timeout_summary_2hours</item>
++        <item>@string/wifi_timeout_summary_4hours</item>
++        <item>@string/wifi_timeout_summary_8hours</item>
++    </string-array>
++
++    <!-- Do not translate. -->
++    <string-array name="wifi_timeout_values" translatable="false">
++        <!-- Do not translate. -->
++        <item>0</item>
++        <!-- Do not translate. -->
++        <item>15000</item>
++        <!-- Do not translate. -->
++        <item>30000</item>
++        <!-- Do not translate. -->
++        <item>60000</item>
++        <!-- Do not translate. -->
++        <item>120000</item>
++        <!-- Do not translate. -->
++        <item>300000</item>
++        <!-- Do not translate. -->
++        <item>600000</item>
++        <!-- Do not translate. -->
++        <item>1800000</item>
++        <!-- Do not translate. -->
++        <item>3600000</item>
++        <!-- Do not translate. -->
++        <item>7200000</item>
++        <!-- Do not translate. -->
++        <item>14400000</item>
++        <!-- Do not translate. -->
++        <item>28800000</item>
++    </string-array>
++
+     <!-- Display settings.  The delay in inactivity before the screen is turned off. These are shown in a list dialog. -->
+     <string-array name="screen_timeout_entries">
+         <item>15 seconds</item>
+diff --git a/res/values/strings.xml b/res/values/strings.xml
+index cf41793fd42..1c3f864c956 100644
+--- a/res/values/strings.xml
++++ b/res/values/strings.xml
+@@ -46,6 +46,25 @@
+     <string name="bluetooth_timeout_summary_4hours">4 hours</string>
+     <string name="bluetooth_timeout_summary_8hours">8 hours</string>
+ 
++    <!--  screen, setting option name to change wifi timeout -->
++    <string name="wifi_timeout">Turn off Wi-Fi automatically</string>
++
++    <!--  screen, setting option summary to change wifi timeout -->
++    <string name="wifi_timeout_summary">Wi-Fi will turn off after <xliff:g id="timeout_description">%1$s</xliff:g> if no network connected</string>
++    <string name="wifi_timeout_summary2">Disabled</string>
++    <string name="wifi_timeout_summary_never">Never</string>
++    <string name="wifi_timeout_summary_15secs">15 seconds</string>
++    <string name="wifi_timeout_summary_30secs">30 seconds</string>
++    <string name="wifi_timeout_summary_1min">1 minute</string>
++    <string name="wifi_timeout_summary_2mins">2 minutes</string>
++    <string name="wifi_timeout_summary_5mins">5 minutes</string>
++    <string name="wifi_timeout_summary_10mins">10 minutes</string>
++    <string name="wifi_timeout_summary_30mins">30 minutes</string>
++    <string name="wifi_timeout_summary_1hour">1 hour</string>
++    <string name="wifi_timeout_summary_2hours">2 hours</string>
++    <string name="wifi_timeout_summary_4hours">4 hours</string>
++    <string name="wifi_timeout_summary_8hours">8 hours</string>
++
+     <!-- Device Info screen. Used for a status item's value when the proper value is not known -->
+     <string name="device_info_default">Unknown</string>
+     <!-- String for removal of sensitive info on about, depending on tap -->
+diff --git a/res/xml/wifi_configure_settings.xml b/res/xml/wifi_configure_settings.xml
+index 5866c5898d9..663e3109d76 100644
+--- a/res/xml/wifi_configure_settings.xml
++++ b/res/xml/wifi_configure_settings.xml
+@@ -26,6 +26,14 @@
+         android:summary="@string/wifi_wakeup_summary"
+         settings:controller="com.android.settings.wifi.WifiWakeupPreferenceController"/>
+ 
++    <ListPreference
++        android:key="wifi_timeout"
++        android:title="@string/wifi_timeout"
++        android:summary="@string/wifi_timeout_summary"
++        android:entries="@array/wifi_timeout_entries"
++        android:entryValues="@array/wifi_timeout_values"
++        settings:controller="com.android.settings.wifi.WifiTimeoutPreferenceController"/>
++
+     <SwitchPreferenceCompat
+         android:key="notify_open_networks"
+         android:title="@string/wifi_notify_open_networks"
+diff --git a/src/com/android/settings/wifi/WifiTimeoutPreferenceController.java b/src/com/android/settings/wifi/WifiTimeoutPreferenceController.java
+new file mode 100644
+index 00000000000..7116c905190
+--- /dev/null
++++ b/src/com/android/settings/wifi/WifiTimeoutPreferenceController.java
+@@ -0,0 +1,115 @@
++/*
++ * Copyright (C) 2020 The Calyx Institute
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++package com.android.settings.wifi;
++
++import android.content.Context;
++import android.net.wifi.WifiManager;
++import android.provider.Settings;
++import android.util.Log;
++
++import androidx.preference.ListPreference;
++import androidx.preference.Preference;
++
++import com.android.settings.R;
++import com.android.settings.core.BasePreferenceController;
++import com.android.settings.core.PreferenceControllerMixin;
++
++public class WifiTimeoutPreferenceController extends BasePreferenceController implements
++        PreferenceControllerMixin, Preference.OnPreferenceChangeListener {
++    private static final String TAG = "WifiTimeoutPrefCtrl";
++
++    public static final int FALLBACK_WIFI_TIMEOUT_VALUE = 0;
++
++    private final String mWifiTimeoutKey;
++
++    protected WifiManager mWifiManager;
++
++    public WifiTimeoutPreferenceController(Context context, String key) {
++        super(context, key);
++        mWifiTimeoutKey = key;
++
++        mWifiManager = context.getSystemService(WifiManager.class);
++        if (mWifiManager == null) {
++            Log.e(TAG, "Wifi is not supported on this device");
++            return;
++        }
++    }
++
++    @Override
++    public int getAvailabilityStatus() {
++        return mWifiManager != null ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
++    }
++
++    @Override
++    public String getPreferenceKey() {
++        return mWifiTimeoutKey;
++    }
++
++    @Override
++    public void updateState(Preference preference) {
++        final ListPreference timeoutListPreference = (ListPreference) preference;
++        final long currentTimeout = Settings.Global.getLong(mContext.getContentResolver(),
++                Settings.Global.WIFI_OFF_TIMEOUT, FALLBACK_WIFI_TIMEOUT_VALUE);
++        timeoutListPreference.setValue(String.valueOf(currentTimeout));
++        updateTimeoutPreferenceDescription(timeoutListPreference,
++                Long.parseLong(timeoutListPreference.getValue()));
++    }
++
++    @Override
++    public boolean onPreferenceChange(Preference preference, Object newValue) {
++        try {
++            long value = Long.parseLong((String) newValue);
++            Settings.Global.putLong(mContext.getContentResolver(), Settings.Global.WIFI_OFF_TIMEOUT, value);
++            updateTimeoutPreferenceDescription((ListPreference) preference, value);
++        } catch (NumberFormatException e) {
++            Log.e(TAG, "could not persist wifi timeout setting", e);
++        }
++        return true;
++    }
++
++    public static CharSequence getTimeoutDescription(
++            long currentTimeout, CharSequence[] entries, CharSequence[] values) {
++        if (currentTimeout < 0 || entries == null || values == null
++                || values.length != entries.length) {
++            return null;
++        }
++
++        for (int i = 0; i < values.length; i++) {
++            long timeout = Long.parseLong(values[i].toString());
++            if (currentTimeout == timeout) {
++                return entries[i];
++            }
++        }
++        return null;
++    }
++
++    private void updateTimeoutPreferenceDescription(ListPreference preference,
++                                                    long currentTimeout) {
++        final CharSequence[] entries = preference.getEntries();
++        final CharSequence[] values = preference.getEntryValues();
++        final CharSequence timeoutDescription = getTimeoutDescription(
++                currentTimeout, entries, values);
++        String summary = "";
++        if (timeoutDescription != null) {
++            if (currentTimeout != 0)
++                summary = mContext.getString(R.string.wifi_timeout_summary, timeoutDescription);
++            else
++                summary = mContext.getString(R.string.wifi_timeout_summary2);
++        }
++        preference.setSummary(summary);
++    }
++}