在前面两部分已经对绘制windows与设置设备状态进行了详细讲解. 之后接着就该对亮度值进行设置, 实现亮屏动作了.

在DisplayPowerController中的animateScreenBrightness函数通过亮度渐变动画来将亮度设置到目标亮度.

[java] view plain copy
  1. // Brightness animation ramp rate in brightness units per second.
  2. private static final int BRIGHTNESS_RAMP_RATE_SLOW = 40;     //亮度渐变动画较慢的速率, 每秒变化40个亮度单位
  3. mBrightnessRampRateFast = resources.getInteger(
  4. com.android.internal.R.integer.config_brightness_ramp_rate_fast);   //从配置文件中获取较快的亮度速率
  5. // Animate the screen brightness when the screen is on or dozing.
  6. // Skip the animation when the screen is off or suspended.
  7. if (!mPendingScreenOff) {
  8. if (state == Display.STATE_ON || state == Display.STATE_DOZE) {
  9. animateScreenBrightness(brightness,      //当亮屏或doze状态时有亮度渐变动画
  10. slowChange ? BRIGHTNESS_RAMP_RATE_SLOW : mBrightnessRampRateFast);
  11. } else {
  12. animateScreenBrightness(brightness, 0);   //灭屏时没有亮度渐变动画,直接将亮度设置为0
  13. }
  14. }

在animateScreenBrightness函数中调用动画mScreenBrightnessRampAnimator对亮度值处理, 而mScreenBrightnessRampAnimator是在initialize()函数中进行初始化的, 在构造函数中将DisplayPowerState和DisplayPowerState.SCREEN_BRIGHTNESS传输过去.

[java] view plain copy
  1. private void initialize() {
  2. //....
  3. mScreenBrightnessRampAnimator = new RampAnimator<DisplayPowerState>(  //泛型为DisplayPowerState
  4. mPowerState, DisplayPowerState.SCREEN_BRIGHTNESS);
  5. mScreenBrightnessRampAnimator.setListener(mRampAnimatorListener);
  6. //...
  7. }
  8. private void animateScreenBrightness(int target, int rate) {
  9. if (DEBUG) {
  10. Slog.d(TAG, "Animating brightness: target=" + target +", rate=" + rate);
  11. }
  12. if (mScreenBrightnessRampAnimator.animateTo(target, rate)) {    //动画处理亮度值
  13. try {
  14. mBatteryStats.noteScreenBrightness(target);
  15. } catch (RemoteException ex) {
  16. // same process
  17. }
  18. }
  19. }

在RampAnimator的构造函数中将DisplayPowerState赋值给mObject, DisplayPowerState.SCREEN_BRIGHTNESS赋值给mProperty, 并且创建mChoreographer实例.

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

下面重点讲解animateTo函数.

