devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 系统背光设置_android automaticbrightnesscontroller

作者：很楠不爱3 | 2024-06-13 16:45:57

赞

踩

android automaticbrightnesscontroller

一、一般设置

1、手动设置背光API

  1. // 修改当前Activity界面的窗口亮度
  2. private void setScreenLight(int brightness) {
  3.     WindowManager.LayoutParams lp = getWindow().getAttributes();
  4.     lp.screenBrightness = Float.valueOf(brightness) * (1f / 255f);
  5.     getWindow().setAttributes(lp);
  6. }
  7.  
  8. // 修改系统的亮度值
  9. public void setScreenLight(int brightness) {
  10.     Uri uri = Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS);
  11.     ContentResolver contentResolver = getContentResolver();
  12.     Settings.System.putInt(contentResolver, Settings.System.SCREEN_BRIGHTNESS, brightness);
  13.     contentResolver.notifyChange(uri, null);
  14. }

 

2、设置系统背光默认亮度值

  1. #frameworks/base/core/res/res/values/config.xml
  2.  
  3. <integer name="config_screenBrightnessSettingMinimum">2</integer>
  4. <integer name="config_screenBrightnessDim">2</integer>

系统背光节点路径：/sys/class/leds/lcd-backlight/brightness

 

3、自动背光配置设置

自动背光涉及光感值与亮度值对应，需要根据项目进行设置光感和背光值数组，一一对应。

  1. # frameworks/base/core/res/res/values/config.xml
  2.  
  3. <integer-array name="config_autoBrightnessLevels">
  4. ... 填写亮度值数组 ...
  5. </integer-array>
  6.  
  7. <integer-array name="config_autoBrightnessLcdBacklightValues">
  8. ... 填写光感值数组 ...
  9. </integer-array>

 

二、流程分析

系统手动设置，待机休眠等都是通过 PowerManagerService.java 统一管理，自动背光则是由 AutomaticBrightnessController.java 管理。最后统一调用 DisplayPowerController.java 进行处理。

 1、frameworks/base/services/core/java/com/android/server/display/AutomaticBrightnessController.java  主要相关操作：

通过监听L-sersor 值变化发送 handleLightSensorEvent  走到  updateAutoBrightness 函数，最终调用到 DisplayPowerController.java updateBrightness函数。

  1. // 内部创建一个光感监听
  2. private final SensorEventListener mLightSensorListener = new SensorEventListener() {
  3.     @Override
  4.     public void onSensorChanged(SensorEvent event) {
  5.         if (mLightSensorEnabled) {
  6.             final long time = SystemClock.uptimeMillis();
  7.             final float lux = event.values[0];
  8.             handleLightSensorEvent(time, lux);
  9.         }
  10.     }
  11.  
  12.     @Override
  13.     public void onAccuracyChanged(Sensor sensor, int accuracy) {
  14.         // Not used.
  15.     }
  16. };
  17.  
  18. // 通知update背光
  19. private void updateAutoBrightness(boolean sendUpdate) {
  20.     if (!mAmbientLuxValid) {
  21.         return;
  22.     }
  23.  
  24.     // 根据光感值计算对应背光值
  25.     float value = mScreenAutoBrightnessSpline.interpolate(mAmbientLux);
  26.     float gamma = 1.0f;
  27.  
  28.     if (USE_SCREEN_AUTO_BRIGHTNESS_ADJUSTMENT
  29.             && mScreenAutoBrightnessAdjustment != 0.0f) {
  30.         final float adjGamma = MathUtils.pow(mScreenAutoBrightnessAdjustmentMaxGamma,
  31.                 Math.min(1.0f, Math.max(-1.0f, -mScreenAutoBrightnessAdjustment)));
  32.         gamma *= adjGamma;
  33.         if (DEBUG) {
  34.             Slog.d(TAG, "updateAutoBrightness: adjGamma=" + adjGamma);
  35.         }
  36.     }
  37.  
  38.     if (gamma != 1.0f) {
  39.         final float in = value;
  40.         value = MathUtils.pow(value, gamma);
  41.         if (DEBUG) {
  42.             Slog.d(TAG, "updateAutoBrightness: gamma=" + gamma
  43.                     + ", in=" + in + ", out=" + value);
  44.         }
  45.     }
  46.  
  47.     int newScreenAutoBrightness =
  48.             clampScreenBrightness(Math.round(value * PowerManager.BRIGHTNESS_ON));
  49.     if (mScreenAutoBrightness != newScreenAutoBrightness) {
  50.         if (DEBUG) {
  51.             Slog.d(TAG, "updateAutoBrightness: mScreenAutoBrightness="
  52.                     + mScreenAutoBrightness + ", newScreenAutoBrightness="
  53.                     + newScreenAutoBrightness);
  54.         }
  55.  
  56.         mScreenAutoBrightness = newScreenAutoBrightness;
  57.         mLastScreenAutoBrightnessGamma = gamma;
  58.         if (sendUpdate) {
  59.             // 通知mCallbacks背光改变，mCallbacks 即是 DisplayPowerController 类对象
  60.             mCallbacks.updateBrightness();
  61.         }
  62.     }
  63. }
  64.  
  65. // mCallbacks中调用获取当前的自动背光值，后续进行设置
  66. public int getAutomaticScreenBrightness() {
  67.     if (!mAmbientLuxValid) {
  68.         return -1;
  69.     }
  70.     if (mDisplayPolicy == DisplayPowerRequest.POLICY_DOZE) {
  71.         return (int) (mScreenAutoBrightness * mDozeScaleFactor);
  72.     }
  73.     return mScreenAutoBrightness;
  74. }
  75.  
  76.  
  77.

 

