PowerManagerService学习笔记一

PowerManagerService(PMS): 主要负责Android系统中电源管理方面的工作。与其直接关系的类成员有如下几个：

PowerManagerService从IPowerManager.Stub派生，并实现了Watchdog.Monitor及LocalPowerManager接口；

IPowerManager.Stub及其内部类Proxy均有aidl工具处理IPower-Mangaer.aidl后得到；

客户端使用PowerManager类，其内部通过BinderProxy端的mService成员变量与PowerManagerService进行Binder通信；

PowerManagerService(PMS)的创建

PMS有SystemServer在ServerThread中创建，这里有几个关键的过程

//SystemServer.java
//ServerThread的run方法
//关键点1
power = new PowerManagerService();
/*注册到SM中*/
ServiceManager.addService(Context.POWER_SERVICE,power);
//关键点2
power.init(context, lights, ActivityManagerService.self(), battery);
......//其它服务
//关键点3
power.systemReady();
......//系统启动完毕会受到ACTION_BOOT_COMPLETED广播
//关键点4
//PMS处理ACTION_BOOT_COMPLETED广播

关键点1：
PowerManagerService() {
// Hack to get our uid... should have a func for this.
long token = Binder.clearCallingIdentity();
MY_UID = Process.myUid();
MY_PID = Process.myPid();
Binder.restoreCallingIdentity(token);

// XXX remove this when the kernel doesn't timeout wake locks
//设置超时间为1周
Power.setLastUserActivityTimeout(7*24*3600*1000); // one week

// assume nothing is on yet

//重要的两个成员变量

mUserState = mPowerState = 0;

//将自己添加到看门狗的监控管理队列中
Watchdog.getInstance().addMonitor(this);
}

关键点2：
init主要完成以下几方面的工作：

1> 对一些成员变量进行赋值；

2> 调用nativeInit方法初始化Native层；

3> 调用updateNativePowerStateLocked方法更新Native层的电源状态；

4> 创建mScreenOffThread线程，按Power键关闭屏幕时，屏幕不是突然变黑，而是一个渐暗的过程。mScreenOffThread线程就是用于控制关闭屏幕过程中的亮度调节；

5> 创建mHandlerThread线程，该线程是PMS的主要工作线程；

6> 初始化mHandlerThread线程相关信息；

7> 强制触发一次用户事件；

各方面共做对应的源码：

1>成员变量说明

 


2>nativeInit

//com_android_server_PowerManagerService.cpp

static void android_server_PowerManagerService_nativeInit(JNIEnv* env, jobject obj) {
//创建一个全局引用对象
gPowerManagerServiceObj = env->NewGlobalRef(obj);
}
3> updateNativePowerStateLocked(待学习)
4> mScreenOffThread创建

//PowerManagerService.java

mInitComplete = false;
mScreenOffThread = new HandlerThread("PowerManagerService.mScreenOffThread") {
@Override
protected void onLooperPrepared() {
mScreenOffHandler = new Handler();
synchronized (mScreenOffThread) {
mInitComplete = true;
mScreenOffThread.notifyAll();
}
}
};
mScreenOffThread.start();
//等待mScreenOffThread线程创建完毕
synchronized (mScreenOffThread) {
while (!mInitComplete) {
try {
mScreenOffThread.wait();
} catch (InterruptedException e) {
// Ignore
}
}
}
5> mHandlerThread创建
mInitComplete = false;
mHandlerThread = new HandlerThread("PowerManagerService") {
@Override
protected void onLooperPrepared() {
super.onLooperPrepared();
初始化mHandlerThread线程
initInThread();
}
};
mHandlerThread.start();
//等待mHandlerThread线程创建完毕
synchronized (mHandlerThread) {
while (!mInitComplete) {
try {
mHandlerThread.wait();
} catch (InterruptedException e) {
// Ignore
}
}
}
6> initInThread分析
a. PMS需要了解外面的状态，所以会注册一些广播接收对象，接收诸如启动完毕，电池变化等广播； 

b. PMS所从事的电源管理工作需要一些规则，需要对其做一些配置，这些配置信息有些是固定的（编译后无法改变），有些是可以在Settings数据库中动态设定的；

