From 043b10c63b18a397e9a7d9b63c7f34eef8245865 Mon Sep 17 00:00:00 2001
From: Ricardo Cerqueira <cyanogenmod@cerqueira.org>
Date: Fri, 23 Nov 2012 14:23:16 +0000
Subject: [PATCH] fw/b: Button backlight brightness

Squash of:

Author: Ricardo Cerqueira <cyanogenmod@cerqueira.org>
Date:   Fri Nov 23 14:23:16 2012 +0000

    Reintroduce button-backlight (and respective inactivity timeout)

    The power manager rewrite from Change I1d7a52e98f0449f76d70bf421f6a7f245957d1d7
    completely removed support for control of the button backlights, which makes
    all capacitive buttons out there stay dark. The commit message in that change
    mentions it hasn't been implemented _yet_, so this fix should be temporary
    until upstream does their own implementation

    Change-Id: I6094c446e0b8c23f57d30652a3cbd35dee5e821a

Author: Danny Baumann <dannybaumann@web.de>
Date:   Thu Aug 22 08:53:24 2013 +0200

    Add PowerManager integration for button and keyboard backlight.

    Allows setting button and keyboard backlight brightness as well as
    button timeout.

    Change-Id: I550cccafc0a8f90d6347de9261adb26b75955cc4

Author: Steve Kondik <steve@cyngn.com>
Date:   Sat Jan 3 05:13:26 2015 -0800

    power: Disable keyboard/button lights while dozing/dreaming

     * With hardkeys and doze mode enabled, entering suspend results in
       an epic battle over the lights. It's a bad situation. Disable
       them when we're sleepy.

    Change-Id: I7f1fc35a1573717d1ea101a07c4171d6f66d1553

Author: nadlabak <pavel@doshaska.net>
Date:   Sun Jun 7 02:01:05 2015 +0200

    PowerManagerService: Fix updating of mUserActivitySummary

    I7f1fc35a1573717d1ea101a07c4171d6f66d1553 missed the fact that the primary
    purpose of the affected condition block was to update mUserActivitySummary
    and the button/keyboard light handling was just appended to it later.

    This fixes the waking from dream/screensaver by user activity.

    I30c5c8c9c09e3d57ace18cac72b783510b9b3bf3 is removed here as well as it was
    just a band aid.

    jira: NIGHTLIES-1285

    Change-Id: I6b2f6c58e73110787d62e86d4d2ef538638cf491

Author: Bruno Martins <bgcngm@gmail.com>
Date:   Tue Dec 26 17:15:05 2017 +0000

    Forward-port button brightness implementation to O

     * Reworked for the new handler interface, restoring also removed
       methods (partial revert of commit 86c39f9edee88baa912c694061010483c7da9daf).

     * Keyboard backlight brightness support left out for now.

    Change-Id: I53f031fa2da394e95a2b29a01eb3c6a8f8132507

Change-Id: I5176a2028c18408c17bac7f25e62b5612fd6c227
Signed-off-by: DennySPb <dennyspb@gmail.com>
---

diff --git a/core/java/android/os/PowerManager.java b/core/java/android/os/PowerManager.java
index 4a6c459..4de0647 100644
--- a/core/java/android/os/PowerManager.java
+++ b/core/java/android/os/PowerManager.java
@@ -481,7 +481,8 @@
             BRIGHTNESS_CONSTRAINT_TYPE_DOZE,
             BRIGHTNESS_CONSTRAINT_TYPE_MINIMUM_VR,
             BRIGHTNESS_CONSTRAINT_TYPE_MAXIMUM_VR,
-            BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_VR
+            BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_VR,
+            BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_BUTTON
     })
     @Retention(RetentionPolicy.SOURCE)
     public @interface BrightnessConstraint{}
