PowerManagerService中的核心方法（二）

最新推荐文章于 2024-12-09 21:30:12 发布

原创最新推荐文章于 2024-12-09 21:30:12 发布 · 241 阅读

0 ·

CC 4.0 BY-SA版权

源码分析专栏收录该内容

10 篇文章

订阅专栏

本文详细解析了设备电源状态更新的内部机制，包括唤醒锁状态、用户活动状态的更新逻辑，以及如何根据这些状态调整设备的显示亮度和休眠行为。

 变量：

private int mDirty;//一个位域，指示电源状态的哪些部分已更改并需要重新计算。

132      // Dirty bit: mWakeLocks changed
133      private static final int DIRTY_WAKE_LOCKS = 1 << 0;
134      // Dirty bit: mWakefulness changed
135      private static final int DIRTY_WAKEFULNESS = 1 << 1;
136      // Dirty bit: user activity was poked or may have timed out
137      private static final int DIRTY_USER_ACTIVITY = 1 << 2;
138      // Dirty bit: actual display power state was updated asynchronously
139      private static final int DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED = 1 << 3;
140      // Dirty bit: mBootCompleted changed
141      private static final int DIRTY_BOOT_COMPLETED = 1 << 4;
142      // Dirty bit: settings changed
143      private static final int DIRTY_SETTINGS = 1 << 5;
144      // Dirty bit: mIsPowered changed
145      private static final int DIRTY_IS_POWERED = 1 << 6;
146      // Dirty bit: mStayOn changed
147      private static final int DIRTY_STAY_ON = 1 << 7;
148      // Dirty bit: battery state changed
149      private static final int DIRTY_BATTERY_STATE = 1 << 8;
150      // Dirty bit: proximity state changed
151      private static final int DIRTY_PROXIMITY_POSITIVE = 1 << 9;
152      // Dirty bit: dock state changed
153      private static final int DIRTY_DOCK_STATE = 1 << 10;
154      // Dirty bit: brightness boost changed
155      private static final int DIRTY_SCREEN_BRIGHTNESS_BOOST = 1 << 11;
156      // Dirty bit: sQuiescent changed
157      private static final int DIRTY_QUIESCENT = 1 << 12;
158      // Dirty bit: VR Mode enabled changed
159      private static final int DIRTY_VR_MODE_CHANGED = 1 << 13;


private int mWakefulness;//指示设备是处于唤醒状态还是处于睡眠状态或两者之间的某处。

private int mWakeLockSummary;//一个位域，总结了所有活动唤醒锁的状态。

161      // Summarizes the state of all active wakelocks.
162      private static final int WAKE_LOCK_CPU = 1 << 0;
163      private static final int WAKE_LOCK_SCREEN_BRIGHT = 1 << 1;
164      private static final int WAKE_LOCK_SCREEN_DIM = 1 << 2;
165      private static final int WAKE_LOCK_BUTTON_BRIGHT = 1 << 3;
166      private static final int WAKE_LOCK_PROXIMITY_SCREEN_OFF = 1 << 4;
167      private static final int WAKE_LOCK_STAY_AWAKE = 1 << 5; // only set if already awake
168      private static final int WAKE_LOCK_DOZE = 1 << 6;
169      private static final int WAKE_LOCK_DRAW = 1 << 7;

用户活动状态：

171      // Summarizes the user activity state.
172      private static final int USER_ACTIVITY_SCREEN_BRIGHT = 1 << 0;
173      private static final int USER_ACTIVITY_SCREEN_DIM = 1 << 1;
174      private static final int USER_ACTIVITY_SCREEN_DREAM = 1 << 2;

updateWakeLockSummaryLocked()函数

更新mWakeLockSummary的值以汇总所有活动唤醒锁的状态。系统处于休眠状态时会忽略大多数唤醒锁定。

1791      /**
1792       * Updates the value of mWakeLockSummary to summarize the state of all active wake locks.
1793       * Note that most wake-locks are ignored when the system is asleep.
1794       *
1795       * This function must have no other side-effects.
1796       */
1797      @SuppressWarnings("deprecation")
1798      private void updateWakeLockSummaryLocked(int dirty) {
                   //当dirty最后两位中至少有一位是1的时候，即是DIRTY_WAKE_LOCKS和DIRTY_WAKEFULNESS 至少包含其中一种状态变化时，更新mWakeLockSummary 
1799          if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_WAKEFULNESS)) != 0) {
1800              mWakeLockSummary = 0;
1801  
1802              final int numProfiles = mProfilePowerState.size();
                  //将以前ProfilePowerState中的mWakeLockSummary清0
1803              for (int i = 0; i < numProfiles; i++) {
1804                  mProfilePowerState.valueAt(i).mWakeLockSummary = 0;
1805              }
1806  
1807              final int numWakeLocks = mWakeLocks.size();
1808              for (int i = 0; i < numWakeLocks; i++) {
1809                  final WakeLock wakeLock = mWakeLocks.get(i);
                      //通过唤醒锁得到其对应的状态，具体看上面mWakeLockSummary变量的解释及其各种状态的值；
1810                  final int wakeLockFlags = getWakeLockSummaryFlags(wakeLock);
1811                  mWakeLockSummary |= wakeLockFlags;//将mWakeLockSummary 置位为最新状态
1812                  for (int j = 0; j < numProfiles; j++) {
1813                      final ProfilePowerState profile = mProfilePowerState.valueAt(j);
1814                      if (wakeLockAffectsUser(wakeLock, profile.mUserId)) {
                              //同理将ProfilePowerState 中的mWakeLockSummary 置位为最新状态
1815                          profile.mWakeLockSummary |= wakeLockFlags;
1816                      }
1817                  }
1818              }
1819              //判断改锁需不需要忽略，
                  //当这个方法执行后，将未忽略的wakelocks类型都记录在mWakeLockSummary这个标志    位中。
                  //在平时分析处理不灭屏相关Bug时，通过该值可确定当前系统持有哪些类型的锁。
1820              mWakeLockSummary = adjustWakeLockSummaryLocked(mWakeLockSummary);
1821              for (int i = 0; i < numProfiles; i++) {
1822                  final ProfilePowerState profile = mProfilePowerState.valueAt(i);
1823                  profile.mWakeLockSummary = adjustWakeLockSummaryLocked(profile.mWakeLockSummary);
1824              }
1825  
1826              if (DEBUG_SPEW) {
1827                  Slog.d(TAG, "updateWakeLockSummaryLocked: mWakefulness="
1828                          + PowerManagerInternal.wakefulnessToString(mWakefulness)
1829                          + ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary));
1830              }
1831          }
1832      }

