基于Android(安卓)P 背光流程
16lz
2021-12-04
一、SystemUI、Settings中手动调节
/frameworks/base/packages/SystemUI/src/com/android/systemui/settings/BrightnessController.java@Overridepublic void onChanged(ToggleSlider toggleSlider, boolean tracking, boolean automatic, int value, boolean stopTracking) { final String setting; if (mIsVrModeEnabled) { setting = Settings.System.SCREEN_BRIGHTNESS_FOR_VR; } else { setting = Settings.System.SCREEN_BRIGHTNESS; } //获取亮度值 final int val = convertGammaToLinear(value, min, max); //设置亮度值 setBrightness(val); if (!tracking) { //在异步任务中将新的亮度值保存在SettingsProvider中 AsyncTask.execute(new Runnable() { public void run() { Settings.System.putIntForUser(mContext.getContentResolver(), setting, val, UserHandle.USER_CURRENT); } }); }}private void setBrightness(int brightness) { mDisplayManager.setTemporaryBrightness(brightness);}//frameworks/base/core/java/android/hardware/display/DisplayManager.javapublic void setTemporaryBrightness(int brightness) { mGlobal.setTemporaryBrightness(brightness);}//frameworks/base/core/java/android/hardware/display/DisplayManagerGlobal.javapublic void setTemporaryBrightness(int brightness) { try { mDm.setTemporaryBrightness(brightness); } catch (RemoteException ex) { throw ex.rethrowFromSystemServer(); }}//frameworks/base/services/core/java/com/android/server/display/DisplayManagerService.java@Override // Binder callpublic void setTemporaryBrightness(int brightness) { mContext.enforceCallingOrSelfPermission( Manifest.permission.CONTROL_DISPLAY_BRIGHTNESS, "Permission required to set the display's brightness"); final long token = Binder.clearCallingIdentity(); try { synchronized (mSyncRoot) { mDisplayPowerController.setTemporaryBrightness(brightness); } } finally { Binder.restoreCallingIdentity(token); }}/frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.javapublic void setTemporaryBrightness(int brightness) { Message msg = mHandler.obtainMessage(MSG_SET_TEMPORARY_BRIGHTNESS, brightness, 0 /*unused*/); msg.sendToTarget();}@Overridepublic void handleMessage(Message msg) { switch (msg.what) { case MSG_SET_TEMPORARY_BRIGHTNESS: // TODO: Should we have a a timeout for the temporary brightness? //将brightness赋值给了mTemporaryScreenBrightness mTemporaryScreenBrightness = msg.arg1; updatePowerState(); break; } }}private void updatePowerState() {// ...... //手动设置亮度是否改变 final boolean userSetBrightnessChanged = updateUserSetScreenBrightness(); if (userSetBrightnessChanged) { mTemporaryScreenBrightness = -1;}// ......// Apply manual brightness. if (brightness < 0) { brightness = clampScreenBrightness(mCurrentScreenBrightnessSetting); }// ...... // Use the temporary screen brightness if there isn't an override, either from // WindowManager or based on the display state. if (mTemporaryScreenBrightness > 0) { //使用手动设置的亮度 brightness = mTemporaryScreenBrightness; mAppliedTemporaryBrightness = true; } else { mAppliedTemporaryBrightness = false; } //........ if (!mPendingScreenOff) { final boolean isDisplayContentVisible = mColorFadeEnabled ? (mColorFadeEnabled && mPowerState.getColorFadeLevel() == 1.0f) : (state == Display.STATE_ON && mSkipRampState == RAMP_STATE_SKIP_NONE); if (initialRampSkip || hasBrightnessBuckets || wasOrWillBeInVr || !isDisplayContentVisible || brightnessIsTemporary) {//设置亮度值到底层驱动，调节背光值，不设置背光动画 animateScreenBrightness(brightness, 0); } else {//设置亮度值到底层驱动，调节背光值，根据slowChange设置快动画还是慢动画 animateScreenBrightness(brightness, slowChange ? mBrightnessRampRateSlow : mBrightnessRampRateFast); } //......}private boolean updateUserSetScreenBrightness() { if (mPendingScreenBrightnessSetting < 0) { return false; } //add for bug BEG if (mPendingScreenBrightnessSetting > 0 && (mCurrentScreenBrightnessSetting == mTemporaryScreenBrightness)){ return true; } //add for bug END if (mCurrentScreenBrightnessSetting == mPendingScreenBrightnessSetting) { mPendingScreenBrightnessSetting = -1; return false; } mCurrentScreenBrightnessSetting = mPendingScreenBrightnessSetting; mLastUserSetScreenBrightness = mPendingScreenBrightnessSetting; mPendingScreenBrightnessSetting = -1; return true;}//监听SettingsProvider中Settings.System.SCREEN_BRIGHTNESS的值变化（对应systemUI，Settings中seekbar的拖动）private final class SettingsObserver extends ContentObserver { public SettingsObserver(Handler handler) { super(handler); } @Override public void onChange(boolean selfChange, Uri uri) { handleSettingsChange(false /* userSwitch */); } }private void handleSettingsChange(boolean userSwitch) { mPendingScreenBrightnessSetting = getScreenBrightnessSetting(); sendUpdatePowerState();}private int getScreenBrightnessSetting() { final int brightness = Settings.System.getIntForUser(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS, mScreenBrightnessDefault, UserHandle.USER_CURRENT); return clampAbsoluteBrightness(brightness);}二、视频背光调节播放视频时，可以通过上下滑动界面来设置亮度，当退出播放界面时，又会恢复到原亮度，其调用接口正是PMS中的setScreenBrightnessOverrideFromWindowManager()方法。/frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.javapublic void handleMessage(Message msg) { switch (msg.what) { case SET_SCREEN_BRIGHTNESS_OVERRIDE: //调用PMS相关接口 mService.mPowerManagerInternal.setScreenBrightnessOverrideFromWindowManager( msg.arg1); break; ...... } }}/frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java@Overridepublic void setScreenBrightnessOverrideFromWindowManager(int screenBrightness) { if (screenBrightness < PowerManager.BRIGHTNESS_DEFAULT || screenBrightness > PowerManager.BRIGHTNESS_ON) { screenBrightness = PowerManager.BRIGHTNESS_DEFAULT; } setScreenBrightnessOverrideFromWindowManagerInternal(screenBrightness);}private void setScreenBrightnessOverrideFromWindowManagerInternal(int brightness) { synchronized (mLock) { //将亮度值设置给了mScreenBrightnessOverrideFromWindowManager变量 if (mScreenBrightnessOverrideFromWindowManager != brightness) { mScreenBrightnessOverrideFromWindowManager = brightness; mDirty |= DIRTY_SETTINGS; updatePowerStateLocked(); } }}private void updatePowerStateLocked() { if (!mSystemReady || mDirty == 0) { return; } if (!Thread.holdsLock(mLock)) { Slog.wtf(TAG, "Power manager lock was not held when calling updatePowerStateLocked"); } Trace.traceBegin(Trace.TRACE_TAG_POWER, "updatePowerState"); try { // Phase 0: Basic state updates. updateIsPoweredLocked(mDirty); updateStayOnLocked(mDirty); updateScreenBrightnessBoostLocked(mDirty); // Phase 1: Update wakefulness. // Loop because the wake lock and user activity computations are influenced // by changes in wakefulness. final long now = SystemClock.uptimeMillis(); int dirtyPhase2 = 0; for (;;) { int dirtyPhase1 = mDirty; dirtyPhase2 |= dirtyPhase1; mDirty = 0; updateWakeLockSummaryLocked(dirtyPhase1); updateUserActivitySummaryLocked(now, dirtyPhase1); if (!updateWakefulnessLocked(dirtyPhase1)) { break; } } // Phase 2: Lock profiles that became inactive/not kept awake. updateProfilesLocked(now); // Phase 3: Update display power state. final boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2); // Phase 4: Update dream state (depends on display ready signal). updateDreamLocked(dirtyPhase2, displayBecameReady); // Phase 5: Send notifications, if needed. finishWakefulnessChangeIfNeededLocked(); // Phase 6: Update suspend blocker. // Because we might release the last suspend blocker here, we need to make sure // we finished everything else first! updateSuspendBlockerLocked(); } finally { Trace.traceEnd(Trace.TRACE_TAG_POWER); } }private boolean updateDisplayPowerStateLocked(int dirty) { final boolean oldDisplayReady = mDisplayReady; 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 | DIRTY_VR_MODE_CHANGED |DIRTY_QUIESCENT)) != 0) { mDisplayPowerRequest.policy = getDesiredScreenPolicyLocked(); // Determine appropriate screen brightness and auto-brightness adjustments. final boolean autoBrightness; final int screenBrightnessOverride; if (!mBootCompleted) { // Keep the brightness steady during boot. This requires the // bootloader brightness and the default brightness to be identical. autoBrightness = false; screenBrightnessOverride = mScreenBrightnessSettingDefault; } else if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) { autoBrightness = false; screenBrightnessOverride = mScreenBrightnessOverrideFromWindowManager; } else { autoBrightness = (mScreenBrightnessModeSetting == Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC); screenBrightnessOverride = -1; } // Update display power request. mDisplayPowerRequest.screenBrightnessOverride = screenBrightnessOverride; mDisplayPowerRequest.useAutoBrightness = autoBrightness; mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked(); mDisplayPowerRequest.boostScreenBrightness = shouldBoostScreenBrightness(); updatePowerRequestFromBatterySaverPolicy(mDisplayPowerRequest); if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE) { mDisplayPowerRequest.dozeScreenState = mDozeScreenStateOverrideFromDreamManager; if ((mWakeLockSummary & WAKE_LOCK_DRAW) != 0 && !mDrawWakeLockOverrideFromSidekick) { if (mDisplayPowerRequest.dozeScreenState == Display.STATE_DOZE_SUSPEND) { mDisplayPowerRequest.dozeScreenState = Display.STATE_DOZE; } if (mDisplayPowerRequest.dozeScreenState == Display.STATE_ON_SUSPEND) { mDisplayPowerRequest.dozeScreenState = Display.STATE_ON; } } mDisplayPowerRequest.dozeScreenBrightness = mDozeScreenBrightnessOverrideFromDreamManager; } else { mDisplayPowerRequest.dozeScreenState = Display.STATE_UNKNOWN; mDisplayPowerRequest.dozeScreenBrightness = PowerManager.BRIGHTNESS_DEFAULT; } mDisplayReady = mDisplayManagerInternal.requestPowerState(mDisplayPowerRequest, mRequestWaitForNegativeProximity); mRequestWaitForNegativeProximity = false; if ((dirty & DIRTY_QUIESCENT) != 0) { sQuiescent = false; } } return mDisplayReady && !oldDisplayReady; }/frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.javapublic boolean requestPowerState(DisplayPowerRequest request, boolean waitForNegativeProximity) { if (DEBUG) { Slog.d(TAG, "requestPowerState: " + request + ", waitForNegativeProximity=" + waitForNegativeProximity); } synchronized (mLock) { boolean changed = false; if (waitForNegativeProximity && !mPendingWaitForNegativeProximityLocked) { mPendingWaitForNegativeProximityLocked = true; changed = true; } if (mPendingRequestLocked == null) { mPendingRequestLocked = new DisplayPowerRequest(request); changed = true; } else if (!mPendingRequestLocked.equals(request)) { mPendingRequestLocked.copyFrom(request); changed = true; if (changed) { mDisplayReadyLocked = false; } if (changed && !mPendingRequestChangedLocked) { mPendingRequestChangedLocked = true; sendUpdatePowerStateLocked(); } return mDisplayReadyLocked; } }private void sendUpdatePowerStateLocked() { if (!mPendingUpdatePowerStateLocked) { mPendingUpdatePowerStateLocked = true; Message msg = mHandler.obtainMessage(MSG_UPDATE_POWER_STATE); mHandler.sendMessage(msg);} @Overridepublic void handleMessage(Message msg) { switch (msg.what) { case MSG_UPDATE_POWER_STATE: updatePowerState(); break; }}三、自动背光自动背光流程跟前面的介绍背光流程分叉口就在updatePowerState（）。private void updatePowerState() {…if (mAutomaticBrightnessController != null) { hadUserBrightnessPoint = mAutomaticBrightnessController.hasUserDataPoints(); mAutomaticBrightnessController.configure(autoBrightnessEnabled, mBrightnessConfiguration, mLastUserSetScreenBrightness / (float)PowerManager.BRIGHTNESS_ON, userSetBrightnessChanged, autoBrightnessAdjustment, autoBrightnessAdjustmentChanged, mPowerRequest.policy); } // Apply auto-brightness. boolean slowChange = false; if (brightness < 0) { float newAutoBrightnessAdjustment = autoBrightnessAdjustment; if (autoBrightnessEnabled) { brightness = mAutomaticBrightnessController.getAutomaticScreenBrightness(); newAutoBrightnessAdjustment = mAutomaticBrightnessController.getAutomaticScreenBrightnessAdjustment(); } if (brightness >= 0) { // Use current auto-brightness value and slowly adjust to changes. brightness = clampScreenBrightness(brightness); if (mAppliedAutoBrightness && !autoBrightnessAdjustmentChanged) { slowChange = true; // slowly adapt to auto-brightness } putScreenBrightnessSetting(brightness); mAppliedAutoBrightness = true; } else { mAppliedAutoBrightness = false; } if (autoBrightnessAdjustment != newAutoBrightnessAdjustment) { putAutoBrightnessAdjustmentSetting(newAutoBrightnessAdjustment); } } else { mAppliedAutoBrightness = false; }…if (!mPendingScreenOff) { final boolean isDisplayContentVisible = mColorFadeEnabled ? (mColorFadeEnabled && mPowerState.getColorFadeLevel() == 1.0f) : (state == Display.STATE_ON && mSkipRampState == RAMP_STATE_SKIP_NONE); if (initialRampSkip || hasBrightnessBuckets || wasOrWillBeInVr || !isDisplayContentVisible || brightnessIsTemporary) { animateScreenBrightness(brightness, 0); } else { animateScreenBrightness(brightness, slowChange ? mBrightnessRampRateSlow : mBrightnessRampRateFast); }…}public void configure(boolean enable, @Nullable BrightnessConfiguration configuration, float brightness, boolean userChangedBrightness, float adjustment, boolean userChangedAutoBrightnessAdjustment, int displayPolicy) { boolean dozing = (displayPolicy == DisplayPowerRequest.POLICY_DOZE); boolean changed = setBrightnessConfiguration(configuration); changed |= setDisplayPolicy(displayPolicy); if (userChangedAutoBrightnessAdjustment) { changed |= setAutoBrightnessAdjustment(adjustment); } if (userChangedBrightness && enable) { changed |= setScreenBrightnessByUser(brightness); } final boolean userInitiatedChange = userChangedBrightness || userChangedAutoBrightnessAdjustment; if (userInitiatedChange && enable && !dozing) { prepareBrightnessAdjustmentSample(); }//注册/解除注册LightSensor,即开启自动调节亮度且非Doze状态下才可用 changed |= setLightSensorEnabled(enable && !dozing);//changed为true则说明自动调节亮度状态发生改变或自动亮度调整值发生改变，则更新亮度 if (changed) { updateAutoBrightness(false /*sendUpdate*/); } }private boolean setLightSensorEnabled(boolean enable) { if (enable) { if (!mLightSensorEnabled) { mLightSensorEnabled = true; mLightSensorEnableTime = SystemClock.uptimeMillis(); mCurrentLightSensorRate = mInitialLightSensorRate; mSensorManager.registerListener(mLightSensorListener, mLightSensor, mCurrentLightSensorRate * 1000, mHandler); return true; } } else if (mLightSensorEnabled) { mLightSensorEnabled = false; mAmbientLuxValid = !mResetAmbientLuxAfterWarmUpConfig; mRecentLightSamples = 0; mAmbientLightRingBuffer.clear(); mCurrentLightSensorRate = -1; mHandler.removeMessages(MSG_UPDATE_AMBIENT_LUX); mSensorManager.unregisterListener(mLightSensorListener); } return false; }private final SensorEventListener mLightSensorListener = new SensorEventListener() { @Override public void onSensorChanged(SensorEvent event) { if (mLightSensorEnabled) { final long time = SystemClock.uptimeMillis(); final float lux = event.values[0]; handleLightSensorEvent(time, lux); } } @Override public void onAccuracyChanged(Sensor sensor, int accuracy) { // Not used. } };private void handleLightSensorEvent(long time, float lux) { Trace.traceCounter(Trace.TRACE_TAG_POWER, "ALS", (int) lux); mHandler.removeMessages(MSG_UPDATE_AMBIENT_LUX); if (mAmbientLightRingBuffer.size() == 0) { adjustLightSensorRate(mNormalLightSensorRate); } applyLightSensorMeasurement(time, lux); updateAmbientLux(time);}private void applyLightSensorMeasurement(long time, float lux) { mRecentLightSamples++;//删除距离当前mAmbientLightHorizon(10s)秒的数据 //LSensor500ms上报一次值，因此存储10s内可存储21组数据 mAmbientLightRingBuffer.prune(time - mAmbientLightHorizon);//添加此次数据 mAmbientLightRingBuffer.push(time, lux); mLastObservedLux = lux; mLastObservedLuxTime = time; }private void updateAmbientLux() { long time = SystemClock.uptimeMillis(); mAmbientLightRingBuffer.prune(time - mAmbientLightHorizon); updateAmbientLux(time); }private void updateAmbientLux(long time) { if (!mAmbientLuxValid) { final long timeWhenSensorWarmedUp = mLightSensorWarmUpTimeConfig + mLightSensorEnableTime; if (time < timeWhenSensorWarmedUp) { mHandler.sendEmptyMessageAtTime(MSG_UPDATE_AMBIENT_LUX, timeWhenSensorWarmedUp); return; } setAmbientLux(calculateAmbientLux(time,AMBIENT_LIGHT_SHORT_HORIZON_MILLIS)); mAmbientLuxValid = true; updateAutoBrightness(true); } long nextBrightenTransition = nextAmbientLightBrighteningTransition(time); long nextDarkenTransition = nextAmbientLightDarkeningTransition(time); float slowAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_LONG_HORIZON_MILLIS); float fastAmbientLux = calculateAmbientLux(time, AMBIENT_LIGHT_SHORT_HORIZON_MILLIS); if ((slowAmbientLux >= mBrighteningLuxThreshold && fastAmbientLux >= mBrighteningLuxThreshold && nextBrightenTransition <= time) ||(slowAmbientLux <= mDarkeningLuxThreshold && fastAmbientLux <= mDarkeningLuxThreshold && nextDarkenTransition <= time)) { setAmbientLux(fastAmbientLux); updateAutoBrightness(true); nextBrightenTransition = nextAmbientLightBrighteningTransition(time); nextDarkenTransition = nextAmbientLightDarkeningTransition(time); } long nextTransitionTime = Math.min(nextDarkenTransition, nextBrightenTransition); nextTransitionTime = nextTransitionTime > time ? nextTransitionTime : time + mNormalLightSensorRate; mHandler.sendEmptyMessageAtTime(MSG_UPDATE_AMBIENT_LUX, nextTransitionTime); }private void updateAutoBrightness(boolean sendUpdate) { if (!mAmbientLuxValid) { return; } float value = mBrightnessMapper.getBrightness(mAmbientLux); int newScreenAutoBrightness = clampScreenBrightness(Math.round(value * PowerManager.BRIGHTNESS_ON)); if (mScreenAutoBrightness != newScreenAutoBrightness) { mScreenAutoBrightness = newScreenAutoBrightness; if (sendUpdate) { mCallbacks.updateBrightness(); } } }public int getAutomaticScreenBrightness() { if (!mAmbientLuxValid) { return -1; } if (mDisplayPolicy == DisplayPowerRequest.POLICY_DOZE) { return (int) (mScreenAutoBrightness * mDozeScaleFactor); } return mScreenAutoBrightness; }/frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java@Overridepublic void updateBrightness() { sendUpdatePowerState(); }private void sendUpdatePowerState() { synchronized (mLock) { sendUpdatePowerStateLocked(); } }private void sendUpdatePowerStateLocked() { if (!mPendingUpdatePowerStateLocked) { mPendingUpdatePowerStateLocked = true; Message msg = mHandler.obtainMessage(MSG_UPDATE_POWER_STATE); mHandler.sendMessage(msg); } }//最后又是重新调用updatepowerstate（）去更新背光值到底层上面各种背光流程，我们都已经将具体流程介绍了一遍，最后得将在他们各个模式下的背光值设置到底层驱动中，而取的值，则要看当前是属于那种模式下，使用animateScreenBrightness（）改变屏幕亮度。
if (initialRampSkip || hasBrightnessBuckets || wasOrWillBeInVr || !isDisplayContentVisible || brightnessIsTemporary) {//直接设置亮度值，不需要亮度动画 animateScreenBrightness(brightness, 0); } else {//设置亮度值，根据slowChange设置快速或慢速动画 animateScreenBrightness(brightness, ? mBrightnessRampRateSlow : mBrightnessRampRateFast); }private void animateScreenBrightness(int target, int rate) { if (DEBUG) { Slog.d(TAG, "Animating brightness: target=" + target +", rate=" + rate); } if (mScreenBrightnessRampAnimator.animateTo(target, rate)) { Trace.traceCounter(Trace.TRACE_TAG_POWER, "TargetScreenBrightness", target); try { mBatteryStats.noteScreenBrightness(target); } catch (RemoteException ex) { // same process } } }/frameworks/base/services/core/java/com/android/server/display/RampAnimator.javapublic boolean animateTo(int target, int rate) { // Immediately jump to the target the first time. if (mFirstTime || rate <= 0) { if (mFirstTime || target != mCurrentValue) { mFirstTime = false; mRate = 0; mTargetValue = target; mCurrentValue = target; mProperty.setValue(mObject, target); if (mAnimating) { mAnimating = false; cancelAnimationCallback(); } if (mListener != null) { mListener.onAnimationEnd(); } return true; } return false; } if (!mAnimating || rate > mRate || (target <= mCurrentValue && mCurrentValue <= mTargetValue) || (mTargetValue <= mCurrentValue && mCurrentValue <= target)) { mRate = rate; } final boolean changed = (mTargetValue != target); mTargetValue = target; // Start animating. if (!mAnimating && target != mCurrentValue) { mAnimating = true; mAnimatedValue = mCurrentValue; mLastFrameTimeNanos = System.nanoTime(); postAnimationCallback(); } return changed;}private void postAnimationCallback() { mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, mAnimationCallback, null); }private final Runnable mAnimationCallback = new Runnable() { @Override // Choreographer callback public void run() { final long frameTimeNanos = mChoreographer.getFrameTimeNanos(); final float timeDelta = (frameTimeNanos - mLastFrameTimeNanos)* 0.000000001f; mLastFrameTimeNanos = frameTimeNanos; final float scale = ValueAnimator.getDurationScale(); if (scale == 0) { // Animation off. mAnimatedValue = mTargetValue; } else { final float amount = timeDelta * mRate / scale; if (mTargetValue > mCurrentValue) { mAnimatedValue = Math.min(mAnimatedValue + amount, mTargetValue); } else { mAnimatedValue = Math.max(mAnimatedValue - amount, mTargetValue); } } final int oldCurrentValue = mCurrentValue; mCurrentValue = Math.round(mAnimatedValue); if (oldCurrentValue != mCurrentValue) { mProperty.setValue(mObject, mCurrentValue); } if (mTargetValue != mCurrentValue) { postAnimationCallback(); } else { mAnimating = false; if (mListener != null) { mListener.onAnimationEnd(); } } }};public RampAnimator(T object, IntProperty property) { mObject = object; mProperty = property; mChoreographer = Choreographer.getInstance(); }/frameworks/base/services/core/java/com/android/server/display/DisplayPowerController.java mScreenBrightnessRampAnimator = new RampAnimator( mPowerState, DisplayPowerState.SCREEN_BRIGHTNESS);/frameworks/base/services/core/java/com/android/server/display/DisplayPowerState.javapublic static final IntProperty SCREEN_BRIGHTNESS = new IntProperty("screenBrightness") { @Override public void setValue(DisplayPowerState object, int value) { object.setScreenBrightness(value); } @Override public Integer get(DisplayPowerState object) { return object.getScreenBrightness(); } };public void setScreenBrightness(int brightness) { if (mScreenBrightness != brightness) { mScreenBrightness = brightness; if (mScreenState != Display.STATE_OFF) { mScreenReady = false; scheduleScreenUpdate(); } } }private void scheduleScreenUpdate() { if (!mScreenUpdatePending) { mScreenUpdatePending = true; postScreenUpdateThreadSafe(); } }private void postScreenUpdateThreadSafe() { mHandler.removeCallbacks(mScreenUpdateRunnable); mHandler.post(mScreenUpdateRunnable); }private final Runnable mScreenUpdateRunnable = new Runnable() { @Override public void run() { mScreenUpdatePending = false; int brightness = mScreenState != Display.STATE_OFF && mColorFadeLevel > 0f ? mScreenBrightness : 0; if (mPhotonicModulator.setState(mScreenState, brightness)) { if (DEBUG) { Slog.d(TAG, "Screen ready"); } mScreenReady = true; invokeCleanListenerIfNeeded(); } else { if (DEBUG) { Slog.d(TAG, "Screen not ready"); } } } };public boolean setState(int state, int backlight) { synchronized (mLock) { boolean stateChanged = state != mPendingState; boolean backlightChanged = backlight != mPendingBacklight; mPendingState = state; mPendingBacklight = backlight; boolean changeInProgress = mStateChangeInProgress || mBacklightChangeInProgress; mStateChangeInProgress = stateChanged || mStateChangeInProgress; mBacklightChangeInProgress = backlightChanged || mBacklightChangeInProgress; if (!changeInProgress) { mLock.notifyAll(); } } return !mStateChangeInProgress; } }@Overridepublic void run() { for (;;) { // Get pending change. final int state; final boolean stateChanged; final int backlight; final boolean backlightChanged; synchronized (mLock) { state = mPendingState; stateChanged = (state != mActualState); backlight = mPendingBacklight; backlightChanged = (backlight != mActualBacklight); if (!stateChanged) { postScreenUpdateThreadSafe(); mStateChangeInProgress = false; } if (!backlightChanged) { mBacklightChangeInProgress = false; } if (!stateChanged && !backlightChanged) { try { mLock.wait(); } catch (InterruptedException ex) { } continue; } mActualState = state; mActualBacklight = backlight; } mBlanker.requestDisplayState(state, backlight); } }}/frameworks/base/services/core/java/com/android/server/display/DisplayManagerService.javapublic void initPowerManagement(final DisplayPowerCallbacks callbacks, Handler handler, SensorManager sensorManager) { synchronized (mSyncRoot) { DisplayBlanker blanker = new DisplayBlanker() { @Override public void requestDisplayState(int state, int brightness) { // The order of operations is important for legacy reasons. //对于灭屏和非灭屏状态,调用callback的顺序不同 if (state == Display.STATE_OFF) { requestGlobalDisplayStateInternal(state, brightness); } //PMS中调用native层方法 callbacks.onDisplayStateChange(state); if (state != Display.STATE_OFF) { requestGlobalDisplayStateInternal(state, brightness); } } }; mDisplayPowerController = new DisplayPowerController( mContext, callbacks, handler, sensorManager, blanker); }}private void requestGlobalDisplayStateInternal(int state, int brightness) { if (state == Display.STATE_UNKNOWN) { state = Display.STATE_ON; } if (state == Display.STATE_OFF) { brightness = PowerManager.BRIGHTNESS_OFF; } else if (brightness < 0) { brightness = PowerManager.BRIGHTNESS_DEFAULT; } else if (brightness > PowerManager.BRIGHTNESS_ON) { brightness = PowerManager.BRIGHTNESS_ON; } synchronized (mTempDisplayStateWorkQueue) { try { synchronized (mSyncRoot) { if (mGlobalDisplayState == state && mGlobalDisplayBrightness == brightness) { return; // no change } Trace.traceBegin(Trace.TRACE_TAG_POWER, "requestGlobalDisplayState(" + Display.stateToString(state) + ", brightness=" + brightness + ")"); mGlobalDisplayState = state; mGlobalDisplayBrightness = brightness; applyGlobalDisplayStateLocked(mTempDisplayStateWorkQueue); } for (int i = 0; i < mTempDisplayStateWorkQueue.size(); i++) { mTempDisplayStateWorkQueue.get(i).run(); } Trace.traceEnd(Trace.TRACE_TAG_POWER); } finally { mTempDisplayStateWorkQueue.clear(); } } }private void applyGlobalDisplayStateLocked(List workQueue) { final int count = mDisplayDevices.size(); for (int i = 0; i < count; i++) { DisplayDevice device = mDisplayDevices.get(i); Runnable runnable = updateDisplayStateLocked(device); if (runnable != null) { workQueue.add(runnable); } } }private Runnable updateDisplayStateLocked(DisplayDevice device) { DisplayDeviceInfo info = device.getDisplayDeviceInfoLocked(); if ((info.flags & DisplayDeviceInfo.FLAG_NEVER_BLANK) == 0) { return device.requestDisplayStateLocked(mGlobalDisplayState, mGlobalDisplayBrightness); } return null; }/frameworks/base/services/core/java/com/android/server/display/LocalDisplayAdapter.java@Overridepublic Runnable requestDisplayStateLocked(final int state, final int brightness) { assert state != Display.STATE_OFF || brightness == PowerManager.BRIGHTNESS_OFF; final boolean stateChanged = (mState != state); final boolean brightnessChanged = (mBrightness != brightness) && mBacklight != null; if (stateChanged || brightnessChanged) { final int displayId = mBuiltInDisplayId; final IBinder token = getDisplayTokenLocked(); final int oldState = mState; if (stateChanged) { mState = state; updateDeviceInfoLocked(); } if (brightnessChanged) { mBrightness = brightness; } return new Runnable() { @Override public void run() { int currentState = oldState; if (Display.isSuspendedState(oldState) || oldState == Display.STATE_UNKNOWN) { if (!Display.isSuspendedState(state)) { setDisplayState(state); currentState = state; } else if (state == Display.STATE_DOZE_SUSPEND || oldState == Display.STATE_DOZE_SUSPEND) { setDisplayState(Display.STATE_DOZE); currentState = Display.STATE_DOZE; } else if (state == Display.STATE_ON_SUSPEND || oldState == Display.STATE_ON_SUSPEND) { setDisplayState(Display.STATE_ON); currentState = Display.STATE_ON; } else { return; } } boolean vrModeChange = false; if ((state == Display.STATE_VR || currentState == Display.STATE_VR) && currentState != state) { setVrMode(state == Display.STATE_VR); vrModeChange = true; } if (brightnessChanged || vrModeChange) { setDisplayBrightness(brightness); } if (state != currentState) { setDisplayState(state); } } private void setVrMode(boolean isVrEnabled) { mBacklight.setVrMode(isVrEnabled); } private void setDisplayState(int state) { if (mSidekickActive) { Trace.traceBegin(Trace.TRACE_TAG_POWER, "SidekickInternal#endDisplayControl"); try { mSidekickInternal.endDisplayControl(); } finally { Trace.traceEnd(Trace.TRACE_TAG_POWER); } mSidekickActive = false; } final int mode = getPowerModeForState(state); Trace.traceBegin(Trace.TRACE_TAG_POWER, "setDisplayState(" + "id=" + displayId + ", state=" + Display.stateToString(state) + ")"); try { SurfaceControl.setDisplayPowerMode(token, mode); Trace.traceCounter(Trace.TRACE_TAG_POWER, "DisplayPowerMode", mode); } finally { Trace.traceEnd(Trace.TRACE_TAG_POWER); } if (Display.isSuspendedState(state) && state != Display.STATE_OFF && mSidekickInternal != null && !mSidekickActive) { Trace.traceBegin(Trace.TRACE_TAG_POWER, "SidekickInternal#startDisplayControl"); try { mSidekickActive = mSidekickInternal.startDisplayControl(state); } finally { Trace.traceEnd(Trace.TRACE_TAG_POWER); } } } private void setDisplayBrightness(int brightness) { Trace.traceBegin(Trace.TRACE_TAG_POWER, "setDisplayBrightness("+ "id=" + displayId + ", brightness=" + brightness + ")"); try { mBacklight.setBrightness(brightness); Trace.traceCounter(Trace.TRACE_TAG_POWER, "ScreenBrightness", brightness); } finally { Trace.traceEnd(Trace.TRACE_TAG_POWER); } } }; } return null; }/frameworks/base/services/core/java/com/android/server/lights/LightsService.java@Overridepublic void setBrightness(int brightness, int brightnessMode) { synchronized (this) { // LOW_PERSISTENCE cannot be manually set if (brightnessMode == BRIGHTNESS_MODE_LOW_PERSISTENCE) { return; } int color = brightness & 0x000000ff; color = 0xff000000 | (color << 16) | (color << 8) | color; setLightLocked(color, LIGHT_FLASH_NONE, 0, 0, brightnessMode); } }private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) { if (shouldBeInLowPersistenceMode()) { brightnessMode = BRIGHTNESS_MODE_LOW_PERSISTENCE; } else if (brightnessMode == BRIGHTNESS_MODE_LOW_PERSISTENCE) { brightnessMode = mLastBrightnessMode; } if (!mInitialized || color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS || mBrightnessMode != brightnessMode) { mInitialized = true; mLastColor = mColor; mColor = color; mMode = mode; mOnMS = onMS; mOffMS = offMS; mBrightnessMode = brightnessMode; Trace.traceBegin(Trace.TRACE_TAG_POWER, "setLight(" + mId + ", 0x" + Integer.toHexString(color) + ")"); try { setLight_native(mId, color, mode, onMS, offMS, brightnessMode); } finally { Trace.traceEnd(Trace.TRACE_TAG_POWER); } } }static native void setLight_native(int light, int color, int mode, int onMS, int offMS, int brightnessMode);}/frameworks/base/services/core/jni/com_android_server_lights_LightsService.cppstatic void setLight_native( JNIEnv* /* env */, jobject /* clazz */, jint light, jint colorARGB, jint flashMode, jint onMS, jint offMS, jint brightnessMode) { if (!validate(light, flashMode, brightnessMode)) { return; } sp hal = LightHal::associate(); if (hal == nullptr) { return; } Type type = static_cast(light); LightState state = constructState( colorARGB, flashMode, onMS, offMS, brightnessMode); { android::base::Timer t;//将背光值传递到HAL层，设置到驱动文件中 Return ret = hal->setLight(type, state); processReturn(ret, type, state); if (t.duration() > 50ms) ALOGD("Excessive delay setting light"); }}
更多相关文章
- Android(安卓)Desigin Library
- android:windowSoftInputMode属性使用
- android笔记
- 设置Android(安卓)app背景图片(Android(安卓)studio)
- 让Android支持透明状态栏
- android:layout_gravity和android:gravity属性的区别
- Android样式基础--shape篇
- Android中的一些样式设置
- android中的文本框