@@ -534,6 +535,12 @@
     public static final int BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_VR = 7;
 
     /**
+     * Brightness constraint type: minimum allowed value.
+     * @hide
+     */
+    public static final int BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_BUTTON = 8;
+
+    /**
      * @hide
      */
     @IntDef(prefix = { "WAKE_REASON_" }, value = {
diff --git a/core/java/android/os/PowerManagerInternal.java b/core/java/android/os/PowerManagerInternal.java
index eb18b96..fca3e76 100644
--- a/core/java/android/os/PowerManagerInternal.java
+++ b/core/java/android/os/PowerManagerInternal.java
@@ -108,6 +108,16 @@
     public abstract void setScreenBrightnessOverrideFromWindowManager(float brightness);
 
     /**
+     * Used by the window manager to override the button brightness based on the
+     * current foreground activity.
+     *
+     * This method must only be called by the window manager.
+     *
+     * @param brightness The overridden brightness, or Float.NaN to disable the override.
+     */
+    public abstract void setButtonBrightnessOverrideFromWindowManager(float brightness);
+
+    /**
      * Used by the window manager to override the user activity timeout based on the
      * current foreground activity.  It can only be used to make the timeout shorter
      * than usual, not longer.
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index c47ac54..15cc767c 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -5877,6 +5877,21 @@
         public static final String VOLUME_KEYS_CONTROL_RING_TONE =
                 "volume_keys_control_ring_tone";
 
+        /**
+         * The time in ms to keep the button backlight on after pressing a button.
+         * A value of 0 will keep the buttons on for as long as the screen is on.
+         * @hide
+         */
+        public static final String BUTTON_BACKLIGHT_TIMEOUT = "button_backlight_timeout";
+
+        /**
+         * The button brightness to be used while the screen is on or after a button press,
+         * depending on the value of {@link BUTTON_BACKLIGHT_TIMEOUT}.
+         * Valid value range is between 0 and {@link PowerManager#getMaximumButtonBrightness()}
+         * @hide
+         */
+        public static final String BUTTON_BRIGHTNESS = "button_brightness";
+
         /***************************
          * AICP System Settings end
          ***************************/
@@ -6113,6 +6128,8 @@
             PRIVATE_SETTINGS.add(CAMERA_WAKE_SCREEN);
             PRIVATE_SETTINGS.add(SWAP_VOLUME_BUTTONS);
             PRIVATE_SETTINGS.add(VOLUME_KEYS_CONTROL_RING_TONE);
+            PRIVATE_SETTINGS.add(BUTTON_BACKLIGHT_TIMEOUT);
+            PRIVATE_SETTINGS.add(BUTTON_BRIGHTNESS);
         }
 
         /**
diff --git a/core/res/res/values/aicp_config.xml b/core/res/res/values/aicp_config.xml
index e14ebe7..0a795d9 100644
--- a/core/res/res/values/aicp_config.xml
+++ b/core/res/res/values/aicp_config.xml
@@ -179,4 +179,8 @@
 
     <!-- Whether to send camera status intent -->
     <bool name="config_sendCameraStatusIntent">false</bool>
+
+    <!-- Button backlight -->
+    <dimen name="config_buttonBrightnessSettingDefaultFloat">1.0</dimen>
+    <bool name="config_deviceHasVariableButtonBrightness">false</bool>
 </resources>
diff --git a/core/res/res/values/aicp_symbols.xml b/core/res/res/values/aicp_symbols.xml
index 5f5cdd6..fd14b65 100644
--- a/core/res/res/values/aicp_symbols.xml
+++ b/core/res/res/values/aicp_symbols.xml
@@ -143,4 +143,8 @@
 
   <!-- Whether to send camera status intent -->
   <java-symbol type="bool" name="config_sendCameraStatusIntent" />
+
+  <!-- Button backlight -->
+  <java-symbol type="dimen" name="config_buttonBrightnessSettingDefaultFloat" />
+  <java-symbol type="bool" name="config_deviceHasVariableButtonBrightness" />
 </resources>
diff --git a/packages/SettingsProvider/src/android/provider/settings/backup/SystemSettings.java b/packages/SettingsProvider/src/android/provider/settings/backup/SystemSettings.java
index 44082ae..57024895 100644
--- a/packages/SettingsProvider/src/android/provider/settings/backup/SystemSettings.java
+++ b/packages/SettingsProvider/src/android/provider/settings/backup/SystemSettings.java
@@ -193,5 +193,7 @@
         Settings.System.TOAST_ANIMATION,
         Settings.System.SWAP_VOLUME_BUTTONS,
         Settings.System.VOLUME_KEYS_CONTROL_RING_TONE,
+        Settings.System.BUTTON_BACKLIGHT_TIMEOUT,
+        Settings.System.BUTTON_BRIGHTNESS,
     };
 }
diff --git a/packages/SettingsProvider/src/android/provider/settings/validators/SystemSettingsValidators.java b/packages/SettingsProvider/src/android/provider/settings/validators/SystemSettingsValidators.java
index 4842d16..04d4265 100644
--- a/packages/SettingsProvider/src/android/provider/settings/validators/SystemSettingsValidators.java
+++ b/packages/SettingsProvider/src/android/provider/settings/validators/SystemSettingsValidators.java
@@ -312,5 +312,7 @@
         VALIDATORS.put(System.TOAST_ANIMATION, ANY_INTEGER_VALIDATOR);
         VALIDATORS.put(System.SWAP_VOLUME_BUTTONS, BOOLEAN_VALIDATOR);
         VALIDATORS.put(System.VOLUME_KEYS_CONTROL_RING_TONE, BOOLEAN_VALIDATOR);
+        VALIDATORS.put(System.BUTTON_BACKLIGHT_TIMEOUT, ANY_INTEGER_VALIDATOR);
+        VALIDATORS.put(System.BUTTON_BRIGHTNESS, ANY_INTEGER_VALIDATOR);
     }
 }
diff --git a/services/core/java/com/android/server/display/DisplayPowerController.java b/services/core/java/com/android/server/display/DisplayPowerController.java
index 2bbf071..ad78a67 100644
--- a/services/core/java/com/android/server/display/DisplayPowerController.java
+++ b/services/core/java/com/android/server/display/DisplayPowerController.java
@@ -69,6 +69,7 @@
 import com.android.server.display.whitebalance.DisplayWhiteBalanceController;
 import com.android.server.display.whitebalance.DisplayWhiteBalanceFactory;
 import com.android.server.display.whitebalance.DisplayWhiteBalanceSettings;
+import com.android.server.lights.LightsManager;
 import com.android.server.policy.WindowManagerPolicy;
 
 import java.io.PrintWriter;
@@ -167,6 +168,9 @@
     @Nullable
     private final IBatteryStats mBatteryStats;
 
+    // The lights service.
+    private final LightsManager mLights;
+
     // The sensor manager.
     private final SensorManager mSensorManager;
 
@@ -472,6 +476,7 @@
 
         mSettingsObserver = new SettingsObserver(mHandler);
         mCallbacks = callbacks;
+        mLights = LocalServices.getService(LightsManager.class);
         mSensorManager = sensorManager;
         mWindowManagerPolicy = LocalServices.getService(WindowManagerPolicy.class);
         mBlanker = blanker;
@@ -1164,6 +1169,13 @@
         if (state == Display.STATE_OFF) {
             brightnessState = PowerManager.BRIGHTNESS_OFF_FLOAT;
             mBrightnessReasonTemp.setReason(BrightnessReason.REASON_SCREEN_OFF);
+            mLights.getLight(LightsManager.LIGHT_ID_BUTTONS).setBrightness(brightnessState);
+        }
+
+        // Disable button lights when dozing
+        if (state == Display.STATE_DOZE || state == Display.STATE_DOZE_SUSPEND) {
+            mLights.getLight(LightsManager.LIGHT_ID_BUTTONS)
+                    .setBrightness(PowerManager.BRIGHTNESS_OFF_FLOAT);
         }
 
         // Always use the VR brightness when in the VR state.
diff --git a/services/core/java/com/android/server/power/PowerManagerService.java b/services/core/java/com/android/server/power/PowerManagerService.java
index 4a084d4..1c84dc9 100644
--- a/services/core/java/com/android/server/power/PowerManagerService.java
+++ b/services/core/java/com/android/server/power/PowerManagerService.java
@@ -264,6 +264,8 @@
      */
     private static final long ENHANCED_DISCHARGE_PREDICTION_BROADCAST_MIN_DELAY_MS = 60 * 1000L;
 
+    private static final int DEFAULT_BUTTON_ON_DURATION = 5 * 1000;
+
     private final Context mContext;
     private final ServiceThread mHandlerThread;
     private final Handler mHandler;
@@ -293,6 +295,11 @@
     private SettingsObserver mSettingsObserver;
     private DreamManagerInternal mDreamManager;
     private LogicalLight mAttentionLight;
+    private LogicalLight mButtonsLight;
+
+    private int mButtonTimeout;
+    private float mButtonBrightness;
+    private float mButtonBrightnessSettingDefault;
 
     private InattentiveSleepWarningController mInattentiveSleepWarningOverlayController;
     private final AmbientDisplaySuppressionController mAmbientDisplaySuppressionController;
@@ -551,6 +558,7 @@
     public final float mScreenBrightnessMinimumVr;
     public final float mScreenBrightnessMaximumVr;
     public final float mScreenBrightnessDefaultVr;
+    public final float mScreenBrightnessDefaultButton;
 
     // Value we store for tracking face down behavior.
     private boolean mIsFaceDown = false;
@@ -560,6 +568,11 @@
     // One of the Settings.System.SCREEN_BRIGHTNESS_MODE_* constants.
     private int mScreenBrightnessModeSetting;
 
+    // The button brightness setting override from the window manager
+    // to allow the current foreground activity to override the button brightness.
+    private float mButtonBrightnessOverrideFromWindowManager =
+            PowerManager.BRIGHTNESS_INVALID_FLOAT;
+
     // The screen brightness setting override from the window manager
     // to allow the current foreground activity to override the brightness.
     private float mScreenBrightnessOverrideFromWindowManager =
@@ -1051,6 +1064,9 @@
             mScreenBrightnessDefaultVr = vrDef;
         }
 