c. PMS需要对法发送一些通知，诸如，屏幕关闭/开启；

d. 源代码

对于数据库中的参数配置，需要加入监测机制，通知PMS更新相关配置。

void initInThread() {
mHandler = new Handler();

mBroadcastWakeLock = new UnsynchronizedWakeLock(
PowerManager.PARTIAL_WAKE_LOCK, "sleep_broadcast", true);
mStayOnWhilePluggedInScreenDimLock = new UnsynchronizedWakeLock(
PowerManager.SCREEN_DIM_WAKE_LOCK, "StayOnWhilePluggedIn Screen Dim", false);
mStayOnWhilePluggedInPartialLock = new UnsynchronizedWakeLock(
PowerManager.PARTIAL_WAKE_LOCK, "StayOnWhilePluggedIn Partial", false);
mPreventScreenOnPartialLock = new UnsynchronizedWakeLock(
PowerManager.PARTIAL_WAKE_LOCK, "PreventScreenOn Partial", false);
mProximityPartialLock = new UnsynchronizedWakeLock(
PowerManager.PARTIAL_WAKE_LOCK, "Proximity Partial", false);
//创建广播通知的intent,用于通知SCREEN_ON/SCREEN_OFF消息
mScreenOnIntent = new Intent(Intent.ACTION_SCREEN_ON);
mScreenOnIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
mScreenOffIntent = new Intent(Intent.ACTION_SCREEN_OFF);
mScreenOffIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);

//取得参数配置，编译时确定，运行过程中无法修改
Resources resources = mContext.getResources();
mAnimateScreenLights = resources.getBoolean(
com.android.internal.R.bool.config_animateScreenLights);

mUnplugTurnsOnScreen = resources.getBoolean(
com.android.internal.R.bool.config_unplugTurnsOnScreen);

mScreenBrightnessDim = resources.getInteger(
com.android.internal.R.integer.config_screenBrightnessDim);

// read settings for auto-brightness
mUseSoftwareAutoBrightness = resources.getBoolean(
com.android.internal.R.bool.config_automatic_brightness_available);
if (mUseSoftwareAutoBrightness) {
mAutoBrightnessLevels = resources.getIntArray(
com.android.internal.R.array.config_autoBrightnessLevels);
mLcdBacklightValues = resources.getIntArray(
com.android.internal.R.array.config_autoBrightnessLcdBacklightValues);
mButtonBacklightValues = resources.getIntArray(
com.android.internal.R.array.config_autoBrightnessButtonBacklightValues);
mKeyboardBacklightValues = resources.getIntArray(
com.android.internal.R.array.config_autoBrightnessKeyboardBacklightValues);
mLightSensorWarmupTime = resources.getInteger(
com.android.internal.R.integer.config_lightSensorWarmupTime);
}
//取得参数配置完毕
//取得数据库设置的配置参数
ContentResolver resolver = mContext.getContentResolver();
Cursor settingsCursor = resolver.query(Settings.System.CONTENT_URI, null,
"(" + Settings.System.NAME + "=?) or ("
+ Settings.System.NAME + "=?) or ("
+ Settings.System.NAME + "=?) or ("
+ Settings.System.NAME + "=?) or ("
+ Settings.System.NAME + "=?) or ("
+ Settings.System.NAME + "=?)",
new String[]{STAY_ON_WHILE_PLUGGED_IN, SCREEN_OFF_TIMEOUT, DIM_SCREEN,
SCREEN_BRIGHTNESS_MODE, WINDOW_ANIMATION_SCALE, TRANSITION_ANIMATION_SCALE},
null);
mSettings = new ContentQueryMap(settingsCursor, Settings.System.NAME, true, mHandler);
//观察者模式，监视ContentQueryMap中内容的变化
SettingsObserver settingsObserver = new SettingsObserver();
mSettings.addObserver(settingsObserver);

// pretend that the settings changed so we will get their initial state
settingsObserver.update(mSettings, null);

