Android Framework------之PowerManagerService的功能_sleepreasontostring

DisplayBlanker.java    
DisplayPowerController.java    
DisplayPowerRequest.java    
DisplayPowerState.java    
ElectronBeam.java    
Notifier.java    
PowerManagerService.java    
RampAnimator.java    
ScreenOnBlocker.java    
ShutdownThread.java    
SuspendBlocker.java    
WirelessChargerDetector.java    

<uses-permission android:name = "android.permission.WAKE_LOCK" />
<uses-permission android:name = "android.permission.DEVICE_POWER"/>

 1  @Override // Binder call
 2     public void goToSleep(long eventTime, int reason) {
 3         if (eventTime > SystemClock.uptimeMillis()) {
 4             throw new IllegalArgumentException("event time must not be in the future");
 5         }
 6 　　　　　　//权限检查
 7             mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
 8 
 9         final long ident = Binder.clearCallingIdentity();
10         try {
11             goToSleepInternal(eventTime, reason);//这里会调用函数的实现，在PowerManagerService中有很多类似的使用方式，之后的代码中我会直接列出对应方法的实现
12         } finally {
13             Binder.restoreCallingIdentity(ident);
14         }
15     }
16 
17     private void goToSleepInternal(long eventTime, int reason) {
18         synchronized (mLock) {
19             if (goToSleepNoUpdateLocked(eventTime, reason)) {
20                 updatePowerStateLocked();
21             }
22         }
23     }

 1     private boolean goToSleepNoUpdateLocked(long eventTime, int reason) {
 2         if (DEBUG_SPEW) {
 3             Slog.d(TAG, "goToSleepNoUpdateLocked: eventTime=" + eventTime + ", reason=" + reason);
 4         }
 5 
 6         if (eventTime < mLastWakeTime || mWakefulness == WAKEFULNESS_ASLEEP
 7                 || !mBootCompleted || !mSystemReady) {
 8             return false;
 9         }
10 
11         switch (reason) {
12             case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:
13                 Slog.i(TAG, "Going to sleep due to device administration policy...");
14                 break;
15             case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT:
16                 Slog.i(TAG, "Going to sleep due to screen timeout...");
17                 break;
18             default:
19                 Slog.i(TAG, "Going to sleep by user request...");
20                 reason = PowerManager.GO_TO_SLEEP_REASON_USER;
21                 break;
22         }
23 
24         sendPendingNotificationsLocked();
25         mNotifier.onGoToSleepStarted(reason);
26         mSendGoToSleepFinishedNotificationWhenReady = true;
27 
28         mLastSleepTime = eventTime;
29         mDirty |= DIRTY_WAKEFULNESS;
30         mWakefulness = WAKEFULNESS_ASLEEP;
31 
32         // Report the number of wake locks that will be cleared by going to sleep.
33         int numWakeLocksCleared = 0;
34         final int numWakeLocks = mWakeLocks.size();
35         for (int i = 0; i < numWakeLocks; i++) {
36             final WakeLock wakeLock = mWakeLocks.get(i);
37             switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
38                 case PowerManager.FULL_WAKE_LOCK:
39                 case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
40                 case PowerManager.SCREEN_DIM_WAKE_LOCK:
41                     numWakeLocksCleared += 1;
42                     break;
43             }
44         }
45         EventLog.writeEvent(EventLogTags.POWER_SLEEP_REQUESTED, numWakeLocksCleared);
46         return true;
47     }

SCREENSAVER_ENABLE，屏保的功能开启

SCREENSAVER_ACTIVE_ON_SLEEP，在睡眠时屏保启动

SCREENSAVER_ACTIVE_ON_DOCK，连接底座并且屏保启动

SCREEN_OFF_TIMEOUT，休眠时间

STAY_ON_PLUGGED_IN，有插入并且屏幕开启

SCREEN_BRIGHTNESS，屏幕的亮度

SCREEN_BRIGHTNESS_MODE，屏幕亮度的模式