updateUserActivitySummaryLocked

更新mUserActivitySummary的值以汇总请求的用户系统的状态，例如屏幕应该是亮还是暗。系统处于睡眠状态时将忽略用户活动

该方法用来更新用户活动时间，当设备和用户有交互时，都会根据当前时间和休眠时长、Dim时长、所处状态而计算下次休眠的时间，从而完成用户活动超时时的操作。如由亮屏进入Dim的时长、Dim到灭屏的时长、亮屏到屏保的时长，就是在这里计算的。

1953      private void updateUserActivitySummaryLocked(long now, int dirty) {
1954          // Update the status of the user activity timeout timer.
1955          if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY
1956                  | DIRTY_WAKEFULNESS | DIRTY_SETTINGS)) != 0) {
1957              mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT);
1958  
1959              long nextTimeout = 0;
                  //系统处于睡眠状态时将忽略用户活动
1960              if (mWakefulness == WAKEFULNESS_AWAKE
1961                      || mWakefulness == WAKEFULNESS_DREAMING
1962                      || mWakefulness == WAKEFULNESS_DOZING) {
                      //系统完全进入休眠所需时间，该值为-1表示禁用此值，默认-1
1963                  final long sleepTimeout = getSleepTimeoutLocked();
                      //用户超时时间，既经过一段时间不活动进入休眠或屏保的时间，特殊情况外，该值为Settings中的休眠时长
1964                  final long screenOffTimeout = getScreenOffTimeoutLocked(sleepTimeout);
                      //Dim时长，即亮屏不操作，变暗多久休眠
1965                  final long screenDimDuration = getScreenDimDurationLocked(screenOffTimeout);
1966                  final boolean userInactiveOverride = mUserInactiveOverrideFromWindowManager;
1967                  final long nextProfileTimeout = getNextProfileTimeoutLocked(now);
1968  
1969                  mUserActivitySummary = 0;
1970                  if (mLastUserActivityTime >= mLastWakeTime) {
1971                      nextTimeout = mLastUserActivityTime
1972                              + screenOffTimeout - screenDimDuration;
1973                      if (now < nextTimeout) {
1974                          mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
1975                      } else {
1976                          nextTimeout = mLastUserActivityTime + screenOffTimeout;
1977                          if (now < nextTimeout) {
1978                              mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
1979                          }
1980                      }
1981                  }
1982                  if (mUserActivitySummary == 0
1983                          && mLastUserActivityTimeNoChangeLights >= mLastWakeTime) {
1984                      nextTimeout = mLastUserActivityTimeNoChangeLights + screenOffTimeout;
1985                      if (now < nextTimeout) {
1986                          if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT
1987                                  || mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_VR) {
1988                              mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
1989                          } else if (mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_DIM) {
1990                              mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
1991                          }
1992                      }
1993                  }
1994  
1995                  if (mUserActivitySummary == 0) {
1996                      if (sleepTimeout >= 0) {
1997                          final long anyUserActivity = Math.max(mLastUserActivityTime,
1998                                  mLastUserActivityTimeNoChangeLights);
1999                          if (anyUserActivity >= mLastWakeTime) {
2000                              nextTimeout = anyUserActivity + sleepTimeout;
2001                              if (now < nextTimeout) {
2002                                  mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;
2003                              }
2004                          }
2005                      } else {
2006                          mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;
2007                          nextTimeout = -1;
2008                      }
2009                  }
2010  
2011                  if (mUserActivitySummary != USER_ACTIVITY_SCREEN_DREAM && userInactiveOverride) {
2012                      if ((mUserActivitySummary &
2013                              (USER_ACTIVITY_SCREEN_BRIGHT | USER_ACTIVITY_SCREEN_DIM)) != 0) {
2014                          // Device is being kept awake by recent user activity
2015                          if (nextTimeout >= now && mOverriddenTimeout == -1) {
2016                              // Save when the next timeout would have occurred
2017                              mOverriddenTimeout = nextTimeout;
2018                          }
2019                      }
2020                      mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;
2021                      nextTimeout = -1;
2022                  }
2023  
2024                  if (nextProfileTimeout > 0) {
2025                      nextTimeout = Math.min(nextTimeout, nextProfileTimeout);
2026                  }
2027  
2028                  if (mUserActivitySummary != 0 && nextTimeout >= 0) {
2029                      scheduleUserInactivityTimeout(nextTimeout);
2030                  }
2031              } else {
2032                  mUserActivitySummary = 0;
2033              }
2034  
2035              if (DEBUG_SPEW) {
2036                  Slog.d(TAG, "updateUserActivitySummaryLocked: mWakefulness="
2037                          + PowerManagerInternal.wakefulnessToString(mWakefulness)
2038                          + ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary)
2039                          + ", nextTimeout=" + TimeUtils.formatUptime(nextTimeout));
2040              }
2041          }
2042      }