+        mScreenBrightnessDefaultButton = mContext.getResources().getFloat(
+                com.android.internal.R.dimen.config_buttonBrightnessSettingDefaultFloat);
+
         synchronized (mLock) {
             mWakeLockSuspendBlocker =
                     mInjector.createSuspendBlocker(this, "PowerManagerService.WakeLocks");
@@ -1153,6 +1169,10 @@
             mDisplayGroupPowerStateMapper = mInjector.createDisplayPowerRequestMapper(mLock,
                     mDisplayManagerInternal, new DisplayGroupPowerChangeListener());
 
+            PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
+            mButtonBrightnessSettingDefault = pm.getBrightnessConstraint(
+                    PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_BUTTON);
+
             SensorManager sensorManager = new SystemSensorManager(mContext, mHandler.getLooper());
 
             // The notifier runs on the system server's main looper so as not to interfere
@@ -1170,6 +1190,7 @@
 
             mLightsManager = getLocalService(LightsManager.class);
             mAttentionLight = mLightsManager.getLight(LightsManager.LIGHT_ID_ATTENTION);
+            mButtonsLight = mLightsManager.getLight(LightsManager.LIGHT_ID_BUTTONS);
 
             // Initialize display power management.
             mDisplayManagerInternal.initPowerManagement(
@@ -1246,6 +1267,12 @@
         resolver.registerContentObserver(Settings.System.getUriFor(
                 Settings.System.DOZE_ON_CHARGE),
                 false, mSettingsObserver, UserHandle.USER_ALL);
+        resolver.registerContentObserver(Settings.System.getUriFor(
+                Settings.System.BUTTON_BRIGHTNESS),
+                false, mSettingsObserver, UserHandle.USER_ALL);
+        resolver.registerContentObserver(Settings.System.getUriFor(
+                Settings.System.BUTTON_BACKLIGHT_TIMEOUT),
+                false, mSettingsObserver, UserHandle.USER_ALL);
 
         IVrManager vrManager = IVrManager.Stub.asInterface(getBinderService(Context.VR_SERVICE));
 
@@ -1378,6 +1405,13 @@
                 Settings.System.SCREEN_BRIGHTNESS_MODE,
                 Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL, UserHandle.USER_CURRENT);
 
+        mButtonTimeout = Settings.System.getIntForUser(resolver,
+                Settings.System.BUTTON_BACKLIGHT_TIMEOUT,
+                DEFAULT_BUTTON_ON_DURATION, UserHandle.USER_CURRENT);
+        mButtonBrightness = Settings.System.getFloatForUser(resolver,
+                Settings.System.BUTTON_BRIGHTNESS, mButtonBrightnessSettingDefault,
+                UserHandle.USER_CURRENT);
+
         mDirty |= DIRTY_SETTINGS;
     }
 