[java] 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) {   //当第一次调用animateTo, 或者rate小于等于0时直接设置目标亮度.
  4. if (mFirstTime || target != mCurrentValue) {
  5. mFirstTime = false;   //之后就不是第一次调用该函数
  6. mRate = 0;              //设置mRate为0
  7. mTargetValue = target;   //设置目标亮度为target
  8. mCurrentValue = target;
  9. mProperty.setValue(mObject, target);   //调用DisplayPowerState.SCREEN_BRIGHTNESS设置亮度值
  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;    //重新设置mTargetValue
  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. }

在postAnimationCallback中调用Choreographer的postCallback函数处理, 调用完成后回调回mAnimationCallback的run函数

[java] view plain copy
  1. private void postAnimationCallback() {
  2. mChoreographer.postCallback(Choreographer.CALLBACK_ANIMATION, mAnimationCallback, null);
  3. }
  4. private final Runnable mAnimationCallback = new Runnable() {
  5. @Override // Choreographer callback
  6. public void run() {
  7. final long frameTimeNanos = mChoreographer.getFrameTimeNanos();
  8. final float timeDelta = (frameTimeNanos - mLastFrameTimeNanos)
  9. * 0.000000001f;
  10. mLastFrameTimeNanos = frameTimeNanos;  //记录最后一次的frameTimeNanos
  11. // Advance the animated value towards the target at the specified rate
  12. // and clamp to the target. This gives us the new current value but
  13. // we keep the animated value around to allow for fractional increments
  14. // towards the target.
  15. final float scale = ValueAnimator.getDurationScale();
  16. if (scale == 0) {
  17. // Animation off.
  18. mAnimatedValue = mTargetValue;   //让scale为0时, 表示动画停止了, 将mAnimatedValue设置为目标亮度
  19. } else {
  20. final float amount = timeDelta * mRate / scale;  //计算每一次需要变化的亮度值
  21. if (mTargetValue > mCurrentValue) {
  22. mAnimatedValue = Math.min(mAnimatedValue + amount, mTargetValue);  //亮屏,每次增加亮度amount,不超过目标亮度
  23. } else {
  24. mAnimatedValue = Math.max(mAnimatedValue - amount, mTargetValue); //暗屏, 每次减少amount个亮度, 不超过目标亮度
  25. }
  26. }
  27. final int oldCurrentValue = mCurrentValue;
  28. mCurrentValue = Math.round(mAnimatedValue);  //获取当前要达到的亮度值
  29. if (oldCurrentValue != mCurrentValue) {
  30. mProperty.setValue(mObject, mCurrentValue);  //调用DisplayPowerState.SCREEN_BRIGHTNESS设置亮度值
  31. }
  32. if (mTargetValue != mCurrentValue) {
  33. postAnimationCallback();   //如果还没有达到目标亮度,就会继续调用postAnimationCallback循环设置亮度值
  34. } else {
  35. mAnimating = false;
  36. if (mListener != null) {
  37. mListener.onAnimationEnd();  //否则,亮度动画结束
  38. }
  39. }
  40. }
  41. };

DisplayPowerState.SCREEN_BRIGHTNESS的setValue函数是在DisplayPowerState中实现的.

[java] 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);  //调用DisplayPowerState的setScreenBrightness函数,设置亮度值
  6. }
  7. @Override
  8. public Integer get(DisplayPowerState object) {
  9. return object.getScreenBrightness();
  10. }
  11. };
  12. public void setScreenBrightness(int brightness) {
  13. if (mScreenBrightness != brightness) {
  14. if (DEBUG) {
  15. Slog.d(TAG, "setScreenBrightness: brightness=" + brightness);
  16. }
  17. mScreenBrightness = brightness;  //设置全局的亮度值
  18. if (mScreenState != Display.STATE_OFF) {
  19. mScreenReady = false;
  20. scheduleScreenUpdate();   //如果不是灭屏状态,更新屏幕状态
  21. }
  22. }
  23. }

scheduleScreenUpdate函数最终通过Handler发送mScreenUpdateRunnable对象来更新亮度值. 从run函数中可以看出只有当mColorFadeLevel > 0f时才能给brightness设置亮度值, 所以说当windows没有绘制完成时就算mScreenBrightness有值不为0, 但是brightness仍然为0不能点亮屏幕.

[java] 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. };

之后的流程就与设置设置状态的流程相同了, 调用DisplayManagerService中DisplayBlanker的requestDisplayState函数.

[java] 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. };
[java] 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;  //灭屏设置屏幕亮度为0
  7. } else if (brightness < 0) {
  8. brightness = PowerManager.BRIGHTNESS_DEFAULT;  //屏幕亮度小于0,设置为默认亮度
  9. } else if (brightness > PowerManager.BRIGHTNESS_ON) {
  10. brightness = PowerManager.BRIGHTNESS_ON;    //屏幕亮度大于255设置最大亮度值255
  11. }
  12. synchronized (mTempDisplayStateWorkQueue) {
  13. try {
  14. // Update the display state within the lock.
  15. // Note that we do not need to schedule traversals here although it
  16. // may happen as a side-effect of displays changing state.
  17. synchronized (mSyncRoot) {
  18. if (mGlobalDisplayState == state
  19. && mGlobalDisplayBrightness == brightness) {
  20. return; // no change     亮度与状态都没有改变就return
  21. }
  22. Trace.traceBegin(Trace.TRACE_TAG_POWER, "requestGlobalDisplayState("
  23. + Display.stateToString(state)
  24. + ", brightness=" + brightness + ")");
  25. mGlobalDisplayState = state;
  26. mGlobalDisplayBrightness = brightness;
  27. applyGlobalDisplayStateLocked(mTempDisplayStateWorkQueue);   //应用全局状态
  28. }
  29. // Setting the display power state can take hundreds of milliseconds
  30. // to complete so we defer the most expensive part of the work until
  31. // after we have exited the critical section to avoid blocking other
  32. // threads for a long time.
  33. for (int i = 0; i < mTempDisplayStateWorkQueue.size(); i++) {
  34. mTempDisplayStateWorkQueue.get(i).run();  //运行mTempDisplayStateWorkQueue队列中的runnable
  35. }
  36. Trace.traceEnd(Trace.TRACE_TAG_POWER);
  37. } finally {
  38. mTempDisplayStateWorkQueue.clear();
  39. }
  40. }
  41. }