2、frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java 主要操作：

上层背光相关操作最终都是走到 PowerManagerService ，统一处理，这里只看设置 SCREEN_BRIGHTNESS 值的流程。通过 SettingsObserver 监听值变化，最终调用到 DisplayPowerController.java requestPowerState 函数。

  1. // 系统启动时进行初始化操作
  2. public void systemReady(IAppOpsService appOps) {
  3.     ... ...
  4.  
  5.     // 绑定监听
  6.     resolver.registerContentObserver(Settings.System.getUriFor(
  7.             Settings.System.SCREEN_BRIGHTNESS),
  8.             false, mSettingsObserver, UserHandle.USER_ALL);
  9.     resolver.registerContentObserver(Settings.System.getUriFor(
  10.             Settings.System.SCREEN_BRIGHTNESS_MODE),
  11.             false, mSettingsObserver, UserHandle.USER_ALL);
  12.     ... ...
  13. }
  14.  
  15. // 监听变化发送 handleSettingsChangedLocked
  16. private final class SettingsObserver extends ContentObserver {
  17.     public SettingsObserver(Handler handler) {
  18.         super(handler);
  19.     }
  20.  
  21.     @Override
  22.     public void onChange(boolean selfChange, Uri uri) {
  23.         synchronized (mLock) {
  24.             handleSettingsChangedLocked();
  25.         }
  26.     }
  27. }
  28.  
  29. //handleSettingsChangedLocked -> updatePowerStateLocked -> updateDisplayPowerStateLocked 
  30. /**
  31.  *异步更新显示电源状态。 更新完成后，mDisplayReady将设置为true。 显示控制器会发布一条消息，告诉 
  32.  *我们实际的显示电源状态何时已更新，因此我们回到这里进行仔细检查并完成。
  33.  *每次该功能都会重新计算显示功率状态。
  34.  *@return如果显示准备就绪，则为True。
  35. */
  36. private boolean updateDisplayPowerStateLocked(int dirty) {
  37.     final boolean oldDisplayReady = mDisplayReady;
  38.     if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS
  39.             | DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED
  40.             | DIRTY_SETTINGS | DIRTY_SCREEN_BRIGHTNESS_BOOST | DIRTY_VR_MODE_CHANGED |
  41.             DIRTY_QUIESCENT)) != 0) {
  42.         mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked();
  43.         ... ...
  44.  
  45.         // 修改更新 mDisplayPowerRequest 亮度值等属性
  46.         mDisplayPowerRequest.screenBrightnessOverride = screenBrightnessOverride;
  47.         mDisplayPowerRequest.useAutoBrightness = autoBrightness;
  48.         mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();
  49.         mDisplayPowerRequest.boostScreenBrightness = shouldBoostScreenBrightness();
  50.  
  51.         updatePowerRequestFromBatterySaverPolicy(mDisplayPowerRequest);
  52.         ... ...        
  53.         // 最终调用 DisplayPowerController 处理
  54.         mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest,mRequestWaitForNegativeProximity);
  55.         ... ...
  56.     }
  57.     return mDisplayReady && !oldDisplayReady;
  58. }
  59.

 

3、frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java 主要相关方法分析

