[cpp] view plain copy

1. public void setScreenState(int state) {
2. if (mScreenState != state) {
3. if (DEBUG) {
4. Slog.d(TAG, "setScreenState: state=" + state);
5. }
6. mScreenState = state;
7. mScreenReady = false;
8. scheduleScreenUpdate();
9. }
10. }



[cpp] view plain copy

1. private final Runnable mScreenUpdateRunnable = new Runnable() {
2. @Override
3. public void run() {
4. mScreenUpdatePending = false;
5. int brightness = mScreenState != Display.STATE_OFF
6. && mColorFadeLevel > 0f ? mScreenBrightness : 0;
7. if (mPhotonicModulator.setState(mScreenState, brightness)) {
8. if (DEBUG) {
9. Slog.d(TAG, "Screen ready");
10. }
11. mScreenReady = true;
12. invokeCleanListenerIfNeeded();
13. } else {
14. if (DEBUG) {
15. Slog.d(TAG, "Screen not ready");
16. }
17. }
18. }
19. };

[cpp] view plain copy

1. public boolean setState(int state, int backlight) {
2. synchronized (mLock) {
3. boolean stateChanged = state != mPendingState;
4. boolean backlightChanged = backlight != mPendingBacklight;
5. if (stateChanged || backlightChanged) {
6. if (DEBUG) {
7. Slog.d(TAG, "Requesting new screen state: state="
8. + Display.stateToString(state) + ", backlight=" + backlight);
9. }
10. mPendingState = state;
11. mPendingBacklight = backlight;
12. boolean changeInProgress = mStateChangeInProgress || mBacklightChangeInProgress;
13. mStateChangeInProgress = stateChanged;
14. mBacklightChangeInProgress = backlightChanged;
15. if (!changeInProgress) {
16. Slog.d(TAG,"notify set backlight thread run");
17. mLock.notifyAll();
18. }
19. }
20. return !mStateChangeInProgress;
21. }
22. }

[cpp] view plain copy

1. @Override
2. public void run() {
3. for (;;) {
4. // Get pending change.
5. final int state;
6. final boolean stateChanged;
7. final int backlight;
8. final boolean backlightChanged;
9. synchronized (mLock) {
10. state = mPendingState;
11. stateChanged = (state != mActualState);
12. backlight = mPendingBacklight;
13. backlightChanged = (backlight != mActualBacklight);
14. if (!stateChanged) {
15. // State changed applied, notify outer class.
16. postScreenUpdateThreadSafe();
17. mStateChangeInProgress = false;
18. }
19. if (!backlightChanged) {
20. mBacklightChangeInProgress = false;
21. }
22. if (!stateChanged && !backlightChanged) {
23. try {
24. mLock.wait();
25. } catch (InterruptedException ex) { }
26. continue;
27. }
28. mActualState = state;
29. mActualBacklight = backlight;
30. }
31. // Apply pending change.
32. if (true) {
33. Slog.d(TAG, "Updating screen state: state="
34. + Display.stateToString(state) + ", backlight=" + backlight);
35. }
36. mBlanker.requestDisplayState(state, backlight);
37. Slog.d(TAG, "kangchen Updating screen state: state=");
38. }
39. }

[cpp] view plain copy

1. DisplayBlanker blanker = new DisplayBlanker() {
2. @Override
3. public void requestDisplayState(int state, int brightness) {
4. // The order of operations is important for legacy reasons.
5. if (state == Display.STATE_OFF) {
6. requestGlobalDisplayStateInternal(state, brightness);
7. }
8. callbacks.onDisplayStateChange(state);
9. if (state != Display.STATE_OFF) {
10. requestGlobalDisplayStateInternal(state, brightness);
11. }
12. }
13. };

[cpp] view plain copy

1. private void requestGlobalDisplayStateInternal(int state, int brightness) {
2. if (state == Display.STATE_UNKNOWN) {
3. state = Display.STATE_ON;
4. }
5. if (state == Display.STATE_OFF) {
6. brightness = PowerManager.BRIGHTNESS_OFF;
7. } else if (brightness < 0) {
8. brightness = PowerManager.BRIGHTNESS_DEFAULT;
9. } else if (brightness > PowerManager.BRIGHTNESS_ON) {
10. brightness = PowerManager.BRIGHTNESS_ON;
11. }
12. synchronized (mTempDisplayStateWorkQueue) {
13. try {
14. synchronized (mSyncRoot) {
15. if (mGlobalDisplayState == state
16. && mGlobalDisplayBrightness == brightness) {
17. return; // no change
18. }
19. mGlobalDisplayState = state;
20. mGlobalDisplayBrightness = brightness;
21. applyGlobalDisplayStateLocked(mTempDisplayStateWorkQueue);
22. }
23. // Setting the display power state can take hundreds of milliseconds
24. // to complete so we defer the most expensive part of the work until
25. // after we have exited the critical section to avoid blocking other
26. // threads for a long time.
27. for (int i = 0; i < mTempDisplayStateWorkQueue.size(); i++) {
28. mTempDisplayStateWorkQueue.get(i).run();//设置亮度、状态到设备
29. }
30. } finally {
31. mTempDisplayStateWorkQueue.clear();
32. }
33. }
34. }