在applyGlobalDisplayStateLocked函数中获取所有的devices, 调用对应设备的requestDisplayStateLocked函数更新请求状态. 启动devices为LocalDisplayAdapter, 就会调用到该类的requestDisplayStateLocked获得runnable.

[java] view plain copy
  1. private void applyGlobalDisplayStateLocked(List<Runnable> workQueue) {
  2. final int count = mDisplayDevices.size();
  3. for (int i = 0; i < count; i++) {   //遍历devices
  4. DisplayDevice device = mDisplayDevices.get(i);
  5. Runnable runnable = updateDisplayStateLocked(device);  //获得devices中的runnable
  6. if (runnable != null) {
  7. workQueue.add(runnable);  //将runnable加入workQueue队列, 即mTempDisplayStateWorkQueue队列
  8. }
  9. }
  10. }
  11. private Runnable updateDisplayStateLocked(DisplayDevice device) {
  12. // Blank or unblank the display immediately to match the state requested
  13. // by the display power controller (if known).
  14. DisplayDeviceInfo info = device.getDisplayDeviceInfoLocked();  //获取devices信息
  15. if ((info.flags & DisplayDeviceInfo.FLAG_NEVER_BLANK) == 0) {
  16. return device.requestDisplayStateLocked(mGlobalDisplayState, mGlobalDisplayBrightness); //调用requestDisplayStateLocked函数
  17. }
  18. return null;
  19. }

在requestDisplayStateLocked中主要的任务就是创建一个runnable返回到DisplayManagerService中,并且等待回调run函数.

[java] view plain copy
  1. @Override
  2. public Runnable requestDisplayStateLocked(final int state, final int brightness) {
  3. // Assume that the brightness is off if the display is being turned off.
  4. assert state != Display.STATE_OFF || brightness == PowerManager.BRIGHTNESS_OFF;
  5. final boolean stateChanged = (mState != state);  //状态是否改变
  6. final boolean brightnessChanged = (mBrightness != brightness) && mBacklight != null;  //亮度值是否改变
  7. if (stateChanged || brightnessChanged) {  //如果亮度值或者亮度状态发生改变就重新设置对应值
  8. final int displayId = mBuiltInDisplayId;
  9. final IBinder token = getDisplayTokenLocked();
  10. final int oldState = mState;
  11. if (stateChanged) {   //设置亮度时.状态已经设置好,无变化
  12. mState = state;
  13. updateDeviceInfoLocked();
  14. }
  15. if (brightnessChanged) {
  16. mBrightness = brightness;  //设置mBrightness
  17. }
  18. // Defer actually setting the display state until after we have exited
  19. // the critical section since it can take hundreds of milliseconds
  20. // to complete.
  21. return new Runnable() {    //新建一个runnable返回
  22. @Override
  23. public void run() {  //在DisplayManagerService中调用run函数
  24. // Exit a suspended state before making any changes.
  25. int currentState = oldState;
  26. if (Display.isSuspendedState(oldState)    //判断设置是否还是在suspend状态
  27. || oldState == Display.STATE_UNKNOWN) {
  28. if (!Display.isSuspendedState(state)) {
  29. setDisplayState(state);
  30. currentState = state;
  31. } else if (state == Display.STATE_DOZE_SUSPEND
  32. || oldState == Display.STATE_DOZE_SUSPEND) {
  33. setDisplayState(Display.STATE_DOZE);
  34. currentState = Display.STATE_DOZE;
  35. } else {
  36. return; // old state and new state is off
  37. }
  38. }
  39. // Apply brightness changes given that we are in a non-suspended state.
  40. if (brightnessChanged) {
  41. if (isPowerDebug()) {
  42. Slog.d(TAG, "set display brightness=" + brightness);
  43. }
  44. setDisplayBrightness(brightness);    //设置屏幕亮度
  45. }
  46. // Enter the final desired state, possibly suspended.
  47. if (state != currentState) {
  48. if(isPowerDebug()) {
  49. Slog.d(TAG, "set display state=" + state);
  50. }
  51. setDisplayState(state);
  52. }
  53. }
[java] view plain copy
  1. private void setDisplayBrightness(int brightness) {
  2. if (DEBUG) {
  3. Slog.d(TAG, "setDisplayBrightness("
  4. + "id=" + displayId + ", brightness=" + brightness + ")");
  5. }
  6. Trace.traceBegin(Trace.TRACE_TAG_POWER, "setDisplayBrightness("
  7. + "id=" + displayId + ", brightness=" + brightness + ")");
  8. try {
  9. mBacklight.setBrightness(brightness);   //调用LightService设置亮度
  10. } finally {
  11. Trace.traceEnd(Trace.TRACE_TAG_POWER);
  12. }
  13. }
  14. };
  15. }
  16. return null;
  17. }