@@ -2577,10 +2611,32 @@
                     groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                     if (now < groupNextTimeout) {
                         groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
+                        if (mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId) == WAKEFULNESS_AWAKE) {
+                            float buttonBrightness = PowerManager.BRIGHTNESS_OFF_FLOAT;;
+                            if (isValidButtonBrightness(mButtonBrightnessOverrideFromWindowManager)) {
+                                buttonBrightness = mButtonBrightnessOverrideFromWindowManager;
+                            } else if (isValidButtonBrightness(mButtonBrightness)) {
+                                buttonBrightness = mButtonBrightness;
+                            }
+
+                            if (mButtonTimeout != 0 &&
+                                    now > lastUserActivityTime + mButtonTimeout) {
+                                mButtonsLight.setBrightness(PowerManager.BRIGHTNESS_OFF_FLOAT);
+                            } else {
+                                mButtonsLight.setBrightness(buttonBrightness);
+                                if (buttonBrightness != PowerManager.BRIGHTNESS_OFF_FLOAT &&
+                                        mButtonTimeout != 0) {
+                                    nextTimeout = now + mButtonTimeout;
+                                }
+                            }
+                        }
                     } else {
                         groupNextTimeout = lastUserActivityTime + screenOffTimeout;
                         if (now < groupNextTimeout) {
                             groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
+                            if (mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId) == WAKEFULNESS_AWAKE) {
+                                mButtonsLight.setBrightness(PowerManager.BRIGHTNESS_OFF_FLOAT);
+                            }
                         }
                     }
                 }