通过  Settings.System.SCREEN_BRIGHTNESS 手动设置值，是从调用 requestPowerState 开始，最终调用 sendUpdatePowerStateLocked，如下

  1. // 通过设置settings值手动更新亮度调用
  2. public boolean requestPowerState(DisplayPowerRequest request,
  3.         boolean waitForNegativeProximity) {
  4.     if (DEBUG) {
  5.         Slog.d(TAG, "requestPowerState: "
  6.                 + request + ", waitForNegativeProximity=" + waitForNegativeProximity);
  7.     }
  8.  
  9.     synchronized (mLock) {
  10.         boolean changed = false;
  11.  
  12.         mRequestPowerStateChangedByUser = false;
  13.  
  14.         if (waitForNegativeProximity
  15.                 && !mPendingWaitForNegativeProximityLocked) {
  16.             mPendingWaitForNegativeProximityLocked = true;
  17.             changed = true;
  18.         }
  19.  
  20.         if (mPendingRequestLocked == null) {
  21.             mPendingRequestLocked = new DisplayPowerRequest(request);
  22.             changed = true;
  23.         } else if (!mPendingRequestLocked.equals(request)) {
  24.             // 这里不同是手动设置的调用
  25.             mPendingRequestLocked.copyFrom(request);
  26.             changed = true;
  27.             mRequestPowerStateChangedByUser = true;
  28.         }
  29.  
  30.         if (changed) {
  31.             mDisplayReadyLocked = false;
  32.         }
  33.  
  34.         if (changed && !mPendingRequestChangedLocked) {
  35.             mPendingRequestChangedLocked = true;
  36.             // 通知更新亮度
  37.             sendUpdatePowerStateLocked();
  38.         }
  39.  
  40.         return mDisplayReadyLocked;
  41.     }
  42. }

自动背光调节的流程调用是从 updateBrightness() 开始，最终也是调用 sendUpdatePowerStateLocked，如下

  1. @Override
  2. public void updateBrightness() {
  3.     sendUpdatePowerState();
  4. }
  5.  
  6. private void sendUpdatePowerState() {
  7.     synchronized (mLock) {
  8.         sendUpdatePowerStateLocked();
  9.     }
  10. }