[java] view plain copy
  1. @Override
  2. public void setBrightness(int brightness) {
  3. setBrightness(brightness, BRIGHTNESS_MODE_USER);   //亮度模式默认为BRIGHTNESS_MODE_USER
  4. }
  5. @Override
  6. public void setBrightness(int brightness, int brightnessMode) {
  7. synchronized (this) {
  8. int color = brightness & 0x000000ff;
  9. color = 0xff000000 | (color << 16) | (color << 8) | color;   //设置光颜色
  10. setLightLocked(color, LIGHT_FLASH_NONE, 0, 0, brightnessMode);
  11. }
  12. }
  13. private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) {
  14. if (!LightsUtilsFactory.getInstance().isBatteryOpenWhenNotificationCome(mId, color)){
  15. if (!mLocked && (color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS ||
  16. mBrightnessMode != brightnessMode)) {
  17. if (DEBUG || isDebugNotifyLight()) Slog.v(TAG, "setLight #" + mId + ": color=#"
  18. + Integer.toHexString(color) + ": brightnessMode=" + brightnessMode);
  19. mLastColor = mColor;
  20. mColor = color;
  21. mMode = mode;
  22. mOnMS = onMS;
  23. mOffMS = offMS;
  24. mLastBrightnessMode = mBrightnessMode;
  25. mBrightnessMode = brightnessMode;
  26. Trace.traceBegin(Trace.TRACE_TAG_POWER, "setLight(" + mId + ", 0x"
  27. + Integer.toHexString(color) + ")");
  28. try {
  29. setLight_native(mNativePointer, mId, color, mode, onMS, offMS, brightnessMode);  //调用jni层设置亮度
  30. } finally {
  31. Trace.traceEnd(Trace.TRACE_TAG_POWER);
  32. }
  33. }
  34. }
  35. }

通过JNI调用com_android_server_lights_LightsService.cpp的setLight_native函数

[java] view plain copy
  1. static void setLight_native(JNIEnv* /* env */, jobject /* clazz */, jlong ptr,
  2. jint light, jint colorARGB, jint flashMode, jint onMS, jint offMS, jint brightnessMode)
  3. {
  4. Devices* devices = (Devices*)ptr;
  5. light_state_t state;
  6. if (light < 0 || light >= LIGHT_COUNT || devices->lights[light] == NULL) {
  7. return ;
  8. }
  9. uint32_t version = devices->lights[light]->common.version;
  10. memset(&state, 0, sizeof(light_state_t));
  11. if (brightnessMode == BRIGHTNESS_MODE_LOW_PERSISTENCE) {
  12. if (light != LIGHT_INDEX_BACKLIGHT) {
  13. ALOGE("Cannot set low-persistence mode for non-backlight device.");
  14. return;
  15. }
  16. if (version < LIGHTS_DEVICE_API_VERSION_2_0) {
  17. // HAL impl has not been upgraded to support this.
  18. return;
  19. }
  20. } else {
  21. // Only set non-brightness settings when not in low-persistence mode
  22. state.color = colorARGB;
  23. state.flashMode = flashMode;
  24. state.flashOnMS = onMS;
  25. state.flashOffMS = offMS;
  26. }
  27. state.brightnessMode = brightnessMode;
  28. {
  29. ALOGD_IF_SLOW(50, "Excessive delay setting light");   //当设置亮度耗时大于50ms,就会输出该行log.
  30. devices->lights[light]->set_light(devices->lights[light], &state);
  31. }
  32. }

之后调用BSP向亮度节点写入亮度值. 从而点亮屏幕.