1 public void onChange(boolean selfChange, Uri uri) {
2             synchronized (mLock) {
3                 handleSettingsChangedLocked();
4             }
5         }

 1     /**
 2      * Updates the global power state based on dirty bits recorded in mDirty.
 3      *
 4      * This is the main function that performs power state transitions.
 5      * We centralize them here so that we can recompute the power state completely
 6      * each time something important changes, and ensure that we do it the same
 7      * way each time.  The point is to gather all of the transition logic here.
 8      */
 9     private void updatePowerStateLocked() {
10         if (!mSystemReady || mDirty == 0) {//如果系统没有准备好，或者power state没有发生任何变化，这个方法可以不用执行的
11             return;
12         }
13 
14         // Phase 0: Basic state updates.
15         updateIsPoweredLocked(mDirty);
16         updateStayOnLocked(mDirty);
17 
18         // Phase 1: Update wakefulness.
19         // Loop because the wake lock and user activity computations are influenced
20         // by changes in wakefulness.
21         final long now = SystemClock.uptimeMillis();
22         int dirtyPhase2 = 0;
23         for (;;) {
24             int dirtyPhase1 = mDirty;
25             dirtyPhase2 |= dirtyPhase1;
26             mDirty = 0;
27 
28             updateWakeLockSummaryLocked(dirtyPhase1);//在前面解释几个变量的时候，就已经提到了WakeLockSummary和UserActivitySummary，
29             updateUserActivitySummaryLocked(now, dirtyPhase1);//在这里的两个方法中已经开始用到了。 想必通过方法名，大概也已经有所了解其功能了。
30             if (!updateWakefulnessLocked(dirtyPhase1)) {
31                 break;
32             }
33         }
34 
35         // Phase 2: Update dreams and display power state.
36         updateDreamLocked(dirtyPhase2);
37         updateDisplayPowerStateLocked(dirtyPhase2);
38 
39         // Phase 3: Send notifications, if needed.
40         if (mDisplayReady) {
41             sendPendingNotificationsLocked();
42         }
43 
44         // Phase 4: Update suspend blocker.
45         // Because we might release the last suspend blocker here, we need to make sure
46         // we finished everything else first!
47         updateSuspendBlockerLocked();
48     }

 1     /**
 2      * Updates the wakefulness of the device.
 3      *
 4      * This is the function that decides whether the device should start napping//这个方法的功能是：根据当前的wakeLocks和用户的活动情况，来决定设备是否需要小憩
 5      * based on the current wake locks and user activity state.  It may modify mDirty
 6      * if the wakefulness changes.
 7      *
 8      * Returns true if the wakefulness changed and we need to restart power state calculation.
 9      *///当wakefulness发生变化的时，返回true，同时也需要重新计算power state