sendUpdatePowerStateLocked  这个函数就是手动、自动亮度调节最终统一的地方。它里面只是简单的通过handler 发送调用 updatePowerState()；updatePowerState() 里面才是真正进行操作的地方。

  1. private void updatePowerState() {
  2.     // Update the power state request.
  3.     ... ...
  4.  
  5.     // P-Sensor的靠近操作
  6.     if (mProximitySensor != null) {
  7.         ... ...
  8.     } else {
  9.         mWaitingForNegativeProximity = false;
  10.     }
  11.     if (mScreenOffBecauseOfProximity) {
  12.         state = Display.STATE_OFF;
  13.     }
  14.  
  15.     // 配置自动亮度值
  16.     boolean slowChange = false;
  17.     if (brightness < 0) {
  18.         if (autoBrightnessEnabled) {
  19.             // 这里就是获取 AutomaticBrightnessController 保存的自动亮度值
  20.             brightness = mAutomaticBrightnessController.getAutomaticScreenBrightness();
  21.         }
  22.         if (brightness >= 0) {
  23.             // 这里就是保证 brightness 在系统最小最大设置值 10 ~ 255 之间
  24.             // 具体看 frameworks/base/core/res/res/values/config.xml 中 config_screenBrightnessSettingMinimum config_screenBrightnessSettingMaximum 值
  25.             brightness = clampScreenBrightness(brightness);
  26.             if (mAppliedAutoBrightness && !autoBrightnessAdjustmentChanged) {
  27.                 slowChange = true; // slowly adapt to auto-brightness
  28.             }
  29.             mAppliedAutoBrightness = true;
  30.         } else {
  31.             mAppliedAutoBrightness = false;
  32.         }
  33.     } else {
  34.         mAppliedAutoBrightness = false;
  35.     }
  36.  
  37.     // Use default brightness when dozing unless overridden.
  38.     if (brightness < 0 && (state == Display.STATE_DOZE
  39.             || state == Display.STATE_DOZE_SUSPEND)) {
  40.         brightness = mScreenBrightnessDozeConfig;
  41.     }
  42.  
  43.     // 这里是我自己添加判断，过滤重复设置亮度
  44.     // 保存自动亮度值 mRequestPowerStateAutoBrightness。
  45.     // 如果 mRequestPowerStateChangedByUser 手动操作为false，且mRequestPowerStateAutoBrightness也没有变化，就直接return
  46.     if (mRequestPowerStateAutoBrightness != brightness) {
  47.         mRequestPowerStateAutoBrightness = brightness;
  48.     } else if (!mRequestPowerStateChangedByUser) {
  49.         Slog.d(TAG, "Brightness no changed");
  50.         return;
  51.     }
  52.  
  53.     // 这里使用手动亮度值
  54.     Slog.d(TAG, "Apply manual brightness " + brightness + " " + mRequestPowerStateAutoBrightness);
  55.     if (brightness < 0 || mRequestPowerStateChangedByUser) {
  56.         int clampBrightness = clampScreenBrightness(mPowerRequest.screenBrightness);
  57.         if (brightness == clampBrightness) {
  58.             Slog.d(TAG, "RequestPowerStateChangedByUser Brightness no changed");
  59.             return;
  60.         }
  61.         brightness = clampBrightness;
  62.     }
  63.  
  64.     // 这里就是系统自动休眠前，先变暗一会
  65.     if (mPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {
  66.         if (brightness > mScreenBrightnessRangeMinimum) {
  67.             brightness = Math.max(Math.min(brightness - SCREEN_DIM_MINIMUM_REDUCTION,
  68.                     mScreenBrightnessDimConfig), mScreenBrightnessRangeMinimum);
  69.         }
  70.         if (!mAppliedDimming) {
  71.             slowChange = false;
  72.         }
  73.         mAppliedDimming = true;
  74.     } else if (mAppliedDimming) {
  75.         slowChange = false;
  76.         mAppliedDimming = false;
  77.     }
  78.     ... ...
  79.  
  80.     // 判断屏幕是否是off
  81.     if (!mPendingScreenOff) {
  82.         ... ...
  83.  
  84.         // 通过判断确定背光响应变化速度
  85.         // mBrightnessRampRateSlow 原生是60，是1s调整60亮度
  86.         // mBrightnessRampRateFast 原生是180，是1s调整180亮度
  87.         boolean wasOrWillBeInVr = (state == Display.STATE_VR || oldState == Display.STATE_VR);
  88.         if (!mRequestPowerStateChangedByUser && (state == Display.STATE_ON
  89.                 && mSkipRampState == RAMP_STATE_SKIP_NONE
  90.                 || state == Display.STATE_DOZE && !mBrightnessBucketsInDozeConfig)
  91.                 && !wasOrWillBeInVr) {
  92.             // 一般自动亮度变化是会渐变调整的
  93.             animateScreenBrightness(brightness,
  94.                     slowChange ? mBrightnessRampRateSlow : mBrightnessRampRateFast);
  95.         } else {
  96.             // 手动一般是立即变化的，无需动画渐变调整的
  97.             animateScreenBrightness(brightness, 0);
  98.         }
  99.         Slog.d(TAG, "putInt brightness " + brightness);
  100.     }
  101.     ... ...
  102.  
  103. }

animateScreenBrightness 内部逻辑是在 frameworks/base/services/core/java/com/android/server/display/RampAnimator.java 中 animateTo 处理。

animateTo 中调用 postAnimationCallback ，在 mAnimationCallback 中一直设置值渐变。

  1. private void postAnimationCallback() {
  2.     mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, mAnimationCallback, null);
  3. }
  4.  
  5. private void cancelAnimationCallback() {
  6.     mChoreographer.removeCallbacks(Choreographer.CALLBACK_ANIMATION, mAnimationCallback, null);
  7. }
  8.  
  9. private final Runnable mAnimationCallback = new Runnable() {
  10.     @Override // Choreographer callback
  11.     public void run() {
  12.         final long frameTimeNanos = mChoreographer.getFrameTimeNanos();
  13.         final float timeDelta = (frameTimeNanos - mLastFrameTimeNanos)
  14.                 * 0.000000001f;
  15.         mLastFrameTimeNanos = frameTimeNanos;
  16.  
  17.         // Advance the animated value towards the target at the specified rate
  18.         // and clamp to the target. This gives us the new current value but
  19.         // we keep the animated value around to allow for fractional increments
  20.         // towards the target.
  21.         final float scale = ValueAnimator.getDurationScale();
  22.         if (scale == 0) {
  23.             // Animation off.
  24.             mAnimatedValue = mTargetValue;
  25.         } else {
  26.             final float amount = timeDelta * mRate / scale;
  27.             if (mTargetValue > mCurrentValue) {
  28.                 mAnimatedValue = Math.min(mAnimatedValue + amount, mTargetValue);
  29.             } else {
  30.                 mAnimatedValue = Math.max(mAnimatedValue - amount, mTargetValue);
  31.             }
  32.         }
  33.         final int oldCurrentValue = mCurrentValue;
  34.         mCurrentValue = Math.round(mAnimatedValue);
  35.  
  36.         if (oldCurrentValue != mCurrentValue) {
  37.             mProperty.setValue(mObject, mCurrentValue);
  38.         }
  39.  
  40.         // mCurrentValue 当前值 
  41.         // mTargetValue 目标值
  42.         if (mTargetValue != mCurrentValue) {
  43.             postAnimationCallback();
  44.         } else {
  45.             mAnimating = false;
  46.             if (mListener != null) {
  47.                 // 通知变化完成
  48.                 mListener.onAnimationEnd();
  49.             }
  50.         }
  51.     }
  52. };

mProperty.setValue(mObject, mCurrentValue); 

这个方法就是实际操作写入背光值的地方，往下就是通过 native 调用处理。到这里背光设置就完成了。

 

 

 

 

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/713825
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号