灭屏流程分析

灭屏总览

在点击power键灭屏过程中，主要流程就是input对按键事件的传输，传送到上层处理。在PhoneWindowManager中判断是否为灭屏事件, 之后就是在power中进行对亮屏状态的处理，计算一系列的数值，并且与AMS，WMS等模块进行交互，最后调用底层LCD进行最终的设备状态与亮度的设置。灭屏流程与亮屏流程有很多共同流程，在这里只讲解灭屏的独特流程。
                            
当wakefulness状态发生改变，AMS收到通知。如果亮屏操作，AMS就会通过函数comeOutOfSleepIfNeedLocked调用到ActivityStackSupervisor中，将sleep超时消息移除，如果抓的有partial锁，就将其释放，最后将在栈顶的activity显示出来。
当亮屏时通过InputManagerService将当前屏幕状态传入JNI中进行记录，当再次发生power键事件可以方便确认该事件是需要亮屏还是灭屏。
灭屏时首先在Notifier中通过PhoneWindowManager来通知keyguard系统开始灭屏。
灭屏动画
在PowerManagerService中获得屏幕的请求状态为OFF，即设置state为Display.STATE_OFF，在这里将performScreenOffTransition为true。

[java] view plain copy
  1. case DisplayPowerRequest.POLICY_OFF:
  2. state = Display.STATE_OFF;
  3. performScreenOffTransition = true;
  4. break;

调用animateScreenStateChange进行处理屏幕状态。

[java] view plain copy
  1. // Animate the screen state change unless already animating.
  2. // The transition may be deferred, so after this point we will use the
  3. // actual state instead of the desired one.
  4. animateScreenStateChange(state, performScreenOffTransition);
  5. state = mPowerState.getScreenState();

如果目标亮度不为STATE_ON，STATE_DOZE，STATE_DOZE_SUSPEND屏幕就要去睡眠了。

[java] view plain copy
  1. // Want screen off.
  2. mPendingScreenOff = true;
  3. if (mPowerState.getColorFadeLevel() == 0.0f) {
  4. // Turn the screen off.
  5. // A black surface is already hiding the contents of the screen.
  6. setScreenState(Display.STATE_OFF);
  7. mPendingScreenOff = false;
  8. mPowerState.dismissColorFadeResources();
  9. } else if (performScreenOffTransition
  10. && mPowerState.prepareColorFade(mContext,
  11. mColorFadeFadesConfig ?
  12. ColorFade.MODE_FADE : ColorFade.MODE_COOL_DOWN)
  13. && mPowerState.getScreenState() != Display.STATE_OFF) {
  14. // Perform the screen off animation.
  15. mColorFadeOffAnimator.start();
  16. } else {
  17. // Skip the screen off animation and add a black surface to hide the
  18. // contents of the screen.
  19. mColorFadeOffAnimator.end();
  20. }

在这里就要判断ColorFadeLevel是不是0.0，由于亮屏时将ColorFadeLevel设置为1.0所以走else语句，如果performScreenOffTransition为true并且将ColorFade准备好了就开始灭屏动画将ColorFadeLevel从1.0渐变为0.0。但是前面知道将performScreenOffTransition设置为了false，所以就没有了灭屏动画，直接将ColorFadeLevel设置为0.0。之后就调用setScreenState设置状态。
发送灭屏广播
                              

power是通过WindowManagerPolicy与PhoneWindowManager进行交互，当屏幕在finishedGoingToSleep时需要通知window进行更新手势监听，更新方向监听，更新锁屏超时时间。之后发送灭屏广播通知关心灭屏事件的模块。

到此为止亮灭屏流程讲解完毕.

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/fu_kevin0606/article/details/54427641