[cpp] view plain copy

1. private void applyGlobalDisplayStateLocked(List<Runnable> workQueue) {
2. final int count = mDisplayDevices.size();
3. for (int i = 0; i < count; i++) {
4. DisplayDevice device = mDisplayDevices.get(i);
5. Runnable runnable = updateDisplayStateLocked(device);
6. if (runnable != null) {
7. workQueue.add(runnable);
8. }
9. }
10. }

[cpp] view plain copy

1. private Runnable updateDisplayStateLocked(DisplayDevice device) {
2. // Blank or unblank the display immediately to match the state requested
3. // by the display power controller (if known).
4. DisplayDeviceInfo info = device.getDisplayDeviceInfoLocked();
5. if ((info.flags & DisplayDeviceInfo.FLAG_NEVER_BLANK) == 0) {
6. return device.requestDisplayStateLocked(mGlobalDisplayState, mGlobalDisplayBrightness);
7. }
8. return null;
9. }

[cpp] view plain copy

1. public Runnable requestDisplayStateLocked(final int state, final int brightness) {
2. // Assume that the brightness is off if the display is being turned off.
3. assert state != Display.STATE_OFF || brightness == PowerManager.BRIGHTNESS_OFF;
4. final boolean stateChanged = (mState != state);
5. final boolean brightnessChanged = (mBrightness != brightness) && mBacklight != null;
6. if (stateChanged || brightnessChanged) {
7. final int displayId = mBuiltInDisplayId;
8. final IBinder token = getDisplayTokenLocked();
9. final int oldState = mState;
10. if (stateChanged) {
11. mState = state;//保存state
12. updateDeviceInfoLocked();
13. }
14. if (brightnessChanged) {
15. mBrightness = brightness;//保存brightness
16. }
17. // Defer actually setting the display state until after we have exited
18. // the critical section since it can take hundreds of milliseconds
19. // to complete.
20. return new Runnable() {//返回Runnable
21. @Override
22. public void run() {
23. // Exit a suspended state before making any changes.
24. int currentState = oldState;
25. if (Display.isSuspendedState(oldState)
26. || oldState == Display.STATE_UNKNOWN) {
27. if (!Display.isSuspendedState(state)) {
28. setDisplayState(state);
29. currentState = state;
30. } else if (state == Display.STATE_DOZE_SUSPEND
31. || oldState == Display.STATE_DOZE_SUSPEND) {
32. setDisplayState(Display.STATE_DOZE);
33. currentState = Display.STATE_DOZE;
34. } else {
35. return; // old state and new state is off
36. }
37. }
38. // Apply brightness changes given that we are in a non-suspended state.
39. if (brightnessChanged) {
40. Slog.d(TAG, "setDisplayBrightnessbrightness1=" + brightness);
41. setDisplayBrightness(brightness);
42. Slog.d(TAG, "setDisplayBrightnessbrightness2=" + brightness);
43. }
44. // Enter the final desired state, possibly suspended.
45. if (state != currentState) {
46. setDisplayState(state);
47. }
48. }
49. private void setDisplayState(int state) {
50. if (DEBUG) {
51. Slog.d(TAG, "setDisplayState("
52. + "id=" + displayId
53. + ", state=" + Display.stateToString(state) + ")");
54. }
55. try {
56. final int mode = getPowerModeForState(state);
57. SurfaceControl.setDisplayPowerMode(token, mode);//到SurfaceControl设置状态
58. } finally {
59. Trace.traceEnd(Trace.TRACE_TAG_POWER);
60. }
61. }
62. private void setDisplayBrightness(int brightness) {
63. try {
64. mBacklight.setBrightness(brightness);//设置亮度
65. } finally {
66. Trace.traceEnd(Trace.TRACE_TAG_POWER);
67. }
68. }
69. };
70. }
71. return null;
72. }

[cpp] view plain copy

1. if (!mPendingScreenOff) {
2. if (state == Display.STATE_ON || state == Display.STATE_DOZE) {
3. animateScreenBrightness(brightness,
4. slowChange ? BRIGHTNESS_RAMP_RATE_SLOW : BRIGHTNESS_RAMP_RATE_FAST);
5. } else {
6. animateScreenBrightness(brightness, 0);
7. }
8. }

[cpp] view plain copy

1. private void animateScreenBrightness(int target, int rate) {
2. if (mScreenBrightnessRampAnimator.animateTo(target, rate)) {
3. try {
4. mBatteryStats.noteScreenBrightness(target);
5. } catch (RemoteException ex) {
6. // same process
7. }
8. }
9. }

[cpp] view plain copy

1. mScreenBrightnessRampAnimator = new RampAnimator<DisplayPowerState>(
2. mPowerState, DisplayPowerState.SCREEN_BRIGHTNESS);