10     private boolean updateWakefulnessLocked(int dirty) {
11         boolean changed = false;
12         if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_BOOT_COMPLETED
13                 | DIRTY_WAKEFULNESS | DIRTY_STAY_ON | DIRTY_PROXIMITY_POSITIVE
14                 | DIRTY_DOCK_STATE)) != 0) {
15             if (mWakefulness == WAKEFULNESS_AWAKE && isItBedTimeYetLocked()) {
16                 if (DEBUG_SPEW) {
17                     Slog.d(TAG, "updateWakefulnessLocked: Bed time...");
18                 }
19                 final long time = SystemClock.uptimeMillis();
20                 if (shouldNapAtBedTimeLocked()) {
21                     changed = napNoUpdateLocked(time);
22                 } else {
23                     changed = goToSleepNoUpdateLocked(time,
24                             PowerManager.GO_TO_SLEEP_REASON_TIMEOUT);
25                 }
26             }
27         }
28         return changed;
29     }

 1     private boolean isItBedTimeYetLocked() {
 2         return mBootCompleted && !isBeingKeptAwakeLocked();//个人认为mBootCompleted很重要，但是在设备正常使用的过程中我们可以认为其值是true。现在还没有必要讨论其他的情况
 3     }
 4 
 5     /**
 6      * Returns true if the device is being kept awake by a wake lock, user activity
 7      * or the stay on while powered setting.
 8      */
 9     private boolean isBeingKeptAwakeLocked() {
10         return mStayOn
11                 || mProximityPositive
12                 || (mWakeLockSummary & WAKE_LOCK_STAY_AWAKE) != 0
13                 || (mUserActivitySummary & (USER_ACTIVITY_SCREEN_BRIGHT
14                         | USER_ACTIVITY_SCREEN_DIM)) != 0;
15     }

    private boolean shouldNapAtBedTimeLocked() {
        return mDreamsActivateOnSleepSetting
                || (mDreamsActivateOnDockSetting
                        && mDockState != Intent.EXTRA_DOCK_STATE_UNDOCKED);
    }

 1     private void updateDisplayPowerStateLocked(int dirty) {
 2         if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_USER_ACTIVITY | DIRTY_WAKEFULNESS
 3                 | DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED | DIRTY_BOOT_COMPLETED
 4                 | DIRTY_SETTINGS | DIRTY_SCREEN_ON_BLOCKER_RELEASED)) != 0) {
 5             int newScreenState = getDesiredScreenPowerStateLocked();//获取display 的power state将要变成的状态
 6             if (newScreenState != mDisplayPowerRequest.screenState) {//mDisplayPowerRequest.screenState是目前display所处的power state
 7                 if (newScreenState == DisplayPowerRequest.SCREEN_STATE_OFF
 8                         && mDisplayPowerRequest.screenState
 9                                 != DisplayPowerRequest.SCREEN_STATE_OFF) {//这个判断意味着：目前display的电源状态不是OFF，但是想要变为OFF
10                     mLastScreenOffEventElapsedRealTime = SystemClock.elapsedRealtime();
11                 }
12 
13                 mDisplayPowerRequest.screenState = newScreenState;
14                 nativeSetPowerState(
15                         newScreenState != DisplayPowerRequest.SCREEN_STATE_OFF,
16                         newScreenState == DisplayPowerRequest.SCREEN_STATE_BRIGHT);
17             }
18 
19             int screenBrightness = mScreenBrightnessSettingDefault;
20             float screenAutoBrightnessAdjustment = 0.0f;
21             boolean autoBrightness = (mScreenBrightnessModeSetting ==
22                     Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC);//获取屏幕亮度模式是否为自动变化
23             if (isValidBrightness(mScreenBrightnessOverrideFromWindowManager)) {//mScreenBrightnessOverideFromeWindowManager是WindowManager设置的亮度大小，默认值为-1
24                 screenBrightness = mScreenBrightnessOverrideFromWindowManager;
25                 autoBrightness = false;
26             } else if (isValidBrightness(mTemporaryScreenBrightnessSettingOverride)) {//mTemporaryScreenBrightnessSettingOverride在widget中中设置的临时亮度大小，默认为-1
27                 screenBrightness = mTemporaryScreenBrightnessSettingOverride;
28             } else if (isValidBrightness(mScreenBrightnessSetting)) {//在Settings中的设置的默认亮度，在android4.2中其值为102
29                 screenBrightness = mScreenBrightnessSetting;
30             }
31             if (autoBrightness) {//如果亮度是自动调节的话
32                 screenBrightness = mScreenBrightnessSettingDefault;
33                 if (isValidAutoBrightnessAdjustment(
34                         mTemporaryScreenAutoBrightnessAdjustmentSettingOverride)) {
35                     screenAutoBrightnessAdjustment =
36                             mTemporaryScreenAutoBrightnessAdjustmentSettingOverride;
37                 } else if (isValidAutoBrightnessAdjustment(
38                         mScreenAutoBrightnessAdjustmentSetting)) {
39                     screenAutoBrightnessAdjustment = mScreenAutoBrightnessAdjustmentSetting;
40                 }
41             }
42             screenBrightness = Math.max(Math.min(screenBrightness,
43                     mScreenBrightnessSettingMaximum), mScreenBrightnessSettingMinimum);
44             screenAutoBrightnessAdjustment = Math.max(Math.min(
45                     screenAutoBrightnessAdjustment, 1.0f), -1.0f);
46             mDisplayPowerRequest.screenBrightness = screenBrightness;//从这行向下开始就是配置完成DisplayPowerRequest，然后以此为参数通过requestPowerSTate方法进行设置。
47             mDisplayPowerRequest.screenAutoBrightnessAdjustment =
48                     screenAutoBrightnessAdjustment;
49             mDisplayPowerRequest.useAutoBrightness = autoBrightness;
50 
51             mDisplayPowerRequest.useProximitySensor = shouldUseProximitySensorLocked();
52 
53             mDisplayPowerRequest.blockScreenOn = mScreenOnBlocker.isHeld();
54 
55             mDisplayReady = mDisplayPowerController.requestPowerState(mDisplayPowerRequest,
56                     mRequestWaitForNegativeProximity);
57             mRequestWaitForNegativeProximity = false;
58 
59             if (DEBUG_SPEW) {
60                 Slog.d(TAG, "updateScreenStateLocked: mDisplayReady=" + mDisplayReady
61                         + ", newScreenState=" + newScreenState
62                         + ", mWakefulness=" + mWakefulness
63                         + ", mWakeLockSummary=0x" + Integer.toHexString(mWakeLockSummary)
64                         + ", mUserActivitySummary=0x" + Integer.toHexString(mUserActivitySummary)
65                         + ", mBootCompleted=" + mBootCompleted);
66             }
67         }
68     }

 1     public PowerManagerService() {
 2         synchronized (mLock) {//下面是对于PowerManagerService中一些必要的变量进行的创建
 3             mWakeLockSuspendBlocker = createSuspendBlockerLocked("PowerManagerService");
 4             mWakeLockSuspendBlocker.acquire();//申请持有SuspendBlocker，防止系统停止工作
 5             mScreenOnBlocker = new ScreenOnBlockerImpl();
 6             mDisplayBlanker = new DisplayBlankerImpl();
 7             mHoldingWakeLockSuspendBlocker = true;
 8             mWakefulness = WAKEFULNESS_AWAKE;
 9         }
10 
11         nativeInit();//初始化native层的PowerManagerService，等会着重分析下这个函数
12         nativeSetPowerState(true, true);//这这个方法是用来初始化两个全局变量的，一个是gScreenOn，一个是gScreenBright，用来标示屏幕是否开启，是否亮着
13     }

 1 static void nativeInit(JNIEnv* env, jobject obj) {
 2     gPowerManagerServiceObj = env->NewGlobalRef(obj);
 3 　　//在阅读和HAL相关的代码是，经常见到如下这个方法，和hw_module_t这个结构体
 4     status_t err = hw_get_module(POWER_HARDWARE_MODULE_ID,//#define POWER_HARDWARE_MODULE_ID “power”
 5             (hw_module_t const**)&gPowerModule);//power_module* gPowerModule
 6     if (!err) {
 7         gPowerModule->init(gPowerModule);
 8     } else {
 9         ALOGE("Couldn't load %s module (%s)", POWER_HARDWARE_MODULE_ID, strerror(-err));
10     }
11 }