//注册接收通知的BroadCastReceiver对象
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_BATTERY_CHANGED);
mContext.registerReceiver(new BatteryReceiver(), filter);
filter = new IntentFilter();
filter.addAction(Intent.ACTION_BOOT_COMPLETED);
mContext.registerReceiver(new BootCompletedReceiver(), filter);
filter = new IntentFilter();
filter.addAction(Intent.ACTION_DOCK_EVENT);
mContext.registerReceiver(new DockReceiver(), filter);

// Listen for secure settings changes
//监视Settings数据库中secure表的变化
mContext.getContentResolver().registerContentObserver(
Settings.Secure.CONTENT_URI, true,
new ContentObserver(new Handler()) {
public void onChange(boolean selfChange) {
updateSettingsValues();
}
});
updateSettingsValues();

synchronized (mHandlerThread) {
mInitComplete = true;
mHandlerThread.notifyAll();
}
}
7> forceUserActivityLocked内部调用userActivity,调用该方法后手机被唤醒，屏幕超时时间也将重新计算
private void forceUserActivityLocked() {
if (isScreenTurningOffLocked()) {
// cancel animation so userActivity will succeed
mScreenBrightness.animating = false;
}
boolean savedActivityAllowed = mUserActivityAllowed;
mUserActivityAllowed = true;
//唤醒设备屏幕，超时时间重新计算
userActivity(SystemClock.uptimeMillis(), false);
mUserActivityAllowed = savedActivityAllowed;
}关键点3:
systemReady主要完成以下几方面工作:

1> PMS创建SensorManager,通过它可与对应的传感器交互；PMS仅仅启用特定的传感器，而来自传感器的数据将通过回调方式通知PMS，PMS根据时间作出回应；

2> 通过setPowerState方法设置电源状态为ALL_BRIGHT(不考虑，UserSoftwareAutoBrightness情况)，此时屏幕及键盘都会点亮；

3> 通过BatteryStasService提供的方法，通知屏幕打开事件；

void systemReady() {
mSensorManager = new SensorManager(mHandlerThread.getLooper());
mProximitySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
// don't bother with the light sensor if auto brightness is handled in hardware
if (mUseSoftwareAutoBrightness) {
mLightSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
}

// wait until sensors are enabled before turning on screen.
// some devices will not activate the light sensor properly on boot
// unless we do this.
if (mUseSoftwareAutoBrightness) {
// turn the screen on
setPowerState(SCREEN_BRIGHT);
} else {
// turn everything on
setPowerState(ALL_BRIGHT);
}

synchronized (mLocks) {
Slog.d(TAG, "system ready!");
mDoneBooting = true;

enableLightSensorLocked(mUseSoftwareAutoBrightness && mAutoBrightessEnabled);

long identity = Binder.clearCallingIdentity();
try {
mBatteryStats.noteScreenBrightness(getPreferredBrightness());
mBatteryStats.noteScreenOn();
} catch (RemoteException e) {
// Nothing interesting to do.
} finally {
Binder.restoreCallingIdentity(identity);
}
}
}

关键点4：

当系统的服务在systemReady中进行处理后，系统会发ACTION_BOOT_COMPLETED消息。

1> BootCompletedReceiver

private final class BootCompletedReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
bootCompleted();
}
}
2> bootCompleted
void bootCompleted() {
Slog.d(TAG, "bootCompleted");
synchronized (mLocks) {
mBootCompleted = true;
userActivity(SystemClock.uptimeMillis(), false, BUTTON_EVENT, true);
updateWakeLockLocked();
mLocks.notifyAll();
}
}
3> updateWakeLockLocked
private void updateWakeLockLocked() {
/*
mStayOnConditions用于控制当手机插上USB时，是否需要保持唤醒状态
mBatteryService.isPowered是否处于USB充电状态。
如果满足条件，PMS需要使用WakeLock来确保系统不掉电
*/
if (mStayOnConditions != 0 && mBatteryService.isPowered(mStayOnConditions)) {
// keep the device on if we're plugged in and mStayOnWhilePluggedIn is set.
mStayOnWhilePluggedInScreenDimLock.acquire();
mStayOnWhilePluggedInPartialLock.acquire();
} else {
mStayOnWhilePluggedInScreenDimLock.release();
mStayOnWhilePluggedInPartialLock.release();
}
}