解析自动休眠---实现自动关机

从Application上往下跟，解析自动休眠的实现策略

Application层

Settings----Display----Sleep

这里是超时设置的地方。

文件目录：packages/apps/Settings/src/com/android/settings/DisplaySettings.java

这里比较简单：

onCreate()

{

…

mScreenTimeoutPreference = (ListPreference)findPreference(KEY_SCREEN_TIMEOUT);

final long currentTimeout =Settings.System.getLong(resolver, SCREEN_OFF_TIMEOUT,

FALLBACK_SCREEN_TIMEOUT_VALUE);

mScreenTimeoutPreference.setValue(String.valueOf(currentTimeout));

mScreenTimeoutPreference.setOnPreferenceChangeListener(this);

disableUnusableTimeouts(mScreenTimeoutPreference);

updateTimeoutPreferenceDescription(currentTimeout);

…

}

……….

@Override

publicboolean onPreferenceChange(Preference preference, Object objValue) {

finalString key = preference.getKey();

if(KEY_SCREEN_TIMEOUT.equals(key)) {

try {

int value = Integer.parseInt((String) objValue);

Settings.System.putInt(getContentResolver(), SCREEN_OFF_TIMEOUT, value);

updateTimeoutPreferenceDescription(value);

}catch (NumberFormatException e) {

Log.e(TAG, "could not persist screen timeout setting", e);

}

Settings里头，只是将当前的数值保存在数据库里头，这意味着默认值可以在SettingsProvider中被设置，这是比较正统的做法。同时，也意味着会有一个Observer。

---------------------------------------------------------------------------------------------------------------------------

Framework层

有以下几处用到了这个SCREEN_OFF_TIMEOUT

1. frameworks/base/services/core/java/com/android/server/power/PowerManagerService.java

2. frameworks/base/packages/SystemUI/src/com/android/systemui/keyguard/KeyguardViewMediator.java

3. frameworks/base/packages/SettingsProvider/src/com/android/providers/settings/DatabaseHelper.java

4. frameworks/base/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java

这几处要一个一个查。具体是什么作用

从简单的开始查，基本上可以肯定DatabaseHelper.java只是初始化，读取默认参数。去看看。

一、DatabaseHelper.java

private voidloadSystemSettings(SQLiteDatabase db) {

SQLiteStatement stmt = null;

try {

……...

//add for factory as ro.rk.screenoff_time

loadSetting(stmt, Settings.System.SCREEN_OFF_TIMEOUT,

SystemProperties.getInt("ro.rk.screenoff_time",mContext.getResources().getInteger(R.integer.def_screen_off_timeout)));

………..

}

这里读取ro.rk.screenoff_time读取数据，默认数值保存在def_screen_off_timeout中。只是初始化数值。

SCREEN_OFF_TIMEOUT这个关键字还出现upgradeScreenTimeoutFromNever中，但这里只是数据库更新时的操作，没有更多的意义。

二、PhoneWindowManager.java第二个文件是这个。

特地说明下这个类：PhoneWindowManager.java继承自WindowManagePolicy.java

WindowManagePolicy.java是做什么的呢？这里头有一大堆lw li t

--------接口类，提供了WindowManager的所有UI定制行为。在WindowManager启动的时候被实例化，允许定制window层级，制定window类型，key事件派发，布局。

WindowManagePolicy.java提供了与系统窗口管理的深层交互。在这个interface中的一些方法会被许多被多重限制的context调用。这里怎么理解呢？多重限制。可以理解成这是些被很多lock限制的context。这些函数会用一些后缀来判别被调用时持有了哪些lock。如果没有后缀。那就意味着函数可能是被window manager 主线程或其他调用windowmanager的线程。

后缀：Ti--------Thread input； Tq----------Thread Queue； Lw---------------lock mainwindowmanager; Li-----------------Lock input thread

同时，在PhoneWindowManager中，新增后缀Lp--------Lock phone window manager

这里的限制======锁=====locks

还有一点：老规矩frameworks/base/services/java/com/android/server/WindowManagerService.java是核心，有很多调用都从这里来，PhoneWindowManager.java侧重与提供app调用的接口。

接着讲PhoneWindowManager.java。进入正题。

class SettingsObserver extendsContentObserver {

SettingsObserver(Handler handler) {

super(handler);

}

void observe() {

………….

resolver.registerContentObserver(Settings.System.getUriFor(

Settings.System.SCREEN_OFF_TIMEOUT), false, this,

UserHandle.USER_ALL);

………..

updateSettings();

}

@Overridepublic void onChange(boolean selfChange) {

updateSettings();

updateRotation(false);

}

另一处是在updateSettings中。

public void updateSettings() {

ContentResolverresolver = mContext.getContentResolver();

boolean updateRotation = false;

synchronized (mLock) {

……………..

//use screen off timeout setting as the timeout for the lockscreen

mLockScreenTimeout = Settings.System.getIntForUser(resolver,

Settings.System.SCREEN_OFF_TIMEOUT,0, UserHandle.USER_CURRENT);

……………..

}

………….

}

结合起来看，就是PhoneWindowManager监听了SCREEN_OFF_TIMEOUT。同时，在数据库改变时，讲最新的值保存在mLockScreenTimeout中。----------注意这是保存了超时时间的变量

-------------------------------------------------------------------------------------------------------

那么，mLockScreenTimeout在什么时候调用呢？

两个地方

private void updateLockScreenTimeout() {

synchronized (mScreenLockTimeout) {

boolean enable = (mAllowLockscreenWhenOn && mAwake &&

mKeyguardDelegate != null&& mKeyguardDelegate.isSecure());

if (mLockScreenTimerActive != enable) {

if (enable) {

if (localLOGV) Log.v(TAG,"setting lockscreen timer");

mHandler.postDelayed(mScreenLockTimeout, mLockScreenTimeout);

} else {

if (localLOGV) Log.v(TAG,"clearing lockscreen timer");

mHandler.removeCallbacks(mScreenLockTimeout);

}

mLockScreenTimerActive =enable;

}

看函数体，这是根据一些变量，判断是否要添加mScreenLockTimeout的Handler。mLockScreenTimerActive保存住当前是否开启了自动锁屏功能。

updateLockScreenTimeout在三个地方被调用：

1. finishPostLayoutPolicyLw----WindowManagerService.java

2. goingToSleep--------Notifier.java

3. wakingUp---------Notifier.java

小结，ScreenTimeout只在睡眠唤醒UI刷新时会检查判断。which is quite often.

如果读者有兴趣可以继续跟这几个函数的具体调用。针对这个研究目标已经足够。

另一个地方：

public void userActivity() {

………

synchronized (mScreenLockTimeout) {

if (mLockScreenTimerActive) {

// reset the timer

mHandler.removeCallbacks(mScreenLockTimeout);

mHandler.postDelayed(mScreenLockTimeout, mLockScreenTimeout);

}

……….

}

在userActivity的时候不断的更新。

userActivity又是如何调用的呢？

在事件派发机制中，有个InputDispatcher.cpp，kernel收到events之后，通过这个类的pokeUserActivity，传递到com_android_server_input_InputManagerService.cpp中，再通过com_android_server_input_InputManagerService.cpp的调用android_server_PowerManagerService_userActivity，最终userActivityFromNative真正传到PowerManagerService。再调到PhoneWindowManager.java的userActivity。

三、KeyguardViewMediator.java第三个文件是这个。

private void doKeyguardLaterLocked() {

// if thescreen turned off because of timeout or the user hit the power button

// and wedon't need to lock immediately, set an alarm

// toenable it a little bit later (i.e, give the user a chance

// toturn the screen back on within a certain window without

// havingto unlock the screen)

finalContentResolver cr = mContext.getContentResolver();

// FromDisplaySettings

longdisplayTimeout = Settings.System.getInt(cr, SCREEN_OFF_TIMEOUT,

KEYGUARD_DISPLAY_TIMEOUT_DELAY_DEFAULT);

// FromSecuritySettings

finallong lockAfterTimeout = Settings.Secure.getInt(cr,

Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT,

KEYGUARD_LOCK_AFTER_DELAY_DEFAULT);

// FromDevicePolicyAdmin

finallong policyTimeout = mLockPatternUtils.getDevicePolicyManager()

.getMaximumTimeToLock(null, mLockPatternUtils.getCurrentUser());

longtimeout;

if(policyTimeout > 0) {

//policy in effect. Make sure we don't go beyond policy limit.

displayTimeout = Math.max(displayTimeout, 0); // ignore negative values

timeout = Math.min(policyTimeout - displayTimeout, lockAfterTimeout);

} else {

timeout = lockAfterTimeout;

}

if(timeout <= 0) {

//Lock now

mSuppressNextLockSound = true;

doKeyguardLocked(null);

} else {

//Lock in the future

longwhen = SystemClock.elapsedRealtime() + timeout;

Intent intent = new Intent(DELAYED_KEYGUARD_ACTION);

intent.putExtra("seq", mDelayedShowingSequence);

PendingIntent sender = PendingIntent.getBroadcast(mContext,

0, intent, PendingIntent.FLAG_CANCEL_CURRENT);

mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, when, sender);

if(DEBUG) Log.d(TAG, "setting alarm to turn off keyguard, seq = "

+mDelayedShowingSequence);

}

这里看起来比较方便。获取了SCREEN_OFF_TIMEOUT的最新值，保存在displayTimeout。并根据这个值计算要待机的时间。

四、PowerManagerService.java最烦就是这个。

可以查到

public voidsystemReady(IAppOpsService appOps) {

synchronized (mLock) {

……

resolver.registerContentObserver(Settings.System.getUriFor(

Settings.System.SCREEN_OFF_TIMEOUT),

…….

}

PowerManagerService.java添加了对SCREEN_OFF_TIMEOUT的监听。

private void updateSettingsLocked() {

……..

mScreenOffTimeoutSetting =Settings.System.getIntForUser(resolver,

Settings.System.SCREEN_OFF_TIMEOUT, DEFAULT_SCREEN_OFF_TIMEOUT,

UserHandle.USER_CURRENT);

……..

}

将数据库中的值保存在mScreenOffTimeoutSetting中。

private int getScreenOffTimeoutLocked(intsleepTimeout) {

int timeout = mScreenOffTimeoutSetting;

if(isMaximumScreenOffTimeoutFromDeviceAdminEnforcedLocked()) {

timeout = Math.min(timeout,mMaximumScreenOffTimeoutFromDeviceAdmin);

}

if (mUserActivityTimeoutOverrideFromWindowManager>= 0) {

timeout = (int)Math.min(timeout,mUserActivityTimeoutOverrideFromWindowManager);

}

if (sleepTimeout >= 0) {

timeout = Math.min(timeout,sleepTimeout);

}

return Math.max(timeout,mMinimumScreenOffTimeoutConfig);

}

继续看，可以发现mScreenOffTimeoutSetting，经过处理，会通过getScreenOffTimeoutLocked函数被其他函数使用。

private voidupdateUserActivitySummaryLocked(long now, int dirty) {

// Update the status of the user activitytimeout timer.

if ((dirty & (DIRTY_WAKE_LOCKS |DIRTY_USER_ACTIVITY

| DIRTY_WAKEFULNESS |DIRTY_SETTINGS)) != 0) {

mHandler.removeMessages(MSG_USER_ACTIVITY_TIMEOUT);

long nextTimeout = 0;

if (mWakefulness == WAKEFULNESS_AWAKE

|| mWakefulness ==WAKEFULNESS_DREAMING

|| mWakefulness ==WAKEFULNESS_DOZING) {

final int sleepTimeout =getSleepTimeoutLocked();

final int screenOffTimeout =getScreenOffTimeoutLocked(sleepTimeout);

final int screenDimDuration =getScreenDimDurationLocked(screenOffTimeout);

mUserActivitySummary = 0;

if (mLastUserActivityTime >=mLastWakeTime) {

nextTimeout =mLastUserActivityTime

+ screenOffTimeout- screenDimDuration;

if (now < nextTimeout) {

mUserActivitySummary =USER_ACTIVITY_SCREEN_BRIGHT;

} else {

nextTimeout =mLastUserActivityTime + screenOffTimeout;

if (now <nextTimeout) {

mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;

}

if (mUserActivitySummary == 0

&&mLastUserActivityTimeNoChangeLights >= mLastWakeTime) {

nextTimeout =mLastUserActivityTimeNoChangeLights + screenOffTimeout;

if (now < nextTimeout) {

if(mDisplayPowerRequest.policy == DisplayPowerRequest.POLICY_BRIGHT) {

mUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;

} else if (mDisplayPowerRequest.policy== DisplayPowerRequest.POLICY_DIM) {

mUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;

}

if (mUserActivitySummary == 0){

if (sleepTimeout >= 0) {

final longanyUserActivity = Math.max(mLastUserActivityTime,

mLastUserActivityTimeNoChangeLights);

if (anyUserActivity>= mLastWakeTime) {

nextTimeout =anyUserActivity + sleepTimeout;

if (now <nextTimeout) {

mUserActivitySummary = USER_ACTIVITY_SCREEN_DREAM;

}

} else {

mUserActivitySummary =USER_ACTIVITY_SCREEN_DREAM;

nextTimeout = -1;

}

if (mUserActivitySummary != 0&& nextTimeout >= 0) {

Message msg =mHandler.obtainMessage(MSG_USER_ACTIVITY_TIMEOUT);

msg.setAsynchronous(true);

mHandler.sendMessageAtTime(msg, nextTimeout);

}

} else {

mUserActivitySummary = 0;

}

…………..

}

MSG_USER_ACTIVITY_TIMEOUT 又会触发handleUserActivityTimeout。又一次去updatePowerStateLocked。updateUserActivitySummaryLocked又在updatePowerStateLocked被调用，这就是一个不断更新的环路。

不管这里的函数应该如何调用。从这里可以看出一点。

这里的SCREEN_OFF_TIMEOUT被用作控制屏幕是dim或者bright。或者asleep后就被ignored。

总结

至此，可以明白了。自动关机该如何实现？在PhoneWindowManager中，添加超时即可。其他的系统会帮你做。具体的实现涉及哪些文件呢？

1. 在system.prop中添加switcher

2. frameworks/base/core/java/android/provider/Settings.java中加KEY：POWER_OFF_TIMEOUT

3. frameworks/base/core/res/res/values/config.xml加与system.prop中配套的default_config值

4. frameworks/base/core/res/res/values/symbols.xml别忘了这个

5. frameworks/base/packages/SettingsProvider支持起来

6. frameworks/base/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java中加AlarmManager去设置一个timer

7. packages/apps/Settings/添加支持。