[cpp] view plain copy

1. public static final IntProperty<DisplayPowerState> SCREEN_BRIGHTNESS =
2. new IntProperty<DisplayPowerState>("screenBrightness") {
3. @Override
4. public void setValue(DisplayPowerState object, int value) {
5. object.setScreenBrightness(value);
6. }
7. @Override
8. public Integer get(DisplayPowerState object) {
9. return object.getScreenBrightness();
10. }
11. };

[cpp] view plain copy

1. public RampAnimator(T object, IntProperty<T> property) {
2. mObject = object;
3. mProperty = property;
4. mChoreographer = Choreographer.getInstance();
5. }

[cpp] view plain copy

1. public boolean animateTo(int target, int rate) {
2. // Immediately jump to the target the first time.
3. if (mFirstTime || rate <= 0) {
4. if (mFirstTime || target != mCurrentValue) {
5. mFirstTime = false;
6. mRate = 0;
7. mTargetValue = target;
8. mCurrentValue = target;
9. mProperty.setValue(mObject, target);//设置值
10. if (mAnimating) {
11. mAnimating = false;
12. cancelAnimationCallback();
13. }
14. if (mListener != null) {
15. mListener.onAnimationEnd();
16. }
17. return true;
18. }
19. return false;
20. }
21. // Adjust the rate based on the closest target.
22. // If a faster rate is specified, then use the new rate so that we converge
23. // more rapidly based on the new request.
24. // If a slower rate is specified, then use the new rate only if the current
25. // value is somewhere in between the new and the old target meaning that
26. // we will be ramping in a different direction to get there.
27. // Otherwise, continue at the previous rate.
28. if (!mAnimating
29. || rate > mRate
30. || (target <= mCurrentValue && mCurrentValue <= mTargetValue)
31. || (mTargetValue <= mCurrentValue && mCurrentValue <= target)) {
32. mRate = rate;
33. }
34. final boolean changed = (mTargetValue != target);
35. mTargetValue = target;
36. // Start animating.
37. if (!mAnimating && target != mCurrentValue) {
38. mAnimating = true;
39. mAnimatedValue = mCurrentValue;
40. mLastFrameTimeNanos = System.nanoTime();
41. postAnimationCallback();
42. }
43. return changed;
44. }

[cpp] view plain copy

1. private void postAnimationCallback() {
2. mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, mAnimationCallback, null);
3. }

[cpp] view plain copy

1. private final Runnable mAnimationCallback = new Runnable() {
2. @Override // Choreographer callback
3. public void run() {
4. final long frameTimeNanos = mChoreographer.getFrameTimeNanos();
5. final float timeDelta = (frameTimeNanos - mLastFrameTimeNanos)
6. * 0.000000001f;
7. mLastFrameTimeNanos = frameTimeNanos;
8. final float scale = ValueAnimator.getDurationScale();
9. if (scale == 0) {
10. // Animation off.
11. mAnimatedValue = mTargetValue;
12. } else {
13. final float amount = timeDelta * mRate / scale;
14. if (mTargetValue > mCurrentValue) {
15. mAnimatedValue = Math.min(mAnimatedValue + amount, mTargetValue);
16. } else {
17. mAnimatedValue = Math.max(mAnimatedValue - amount, mTargetValue);
18. }
19. }
20. final int oldCurrentValue = mCurrentValue;
21. mCurrentValue = Math.round(mAnimatedValue);
22. if (oldCurrentValue != mCurrentValue) {
23. mProperty.setValue(mObject, mCurrentValue);//设置到DisplayPowerState的setScreenBrightness函数中
24. }
25. if (mTargetValue != mCurrentValue) {//当前值还不是目标值，继续设置VSync回调
26. postAnimationCallback();
27. } else {
28. mAnimating = false;//否则动画标志置为false
29. if (mListener != null) {
30. mListener.onAnimationEnd();
31. }
32. }
33. }
34. }

[cpp] view plain copy

1. public void setScreenBrightness(int brightness) {
2. if (mScreenBrightness != brightness) {
3. mScreenBrightness = brightness;
4. if (mScreenState != Display.STATE_OFF) {
5. mScreenReady = false;
6. scheduleScreenUpdate();
7. }
8. }
9. }

[cpp] view plain copy

1. private final Runnable mScreenUpdateRunnable = new Runnable() {
2. @Override
3. public void run() {
4. mScreenUpdatePending = false;
5. int brightness = mScreenState != Display.STATE_OFF
6. && mColorFadeLevel > 0f ? mScreenBrightness : 0;
7. if (mPhotonicModulator.setState(mScreenState, brightness)) {
8. if (DEBUG) {
9. Slog.d(TAG, "Screen ready");
10. }
11. mScreenReady = true;
12. invokeCleanListenerIfNeeded();
13. } else {
14. if (DEBUG) {
15. Slog.d(TAG, "Screen not ready");
16. }
17. }
18. }
19. };