Android7.0 PowerManagerService亮灭屏分析(三)相关推荐

  1. Android 系统（42）---Android7.0 PowerManagerService亮灭屏分析(三)

    Android7.0 PowerManagerService亮灭屏分析(三) 在前面两部分已经对绘制windows与设置设备状态进行了详细讲解. 之后接着就该对亮度值进行设置, 实现亮屏动作了. 在D ...

  2. Android 系统（40）--Android7.0 PowerManagerService亮灭屏分析(一)

    Android7.0 PowerManagerService亮灭屏分析(一) 可以导致手机亮灭屏的因素有多种,而在本文中主要讲解按power键亮灭屏过程以及来电亮屏.在亮灭屏过程power中主要的实现 ...

  3. Android 系统（41）---Android7.0 PowerManagerService亮灭屏分析(二)

    Android7.0 PowerManagerService亮灭屏分析(二) 3029 在PowerManagerService中对各种状态进行判断后,将其数值封装进DisplayPowerReque ...

  4. Android7.0 PowerManagerService亮灭屏分析(一)

    绪论 可以导致手机亮灭屏的因素有多种,而在本文中主要讲解按power键亮灭屏过程以及来电亮屏.在亮灭屏过程power中主要的实现类与功能如下所述: PowerManagerService.java:以 ...

  5. Android7.0 PowerManagerService亮灭屏分析(二)

    在PowerManagerService中对各种状态进行判断后,将其数值封装进DisplayPowerRequest中传入DisplayPowerController中进一步处理.在亮屏过程中Disp ...

  6. Android 8.0 手机亮灭屏

    本文主要跟踪分析通过按松power键来唤醒,熄灭屏幕的逻辑.下面是一些相关类的介绍 PowerManagerService.java:简称PMS,负责Andorid系统中电源管理方面的工作.作为系统核 ...

  7. Android7.1 Kyguard界面灭屏时间分析

    概述 在Android系统中,当用户没有操作手机一段时间后,系统会自动灭屏进入休眠状态,从而降低手机功耗.一般情况下系统灭屏的时间由用户在手机设置中自己进行定义是10s,30s还是1min等等.但是如 ...

  8. Android7.0 PowerManagerService 之亮灭屏（二） PMS 电源状态管理updatePowerStateLocked（）...

    本篇注意接着上篇[Android7.0 PowerManagerService 之亮灭屏(一)]继续分析量灭屏的流程,这篇主要分析PMS的状态计算和更新流程,也是PMS中最为重要和复杂的一部分电源状态 ...

  9. Android 知识点 109 —— Android7.0 PowerManagerService 之亮灭屏

    原文地址: https://www.cnblogs.com/dyufei/p/8017604.html 写的太好了,粘过来! 本篇从按下power按键后,按键事件从InputManagerServic ...

最新文章

  1. 如何上传html验证文件大小,html5 实现客户端验证上传文件的大小(简单实例)
  2. 怎么改变光标Cursor（5种方法）
  3. 你有没有靠谱的基因？一个人靠不靠谱，其实就看这三点：“凡事有交代，件件有着落，事事有回音。”...
  4. 公开最近开发的OA的框架图
  5. Hibernate框架概述SSH框架工作原理以及流程
  6. html5shiv.js分析-读源码之javascript系列
  7. lsass.exe和smss.exe病毒专杀工具——即磁碟机病毒专杀工具（转载）
  8. 2017报计算机热不热,【2017年10月份热吗】2017年10月份热不热_亲亲宝贝网
  9. Unity-ProBuilder
  10. 软工大牛Collin McMillan及其顶会论文解读
  11. 【我的区块链之路】- 谈一谈IPFS原理及玩法
  12. SylixOS 系统工作队列
  13. 【Python】Python进程池multiprocessing.Pool八个函数对比：apply、apply_async、map、map_async、imap、starmap...
  14. div默认外边距是多少_CSS外边距
  15. 记录每天背的单词，准备考研。（3月15日）
  16. Android实现网络下载二（多任务下载--支持断点续传）
  17. Polkadot学习概念总结
  18. EfficientNet（ICML 2019）原理与代码解析
  19. 基于Robotics toolbox的定制/非标机构的运动学正逆解
  20. 英属哥伦比亚大学计算机科学,英属哥伦比亚大学_University of British Columbia_学校介绍_专业设置...

热门文章

  1. Eclipse 3.7 3.x SWT/Jface 开发环境搭建
  2. SQL Server 数据库安全
  3. [Bug] .NET 2.0 的Bug —— ComboBox中不能添加Component.
  4. Python学习笔记：常用内建模块6 (urllib)
  5. 工具 左侧服务列表_协作办公时代，在线编辑文档工具，安排！
  6. 科大星云诗社动态20220104
  7. 吴恩达《Machine Learning》精炼笔记 10：异常检测
  8. zabbix mysql 查询,Zabbix4.4配置MySQL监控；
  9. python列表中字典排序_python中字典排序，列表中的字典排序
  10. VTK修炼之道24：图像基本操作_单颜色通道图像合成彩色