Android 笔记 屏幕亮度最大/常亮 - super_zq的博客 - CSDN博客
Android 笔记 屏幕亮度最大/常亮
屏幕亮度最大/常亮
似乎找到一个更简单，更有效的方法来实现屏幕亮度最大化。
之前有一个方法，也是网上不知道哪里找来的，但是设置起来相当麻烦，我都不想提，以后如果没有笔记甚至都不知道怎么下手。
今天又找到一个简单的设置办法。
Window是android的一个抽象类，用来描述当前应用的窗口。
可以像普通的view一样获得window的layoutParams，然后设置里面的属性，然后设置到window里面去。
于是，操作屏幕最亮的方法就是 :
window = getWindow();
windowLayoutParams = window.getAttributes();
windowLayoutParams.screenBrightness = WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_FULL;
window.setAttributes(windowLayoutParams);
对应，取消的操作就是
windowLayoutParams.screenBrightness = WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE;
window.setAttributes(windowLayoutParams);
具体参数的意义去API文档里面查吧。
保持屏幕常亮
有一个方法addFlags(int)可以设置各种描述窗口的特性，其实基本上就是当前界面的特性。
清楚的方法就是clearFlags(int)。
其实原来的方法应该是setFlags(int,int)，这里有两个参数，第一个是要设置的量，第二个是设置的目标。源代码里面似乎是使用了|，也就是按位或操作。所以，基本上要设置的话，第一个和第二个都是一样的，也就是目标。如果要清除，第二个还是那个目标，第一个设置成0即可。
然而，官方也提供了一个便利方法，就是刚才提到的addFlags(),clearFlags()。没那么麻烦了。
那么flags值在哪呢？
在WindowManager.LayoutParams里面。保持常亮的值为FLAG_KEEP_SCREEN_ON。
于是操作就是:
window = getWindow();
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
取消的操作就是
window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
是不是超级简单。
似乎不取消也可以，只对当前window在前台的时候有效。当退出了以后，屏幕又可以还原自动休眠设定了。
我的热门文章Android桌面应用关于开启和关闭“自动同步”和“自动调解屏幕亮度”代码实现？ - ITeye问答
大家好：请问下，我要做一个类似于
7键开关SwitchPro Widget
有自动打开和关闭“自动同步”和“自动调解屏幕亮度”（如下图第一行第5个图片和第7个图标）这样的功能。
都需要用到哪些API类啊？
如果能有相关代码实现或Demo更好，先谢谢了。
目前还没有答案
已解决问题
未解决问题android 如何设置开机后屏幕亮度默认值为自动调节
图老师小编精心整理的android 如何设置开机后屏幕亮度默认值为自动调节希望大家喜欢，觉得好的亲们记得收藏起来哦！您的支持就是小编更新的动力~
在第一次开机后，设置显示自动亮度调节 默认是勾选上的。 修改 alpsframeworksbasepackagesSettingsProviderresvaluesdefaults.xml 内的 bool name="def_screen_brightness_automatic_mode"false/bool 改为 bool name="def_screen_brightness_automatic_mode"true/bool 即可。
来源:/n/9419.html
点击查看更多与《》相关的文章>>
excel中存在的奥秘太多，我们知道又有多少，很多excel小技巧尽在图老师，只有你不知道的，没有做不到的哦，看完让你大吃一惊！
百度浏览器是我们经常使用一款浏览器。
每台电脑开机都会有个开机声音。我们就会想可不可以设置自己喜欢的电脑开机音乐呢？如何设置电脑开机音乐？现在就和图老师来看电脑开机音乐设置吧。
巧设置让Windows实现自动开关机,巧设置让Windows实现自动开关机
每一次打开电脑，都要手动连接网络，非常繁琐，那么怎样才能设置开机自动宽带连接呢，其实方法很简单，就让小编告诉大家设置的方法吧！
现在玩powerpoint的人越老越多，powerpoint中的各种小秘密都公之于众，但是总会有你不知道的小秘密，今天小编给大家分享一个powerpoint小技巧，看完你就会觉得你知道的太少了，赶紧来学习吧！
热门搜索：
FLASH动画零基础教程
CAD教程 怎么使用CAD画图形
怎么在Excel中添加下拉箭头
PS教程 将视频截图后期处理清晰
大家看到好看的画都会觉得眼前一凉，总是幻想自己也能够画出类似的，可实际开始操作又觉得简直是难，其实手绘还是很简单的，下面给大家带来的就是羽毛的手绘明信片教程，一起来看看吧。
大家看到好看的画都会觉得眼前一亮，总是幻想自己也能够画出类似的，可实际开始操作又觉得简直是难，其实手绘还是很简单的，下面给大家带来的就是莲藕的手绘明信片教程，一起来看看吧。
每个人看到好看的画都会觉得眼前一心，总是幻想自己也能够画出类似的，可实际开始操作又觉得简直是难，其实手绘还是很简单的，下面给大家带来的就是可爱鳄鱼的手绘明信片教程，一起来看看吧。
共享单车的普及对于大众来说是一个好事，方便利民还实惠好骑。大家现在上街能看到几种不同的共享单车，有的人会挑选自己喜欢的颜色那款单车。现在市场马上要推出一款新型的“彩虹单车”了，七彩单车有各种颜色。下面一起来看看共享单车的代表颜色吧。
怎么利用Photoshop给电商模特照片精修磨皮？很多朋友在工作中经常会遇到要求精修模特的情况，特别是做化妆品行业的电商设计师，所以总结了一下我的模特修图方法和技巧与大家分享，喜欢的朋友让我们一起来学习吧。
磨皮是我们ps照片最基本的技能，Photoshop人物磨皮是我们必须掌握的，如今不少国人对Photoshop修图的三大酷炫神技双曲线、中性灰与高低频几近痴迷，抓耳挠腮想学会它，下面一起看看教程吧。
掌握一点Photoshop教程对你是非常有用的，这篇教程是给大家分享PS简单快速创建眼睛彩虹美瞳效果方法，教程最终创建出来的效果非常漂亮，而且难度并不是很大，很值得大家学习，一起来学习吧。
2017年最受欢迎的生活服务APP！！生活服务类App的出现为日常生活带来极大便利，我们可以通过手机客户端预约各种家政服务，足不出户就能够享受实惠、便捷的生活服务，那么接下来我为大家推荐一些生活中必备生活app。
由于现在抢红包大热起来，很多app都开始支持发红包抢红包了，因此也出现了微信抢红包神器，可以自动抢微信红包,肯定比认为手动操作快,有消息就会自动打开,然后打开红包。今天就给大家分享2017微信自动抢红包神器大全。
2017手机赚钱软件排行榜！！很多朋友都在苦恼每天的钱不够话，空闲时间不知道怎么打发，总想寻找一种简单的赚钱方式，我们的手机app就有很多，下面具体给大家介绍手机赚钱软件有哪些，总有一款你中意的。
经常玩微信的朋友都知道，微信小程序已经全面上线了，对于小程序的出现是否会引发App变革众说纷纭，但不可否认的是小程序能够带给用户及产商一定的便利，那么今天为大家汇总目前上线的一些实用小程序。
男女交往一直都是人们比较关注的一个问题，都说相爱容易，相处不易，交往过的朋友应该都能深刻的体会到，女生常常抱怨着让男生理解自己，但男生也希望多体谅一下他们。尤其不要老是问一些无法回答的问题来考验他们。
很多朋友都信风水一说，对于自己家里房屋客厅的装修也是有一定要求的，因为客厅的风水关系着整个家居的运势，更关系着主人的财运与健康，因而客厅里的风水禁忌是需要我们谨慎注意的，那么风水学中客厅风水禁忌有哪些呢？
春天已经来临了，夏天也不远了，新的一才刚刚开始，时尚爱美的美眉们最关注的就是春夏服装设计的流行趋势了，早早的把握住时尚趋势走在流行的最尖端，今天就给大家整理分享2017春夏女装设计流行趋势 ，你绝对不能错过的亮点。android5.1 自动亮度调节简析 - 简书
android5.1 自动亮度调节简析
android亮度调节在"设置"的"显示"中,分为手动调节和自动调节。其中手动调节就是通过拖动"亮度调节"的拖动条来直接设置亮度值，自动调节则比较复杂，设置自动亮度模式后，再拖动"亮度调节"的拖动条,可以小范围改变亮度值(前提是光照条件不剧烈变化)，但这时不是直接设置的亮度值,而是需要通过一系列转变转成亮度值。
现在遇到问题是：在自动亮度调节模式下，调节亮度拖动条到最小，屏幕变得很黑。
设置中的亮度设置是在DisplaySettings.java(/Settings/src/com/android/settings
/DisplaySettings.java)中，但这里面没有拖动条的相关操作，只有设置手动调节和自动调节模式的操作。其实弹出拖动条的操作在BrightnessPreference.java(/Settings/src/com/android/settings/BrightnessPreference.java)中,它实现了Preference的onClick方法：
protected void onClick() {
Log.i("BrightnessPreference", "BrightnessPreference:brightness dialog open");
getContext().startActivityAsUser(new Intent(Intent.ACTION_SHOW_BRIGHTNESS_DIALOG),
UserHandle.CURRENT_OR_SELF);
通过查找这个action,发现其就是android.intent.action.SHOW_BRIGHTNESS_DIALOG,在 SystemUI(frameworks\base\packages\SystemUI)的AndroidManifest.xml里也出现了:
android:name=".settings.BrightnessDialog"
android:label="@string/quick_settings_brightness_dialog_title"
android:theme="@android:style/Theme.DeviceDefault.Dialog"
android:finishOnCloseSystemDialogs="true"
android:launchMode="singleInstance"
android:excludeFromRecents="true"
android:exported="true"&
&intent-filter&
&action android:name="android.intent.action.SHOW_BRIGHTNESS_DIALOG" /&
&category android:name="android.intent.category.DEFAULT" /&
&/intent-filter&
&/activity&
这里就是通过action启动BrightnessDialog.java(/UsbStorageActivity/src/com/android/systemui/settings
/BrightnessDialog.java),发现这个Activity就是亮度调节的弹出框，至此就没有Settings什么事了。
BrightnessDialog
在BrightnessDialog中初始化拖动条等相关控件，并实例化了BrightnessController.java(/UsbStorageActivity/src/com/android/systemui/settings/BrightnessController.java)：
setContentView(R.layout.quick_settings_brightness_dialog);
final ImageView icon = (ImageView) findViewById(R.id.brightness_icon);
final ToggleSlider slider = (ToggleSlider) findViewById(R.id.brightness_slider);
mBrightnessController = new BrightnessController(this, icon, slider);
并注册和注销BrightnessController的回调方法：
protected void onStart() {
super.onStart();
mBrightnessController.registerCallbacks();
protected void onStop() {
super.onStop();
mBrightnessController.unregisterCallbacks();
BrightnessController
BrightnessController的回调方法主要是在亮度调节模式改变时更新系统保存的模式，在亮度调节时更新拖动条(此拖动条和下拉栏的亮度条保持一致)。这里主要看亮度设置时的操作。因为BrightnessController实现了对ToggleSlider的监听，在拖动条改变时设置亮度：
public void onChanged(ToggleSlider view, boolean tracking, boolean automatic, int value) {
updateIcon(mAutomatic);
if (mExternalChange)
if (!mAutomatic) {
final int val = value + mMinimumB
Log.i(TAG, "brightness mode:"+mAutomatic+"\nvalue:"+value+"value set:"+val);
setBrightness(val);
if (!tracking) {
AsyncTask.execute(new Runnable() {
public void run() {
Settings.System.putIntForUser(mContext.getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS, val,
UserHandle.USER_CURRENT);
final float adj = value / (BRIGHTNESS_ADJ_RESOLUTION / 2f) - 1;
//original code
setBrightnessAdj(adj);
if (!tracking) {
AsyncTask.execute(new Runnable() {
public void run() {
Settings.System.putFloatForUser(mContext.getContentResolver(),
Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ, adj,
UserHandle.USER_CURRENT);
for (BrightnessStateChangeCallback cb : mChangeCallbacks) {
cb.onBrightnessLevelChanged();
value就是拖动条的值，在初始化的时候，亮度条的范围和值都被设置：
private void updateSlider() {
if (mAutomatic) {
float value = Settings.System.getFloatForUser(mContext.getContentResolver(),Settings.System.SCREEN_AUTO_BRIGHTNESS_ADJ, 0,
UserHandle.USER_CURRENT);
mControl.setMax((int) BRIGHTNESS_ADJ_RESOLUTION);
mControl.setValue((int) ((value + 1) * BRIGHTNESS_ADJ_RESOLUTION / 2f));
value = Settings.System.getIntForUser(mContext.getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS, mMaximumBacklight,
UserHandle.USER_CURRENT);
mControl.setMax(mMaximumBacklight - mMinimumBacklight);
mControl.setValue(value - mMinimumBacklight);
可以看出自动模式下亮度条最大值为BRIGHTNESS_ADJ_RESOLUTION,该值为100，而手动模式下亮度条最大值为mMaximumBacklight - mMinimumBacklight,其中mMaximumBacklight为255，mMinimumBacklight为10。在拖动条的值改变时，onChange()方法被调用，若为手动模式，则：
final int val = value + mMinimumB
setBrightness(val);
可以看出，手动模式直接在从拖动条获取的基数value上加了个亮度的最小值，然后调用setBrightness(val),再来看
setBrightness(val):
private void setBrightness(int brightness) {
mPower.setTemporaryScreenBrightnessSettingOverride(brightness);
} catch (RemoteException ex) {
mPower是IPowerManager的对象，这里先放在一边。再来看若为自动模式时拖动条改变，
final float adj = value / (BRIGHTNESS_ADJ_RESOLUTION / 2f) - 1;
setBrightnessAdj(adj);
其中BRIGHTNESS_ADJ_RESOLUTION为100。可以计算出adj的范围随着value的改变始终保持在[-1,1]，暂且称之为调节参数。然后调用setBrightnessAdj(adj)：
private void setBrightnessAdj(float adj) {
mPower.setTemporaryScreenAutoBrightnessAdjustmentSettingOverride(adj);
} catch (RemoteException ex) {
可以看出，两种模式都最终交给IPowerManager处理了，然后基本就是由framework层来进行处理。3.IPowerManagerIPowerManager开头就有注释：
* This file is auto-generated.
DO NOT MODIFY.
* Original file: frameworks/base/core/java/android/os/IPowerManager.aidl
所以这个文件是aidl自动生成的。两个方法：
public void setTemporaryScreenBrightnessSettingOverride(int brightness) throws android.os.RemoteException
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(brightness);
mRemote.transact(Stub.TRANSACTION_setTemporaryScreenBrightnessSettingOverride, _data, _reply, 0);
_reply.readException();
_reply.recycle();
_data.recycle();
public void setTemporaryScreenAutoBrightnessAdjustmentSettingOverride(float adj) throws android.os.RemoteException
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeFloat(adj);
mRemote.transact(Stub.TRANSACTION_setTemporaryScreenAutoBrightnessAdjustmentSettingOverride, _data, _reply, 0);
_reply.readException();
_reply.recycle();
_data.recycle();
然后搜索发现在PowerManagerService.java(com.android.server.power.
PowerManagerService.class)中的BinderService类implements了IPowerManager的Stub类，并且实现了上述两个方法：
* Used by the settings application and brightness control widgets to
* temporarily override the current screen brightness setting so that the
* user can observe the effect of an intended settings change without applying
* it immediately.
* The override will be canceled when the setting value is next updated.
* @param brightness The overridden brightness.
* @see android.provider.Settings.System#SCREEN_BRIGHTNESS
@Override // Binder call
public void setTemporaryScreenBrightnessSettingOverride(int brightness) {
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.DEVICE_POWER, null);
final long ident = Binder.clearCallingIdentity();
setTemporaryScreenBrightnessSettingOverrideInternal(brightness);
} finally {
Binder.restoreCallingIdentity(ident);
* Used by the settings application and brightness control widgets to
* temporarily override the current screen auto-brightness adjustment setting so that the
* user can observe the effect of an intended settings change without applying
* it immediately.
* The override will be canceled when the setting value is next updated.
* @param adj The overridden brightness, or Float.NaN to disable the override.
* @see android.provider.Settings.System#SCREEN_AUTO_BRIGHTNESS_ADJ
@Override // Binder call
public void setTemporaryScreenAutoBrightnessAdjustmentSettingOverride(float adj) {
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.DEVICE_POWER, null);
final long ident = Binder.clearCallingIdentity();
setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(adj);
} finally {
Binder.restoreCallingIdentity(ident);
注释里说明，这两个方法是Settings和亮度调节插件使用的，再来看值传进来后调用的两个方法：
private void setTemporaryScreenBrightnessSettingOverrideInternal(int brightness) {
synchronized (mLock) {
if (mTemporaryScreenBrightnessSettingOverride != brightness) {
mTemporaryScreenBrightnessSettingOverride =
mDirty |= DIRTY_SETTINGS;
updatePowerStateLocked();
private void setTemporaryScreenAutoBrightnessAdjustmentSettingOverrideInternal(float adj) {
synchronized (mLock) {
// Note: This condition handles NaN because NaN is not equal to any other
// value, including itself.
if (mTemporaryScreenAutoBrightnessAdjustmentSettingOverride != adj) {
mTemporaryScreenAutoBrightnessAdjustmentSettingOverride =
mDirty |= DIRTY_SETTINGS;
updatePowerStateLocked();
拿到值后赋值给一个全局变量，然后马上调用updatePowerStateLocked(),再来看此方法对传入的值做了哪些操作：
* Updates the display power state asynchronously.
* When the update is finished, mDisplayReady will be set to true.
The display
* controller posts a message to tell us when the actual display power state
* has been updated so we come back here to double-check and finish up.
* This function recalculates the display power state each time.
* @return True if the display became ready.
private boolean updateDisplayPowerStateLocked(int dirty) {
final boolean oldDisplayReady = mDisplayR
if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS
| DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED
| DIRTY_SETTINGS | DIRTY_SCREEN_BRIGHTNESS_BOOST)) != 0) {
mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked();
// Determine appropriate screen brightness and auto-brightness adjustments.
int screenBrightness = mScreenBrightnessSettingD
float screenAutoBrightnessAdjustment = 0.0f;
boolean autoBrightness = (mScreenBrightnessModeSetting ==
Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);
if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) {
screenBrightness = mScreenBrightnessOverrideFromWindowM
autoBrightness =
} else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) {
screenBrightness = mTemporaryScreenBrightnessSettingO
} else if (isValidBrightness(mScreenBrightnessSetting)) {
screenBrightness = mScreenBrightnessS
if (autoBrightness) {
screenBrightness = mScreenBrightnessSettingD
if (isValidAutoBrightnessAdjustment(
mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) {
screenAutoBrightnessAdjustment =
mTemporaryScreenAutoBrightnessAdjustmentSettingO
} else if (isValidAutoBrightnessAdjustment(
mScreenAutoBrightnessAdjustmentSetting)) {
screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentS
screenBrightness = Math.max(Math.min(screenBrightness,
mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum);
screenAutoBrightnessAdjustment = Math.max(Math.min(
screenAutoBrightnessAdjustment, 1.0f), -1.0f);
// Update display power request.
mDisplayPowerRequest.screenBrightness = screenB
mDisplayPowerRequest.screenAutoBrightnessAdjustment =
screenAutoBrightnessA
mDisplayPowerRequest.useAutoBrightness = autoB
mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();
mDisplayPowerRequest.lowPowerMode = mLowPowerModeE
mDisplayPowerRequest.boostScreenBrightness = mScreenBrightnessBoostInP
if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) {
mDisplayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamM
mDisplayPowerRequest.dozeScreenBrightness =
mDozeScreenBrightnessOverrideFromDreamM
mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN;
mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT;
mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,
mRequestWaitForNegativeProximity);
mRequestWaitForNegativeProximity =
if (DEBUG_SPEW) {
Slog.d(TAG, "updateDisplayPowerStateLocked: mDisplayReady=" + mDisplayReady
+ ", policy=" + mDisplayPowerRequest.policy
+ ", mWakefulness=" + mWakefulness
+ ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary)
+ ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary)
+ ", mBootCompleted=" + mBootCompleted
+ ", mScreenBrightnessBoostInProgress="
+ mScreenBrightnessBoostInProgress);
return mDisplayReady && !oldDisplayR
发现最终值都被赋给mDisplayPowerRequest的属性，然后调用mDisplayManagerInternal.requestPowerState将值传出返回结果。mDisplayManagerInternal是DisplayManagerInternal(android.hardware.
display.DisplayManagerInternal.class)的对象，再来看看DisplayManagerInternal:4.DisplayManagerInternal
public abstract boolean requestPowerState(DisplayPowerRequest request,
boolean waitForNegativeProximity);
发现并没有具体的实现方法。通过搜索发现
DisplayManageService(com.android.server.display.DisplayManagerService.class)中的LocalService类继承了DisplayManagerInternal并实现了requestPowerState()方法:
public boolean requestPowerState(DisplayPowerRequest request,
boolean waitForNegativeProximity) {
return mDisplayPowerController.requestPowerState(request,
waitForNegativeProximity);
发现调用了DisplayPowerController(com.android.server.display.DisplayPower
Controller.class)的requestPowerState()方法作为返回结果。5.DisplayPowerController
public boolean requestPowerState(DisplayPowerRequest request,
boolean waitForNegativeProximity) {
if (DEBUG) {
Slog.d(TAG, "requestPowerState: "
+ request + ", waitForNegativeProximity=" + waitForNegativeProximity);
synchronized (mLock) {
boolean changed =
if (waitForNegativeProximity
&& !mPendingWaitForNegativeProximityLocked) {
mPendingWaitForNegativeProximityLocked =
if (mPendingRequestLocked == null) {
mPendingRequestLocked = new DisplayPowerRequest(request);
} else if (!mPendingRequestLocked.equals(request)) {
mPendingRequestLocked.copyFrom(request);
if (changed) {
mDisplayReadyLocked =
if (changed && !mPendingRequestChangedLocked) {
mPendingRequestChangedLocked =
sendUpdatePowerStateLocked();
return mDisplayReadyL
可以看出，先是将request对象赋给本地，然后调用sendUpdatePowerStateLocked()：
private void sendUpdatePowerStateLocked() {
if (!mPendingUpdatePowerStateLocked) {
mPendingUpdatePowerStateLocked =
Message msg = mHandler.obtainMessage(MSG_UPDATE_POWER_STATE);
msg.setAsynchronous(true);
mHandler.sendMessage(msg);
交给handler处理：
case MSG_UPDATE_POWER_STATE:
updatePowerState();
调用updatePowerState()方法,其中有这样一段代码：
// Configure auto-brightness.
boolean autoBrightnessEnabled =
if (mAutomaticBrightnessController != null) {
final boolean autoBrightnessEnabledInDoze = mAllowAutoBrightnessWhileDozingConfig
&& (state == Display.STATE_DOZE || state == Display.STATE_DOZE_SUSPEND);
autoBrightnessEnabled = mPowerRequest.useAutoBrightness
&& (state == Display.STATE_ON || autoBrightnessEnabledInDoze)
&& brightness & 0;
mAutomaticBrightnessController.configure(autoBrightnessEnabled,
mPowerRequest.screenAutoBrightnessAdjustment, state != Display.STATE_ON);
mAutomaticBrightnessController是AutomaticBrightnessController(com.android.server.display.AutomaticBrightnessController.class)对象，下面来看AutomaticBrightnessController.6.AutomaticBrightnessController
public void configure(boolean enable, float adjustment, boolean dozing) {
// While dozing, the application processor may be suspended which will prevent us from
// receiving new information from the light sensor. On some devices, we may be able to
// switch to a wake-up light sensor instead but for now we will simply disable the sensor
// and hold onto the last computed screen auto brightness.
We save the dozing flag for
// debugging purposes.
boolean changed = setLightSensorEnabled(enable && !dozing);
changed |= setScreenAutoBrightnessAdjustment(adjustment);
if (changed) {
updateAutoBrightness(false /*sendUpdate*/);
private boolean setScreenAutoBrightnessAdjustment(float adjustment) {
if (adjustment != mScreenAutoBrightnessAdjustment) {
mScreenAutoBrightnessAdjustment =
拿到亮度调节参数后：
private void updateAutoBrightness(boolean sendUpdate) {
if (!mAmbientLuxValid) {
float value = mScreenAutoBrightnessSpline.interpolate(mAmbientLux);
float gamma = 1.0f;
if (USE_SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT
&& mScreenAutoBrightnessAdjustment != 0.0f) {
final float adjGamma = MathUtils.pow(SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT_MAX_GAMMA,
Math.min(1.0f, Math.max(-1.0f, -mScreenAutoBrightnessAdjustment)));
gamma *= adjG
if (DEBUG) {
Slog.d(TAG, "updateAutoBrightness: adjGamma=" + adjGamma);
if (USE_TWILIGHT_ADJUSTMENT) {
TwilightState state = mTwilight.getCurrentState();
if (state != null && state.isNight()) {
final long now = System.currentTimeMillis();
final float earlyGamma =
getTwilightGamma(now, state.getYesterdaySunset(), state.getTodaySunrise());
final float lateGamma =
getTwilightGamma(now, state.getTodaySunset(), state.getTomorrowSunrise());
gamma *= earlyGamma * lateG
if (DEBUG) {
Slog.d(TAG, "updateAutoBrightness: earlyGamma=" + earlyGamma
+ ", lateGamma=" + lateGamma);
if (gamma != 1.0f) {
final float in =
value = MathUtils.pow(value, gamma);
if (DEBUG) {
Slog.d(TAG, "updateAutoBrightness: gamma=" + gamma
+ ", in=" + in + ", out=" + value);
int newScreenAutoBrightness =
clampScreenBrightness(Math.round(value * PowerManager.BRIGHTNESS_ON));
if (mScreenAutoBrightness != newScreenAutoBrightness) {
if (DEBUG) {
Slog.d(TAG, "updateAutoBrightness: mScreenAutoBrightness="
+ mScreenAutoBrightness + ", newScreenAutoBrightness="
+ newScreenAutoBrightness);
mScreenAutoBrightness = newScreenAutoB
mLastScreenAutoBrightnessGamma =
if (sendUpdate) {
mCallbacks.updateBrightness();
这里是一大段针对自动亮度调节，将亮度调节系数和一段时间内的光线感应器获取的光强的加权平均通过一系列运算转化为合适的屏幕背光亮度，具体的转化模型这里不深究。
在这里来看一下，每次转化好亮度后都会做如下处理：
private int clampScreenBrightness(int value) {
return MathUtils.constrain(value,
mScreenBrightnessRangeMinimum, mScreenBrightnessRangeMaximum);
mScreenBrightnessRangeMinimum就是最小值，由构造函数传过来，发现是DisplayPowerController实例化AutomaticBrightnessController时传入的：
mAutomaticBrightnessController = new AutomaticBrightnessController(this,
handler.getLooper(), sensorManager, screenAutoBrightnessSpline,
lightSensorWarmUpTimeConfig, screenBrightnessRangeMinimum,
mScreenBrightnessRangeMaximum, dozeScaleFactor);
在DisplayPowerController的构造函数中：
int screenBrightnessRangeMinimum = Math.min(Math.min(
screenBrightnessSettingMinimum, mScreenBrightnessDimConfig),
mScreenBrightnessDarkConfig);
这三个值均取自config.xml(frameworks\base\core\res\res\values\config.xml)分别为：
screenBrightnessSettingMinimum:config_screenBrightnessSettingMinimum
mScreenBrightnessDimConfig:config_screenBrightnessDim
mScreenBrightnessDarkConfig:config_screenBrightnessDark
发现config.xml文件中三个值最小的为1，改为10之后问题解决。}