@@ -3301,6 +3357,10 @@
         return value >= PowerManager.BRIGHTNESS_MIN && value <= PowerManager.BRIGHTNESS_MAX;
     }
 
+    private static boolean isValidButtonBrightness(float value) {
+        return value > PowerManager.BRIGHTNESS_MIN && value <= PowerManager.BRIGHTNESS_MAX;
+    }
+
     @VisibleForTesting
     int getDesiredScreenPolicyLocked(int groupId) {
         final int wakefulness = mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId);
@@ -3965,6 +4025,17 @@
         }
     }
 
+    private void setButtonBrightnessOverrideFromWindowManagerInternal(float brightness) {
+        synchronized (mLock) {
+            if (!BrightnessSynchronizer.floatEquals(mButtonBrightnessOverrideFromWindowManager,
+                    brightness)) {
+                mButtonBrightnessOverrideFromWindowManager = brightness;
+                mDirty |= DIRTY_SETTINGS;
+                updatePowerStateLocked();
+            }
+        }
+    }
+
     private void setScreenBrightnessOverrideFromWindowManagerInternal(float brightness) {
         synchronized (mLock) {
             if (!BrightnessSynchronizer.floatEquals(mScreenBrightnessOverrideFromWindowManager,
@@ -4271,7 +4342,12 @@
                     + mMaximumScreenOffTimeoutFromDeviceAdmin + " (enforced="
                     + isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked() + ")");
             pw.println("  mStayOnWhilePluggedInSetting=" + mStayOnWhilePluggedInSetting);
+            pw.println("  mButtonTimeout=" + mButtonTimeout);
+            pw.println("  mButtonBrightness=" + mButtonBrightness);
+            pw.println("  mButtonBrightnessSettingDefault=" + mButtonBrightnessSettingDefault);
             pw.println("  mScreenBrightnessModeSetting=" + mScreenBrightnessModeSetting);
+            pw.println("  mButtonBrightnessOverrideFromWindowManager="
+                    + mButtonBrightnessOverrideFromWindowManager);
             pw.println("  mScreenBrightnessOverrideFromWindowManager="
                     + mScreenBrightnessOverrideFromWindowManager);
             pw.println("  mUserActivityTimeoutOverrideFromWindowManager="
@@ -5398,6 +5474,8 @@
                     return mScreenBrightnessMaximumVr;
                 case PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_VR:
                     return mScreenBrightnessDefaultVr;
+                case PowerManager.BRIGHTNESS_CONSTRAINT_TYPE_DEFAULT_BUTTON:
+                    return mScreenBrightnessDefaultButton;
                 default:
                     return PowerManager.BRIGHTNESS_INVALID_FLOAT;
             }
@@ -6082,6 +6160,18 @@
         }
 
         @Override
+        public void setButtonBrightnessOverrideFromWindowManager(float screenBrightness) {
+            mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
+
+            final long ident = Binder.clearCallingIdentity();
+            try {
+                setButtonBrightnessOverrideFromWindowManagerInternal(screenBrightness);
+            } finally {
+                Binder.restoreCallingIdentity(ident);
+            }
+        }
+
+        @Override
         public void setDozeOverrideFromDreamManager(int screenState, int screenBrightness) {
             switch (screenState) {
                 case Display.STATE_UNKNOWN:
diff --git a/services/core/java/com/android/server/wm/RootWindowContainer.java b/services/core/java/com/android/server/wm/RootWindowContainer.java
index 52da4b8..8eeb520 100644
--- a/services/core/java/com/android/server/wm/RootWindowContainer.java
+++ b/services/core/java/com/android/server/wm/RootWindowContainer.java
@@ -176,6 +176,7 @@
         implements DisplayManager.DisplayListener {
     private static final String TAG = TAG_WITH_CLASS_NAME ? "RootWindowContainer" : TAG_WM;
 
+    private static final int SET_BUTTON_BRIGHTNESS_OVERRIDE = 0;
     private static final int SET_SCREEN_BRIGHTNESS_OVERRIDE = 1;
     private static final int SET_USER_ACTIVITY_TIMEOUT = 2;
     static final String TAG_TASKS = TAG + POSTFIX_TASKS;
@@ -184,6 +185,7 @@
 
     private Object mLastWindowFreezeSource = null;
     private Session mHoldScreen = null;
+    private float mButtonBrightnessOverride = PowerManager.BRIGHTNESS_INVALID_FLOAT;
     private float mScreenBrightnessOverride = PowerManager.BRIGHTNESS_INVALID_FLOAT;
     private long mUserActivityTimeout = -1;
     private boolean mUpdateRotation = false;
@@ -824,6 +826,7 @@
         }
 
         mHoldScreen = null;
+        mButtonBrightnessOverride = PowerManager.BRIGHTNESS_INVALID_FLOAT;
         mScreenBrightnessOverride = PowerManager.BRIGHTNESS_INVALID_FLOAT;
         mUserActivityTimeout = -1;
         mObscureApplicationContentOnSecondaryDisplays = false;
@@ -943,13 +946,21 @@
 
         mWmService.setHoldScreenLocked(mHoldScreen);
         if (!mWmService.mDisplayFrozen) {
-            final float brightnessOverride = mScreenBrightnessOverride < PowerManager.BRIGHTNESS_MIN
+            final float buttonBrightnessOverride =
+                    mButtonBrightnessOverride < PowerManager.BRIGHTNESS_MIN
+                    || mButtonBrightnessOverride > PowerManager.BRIGHTNESS_MAX
+                    ? PowerManager.BRIGHTNESS_INVALID_FLOAT : mButtonBrightnessOverride;
+            final float screenBrightnessOverride =
+                    mScreenBrightnessOverride < PowerManager.BRIGHTNESS_MIN
                     || mScreenBrightnessOverride > PowerManager.BRIGHTNESS_MAX
                     ? PowerManager.BRIGHTNESS_INVALID_FLOAT : mScreenBrightnessOverride;
-            int brightnessFloatAsIntBits = Float.floatToIntBits(brightnessOverride);
+            int buttonBrightnessFloatAsIntBits = Float.floatToIntBits(buttonBrightnessOverride);
+            int screenBrightnessFloatAsIntBits = Float.floatToIntBits(screenBrightnessOverride);
             // Post these on a handler such that we don't call into power manager service while
             // holding the window manager lock to avoid lock contention with power manager lock.
-            mHandler.obtainMessage(SET_SCREEN_BRIGHTNESS_OVERRIDE, brightnessFloatAsIntBits,
+            mHandler.obtainMessage(SET_BUTTON_BRIGHTNESS_OVERRIDE, buttonBrightnessFloatAsIntBits,
+                    0).sendToTarget();
+            mHandler.obtainMessage(SET_SCREEN_BRIGHTNESS_OVERRIDE, screenBrightnessFloatAsIntBits,
                     0).sendToTarget();
             mHandler.obtainMessage(SET_USER_ACTIVITY_TIMEOUT, mUserActivityTimeout).sendToTarget();
         }
@@ -1126,6 +1137,10 @@
                                 + "has FLAG_KEEP_SCREEN_ON!!! called by%s",
                         w, Debug.getCallers(10));
             }
+            if (!syswin && w.mAttrs.buttonBrightness >= 0
+                    && Float.isNaN(mButtonBrightnessOverride)) {
+                mButtonBrightnessOverride = w.mAttrs.buttonBrightness;
+            }
             if (!syswin && w.mAttrs.screenBrightness >= 0
                     && Float.isNaN(mScreenBrightnessOverride)) {
                 mScreenBrightnessOverride = w.mAttrs.screenBrightness;
@@ -1198,6 +1213,10 @@
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
+                case SET_BUTTON_BRIGHTNESS_OVERRIDE:
+                    mWmService.mPowerManagerInternal.setButtonBrightnessOverrideFromWindowManager(
+                            Float.intBitsToFloat(msg.arg1));
+                    break;
                 case SET_SCREEN_BRIGHTNESS_OVERRIDE:
                     mWmService.mPowerManagerInternal.setScreenBrightnessOverrideFromWindowManager(
                             Float.intBitsToFloat(msg.arg1));