目录
前言
在开发中，或多或少会使用唤醒锁(wake lock)，有的是为了保持屏幕长亮，有的是为了保持 CPU 运行。
唤醒锁的本质，其实是对屏幕状态的控制，以及对 CPU 挂起的控制。
屏幕状态的控制，指的是保持屏幕处于点亮的状态，或者直接唤醒屏幕，或者延长亮屏时间。
CPU 挂起的控制，指的是否阻止 CPU 挂起，如果阻止了 CPU 挂起，其实就是保持 CPU 运行。
本文重点分析唤醒锁是如何实现对屏幕状态的控制，以及对 CPU 挂起的控制。
本文仍以前面的三篇文章为基础，重复的过程不会分析，只会简要概述，因此请读者务必仔细阅读如下三篇文章
使用唤醒锁
首先介绍下如何使用唤醒锁，如下
PowerManager pm = mContext.getSystemService(PowerManager.class);
// 1. 创建唤醒锁
// 保持屏幕处于点亮状态，但是允许变暗
PowerManager.WakeLock wl = pm.newWakeLock(
PowerManager.SCREEN_DIM_WAKE_LOCK
| PowerManager.ON_AFTER_RELEASE,
TAG);
// 2. 获取唤醒锁
wl.acquire();
// ... 执行任务 ...
// 3. 释放唤醒锁
wl.release();
使用唤醒锁的步骤为
- 创建唤醒锁
- 获取唤醒锁
- 在不需要唤醒锁的时候，释放它。
注意，使用唤醒时，还需要在 AndroidManifest.xml 中声明权限 android.Manifest.permission.WAKE_LOCK。
创建唤醒锁
首先介绍下创建唤醒锁的API
// PowerManager.java
public WakeLock newWakeLock(int levelAndFlags, String tag) {
validateWakeLockParameters(levelAndFlags, tag);
return new WakeLock(levelAndFlags, tag, mContext.getOpPackageName(),
Display.INVALID_DISPLAY);
}
参数 levelAndFlags 是由 level 和 flag 以按位或的方式组成，其中必须指定一个 level，但是 flag 是可选的。
第三方 app 能使用的 level 有如下几个
| level | 描述 |
|---|---|
| PARTIAL_WAKE_LOCK | 保证 CPU 运行，但是屏幕和键盘背光可以关闭 |
| FULL_WAKE_LOCK | 保证屏幕和键盘背光处于最大亮度 |
| SCREEN_DIM_WAKE_LOCK | 确保屏幕处于点亮状态，但是可以变暗，键盘背光允许关闭 |
| SCREEN_BRIGHT_WAKE_LOCK | 确认屏幕处于最大亮度，但是键盘背光允许关闭 |
| PROXIMITY_SCREEN_OFF_WAKE_LOCK | 当距离传感器检测到物体靠近时，灭屏，检测到物体远离时，点亮屏幕 |
注意，FULL_WAKE_LOCK 、SCREEN_DIM_WAKE_LOCK、SCREEN_BRIGHT_WAKE_LOCK 不仅会使屏幕处于点亮状态，同时也会保持 CPU 处于运行状态，我们将在后面的分析得到验证。
第三方 app 能使用的 flag 有如下几个
| flag | 描述 |
|---|---|
| ACQUIRE_CAUSES_WAKEUP | 当唤醒锁被获取时，点亮屏幕 |
| ON_AFTER_RELEASE | 当唤醒锁被释放时，如果屏幕处于点亮的状态，那么延长亮屏的时间 |
注意，ACQUIRE_CAUSES_WAKEUP 和 ON_AFTER_RELEASE 要配合屏幕唤醒锁 FULL_WAKE_LOCK, SCREEN_BRIGHT_WAKE_LOCK, SCREEN_DIM_WAKE_LOCK一起使用。我们将在后面的分析得到验证。
这里介绍的 level 和 flag 只适用于第三方 app 使用，其实系统还定义了一些，用于完成特殊的功能。
参数 tag，名字其实可以随意，但是官方说，最好以 app:mytag 的方式命名，例如 gmail:mytag。
参数介绍完了，我现在想提另外一个话题，与多屏相关。 不知从何时起，Android 把多屏进行了分组，内置的屏幕是在默认的分组中。PowerManager#newWakeLock(int levelAndFlags, String tag) 这个 API 会作用于所有的屏幕分组，但是如果我们想指定某组显示屏呢，那么需要使用下面的 API，但是它是系统 API
// PowerManager.java
/**
* @hide
*/
public WakeLock newWakeLock(int levelAndFlags, String tag, int displayId) {
validateWakeLockParameters(levelAndFlags, tag);
return new WakeLock(levelAndFlags, tag, mContext.getOpPackageName(), displayId);
}
参数 displayId 其实应该叫做 display group id，它表示唤醒锁作用于指定分组显示屏。
现在看下 WakeLock 的构造函数
// PowerManager.java
WakeLock(int flags, String tag, String packageName, int displayId) {
mFlags = flags;
mTag = tag;
mPackageName = packageName;
mToken = new Binder();
mTraceName = "WakeLock (" + mTag + ")";
mDisplayId = displayId;
}
构造函数就是简单保存几个参数，但是有一点需要注意，mToken 是一个 Binder，它会传给服务端 PowerManagerService，服务端会注册它的死亡事件。那么这个 Binder 对象其实就是为了监控服务端进程的生死。这个技术大家要学会，我曾经用这个技术优化过自己写的服务端代码。
获取唤醒锁
// PowerManager.java
public void acquire() {
synchronized (mToken) {
acquireLocked();
}
}
public void acquire(long timeout) {
synchronized (mToken) {
acquireLocked();
// 发送一个延时消息，自动释放唤醒锁
mHandler.postDelayed(mReleaser, timeout);
}
}
private void acquireLocked() {
mInternalCount++;
mExternalCount++;
// mRefCounted 默认为 true，它表示对唤醒锁引用计数
if (!mRefCounted || mInternalCount == 1) {
mHandler.removeCallbacks(mReleaser);
Trace.asyncTraceBegin(Trace.TRACE_TAG_POWER, mTraceName, 0);
try {
mService.acquireWakeLock(mToken, mFlags, mTag, mPackageName, mWorkSource,
mHistoryTag, mDisplayId);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
mHeld = true;
}
}
获取唤醒锁时，可以指定一个超时时间，如果时间到了，唤醒锁还没有释放，那么会自动释放唤醒锁。
默认的情况下，唤醒锁是计数的。如果多次获取唤醒锁，需要进行相应次数的释放。
而如果通过 wakeLock.setReferenceCounted(false) 设置唤醒锁为不计数
// PowerManager.java
public void setReferenceCounted(boolean value) {
synchronized (mToken) {
mRefCounted = value;
}
}
那么多次获取唤醒锁后，只需要释放一次。
现在让我们看下服务端 PowerManagerService 是如何获取唤醒锁的
// PowerManagerService.java
public void acquireWakeLock(IBinder lock, int flags, String tag, String packageName,
WorkSource ws, String historyTag, int displayId) {
// ... 省略权限检测
try {
acquireWakeLockInternal(lock, displayId, flags, tag, packageName, ws, historyTag,
uid, pid);
} finally {
Binder.restoreCallingIdentity(ident);
}
}
private void acquireWakeLockInternal(IBinder lock, int displayId, int flags, String tag,
String packageName, WorkSource ws, String historyTag, int uid, int pid) {
synchronized (mLock) {
// ... 省略显示屏分组的检测
WakeLock wakeLock;
int index = findWakeLockIndexLocked(lock);
boolean notifyAcquire;
if (index >= 0) { // 唤醒锁已经存在
// ...
} else { // 唤醒锁不存在
// mUidState 由 ActivityManagerService 同步给 PowerManagerService
// UidState 代表一个 app 进程的状态
UidState state = mUidState.get(uid);
if (state == null) {
state = new UidState(uid);
state.mProcState = ActivityManager.PROCESS_STATE_NONEXISTENT;
mUidState.put(uid, state);
}
// 保存唤醒锁的数量
state.mNumWakeLocks++;
// 1. 创建唤醒锁
wakeLock = new WakeLock(lock, displayId, flags, tag, packageName, ws, historyTag,
uid, pid, state);
try {
// 2. 监听客户端进程的死亡
// 当客户端进程死亡时，释放它所申请的唤醒锁
lock.linkToDeath(wakeLock, 0);
} catch (RemoteException ex) {
throw new IllegalArgumentException("Wake lock is already dead.");
}
// 3. 保存唤醒锁
mWakeLocks.add(wakeLock);
// 4. 更新唤醒锁 PowerManager.PARTIAL_WAKE_LOCK 的 disable 状态
setWakeLockDisabledStateLocked(wakeLock);
notifyAcquire = true;
}
// 5. 处理 PowerManager.ACQUIRE_CAUSES_WAKEUP 唤醒锁亮屏的情况
applyWakeLockFlagsOnAcquireLocked(wakeLock, uid);
// 6. 标记唤醒锁已经改变
mDirty |= DIRTY_WAKE_LOCKS;
// 7. 更新电源状态
updatePowerStateLocked();
if (notifyAcquire) {
// 记录唤醒锁
notifyWakeLockAcquiredLocked(wakeLock);
}
}
}
先大致了解下，首次向 PowerManagerService 申请唤醒锁的过程
- 创建服务端的 WakeLock。
- 监听客户端传递过来的 Binder 的死亡事件，其实就是监听客户端进程的死亡。当客户端进程死亡时，释放它所申请的唤醒锁。
- PowerManagerService 使用 ArrayList< WakeLock > mWakeLocks 保存创建的唤醒锁。
更新唤醒锁 PowerManager.PARTIAL_WAKE_LOCK 的 disable 状态，因此有些情况下，是不允许获取这种唤醒锁的，这些特殊情况如下
private boolean setWakeLockDisabledStateLocked(WakeLock wakeLock) {
if ((wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK)
== PowerManager.PARTIAL_WAKE_LOCK) {
boolean disabled = false;
final int appid = UserHandle.getAppId(wakeLock.mOwnerUid);
if (appid >= Process.FIRST_APPLICATION_UID) {
// Cached inactive processes are never allowed to hold wake locks.
// 1. 缓存的不活跃的进程的唤醒锁需要disable
if (mConstants.NO_CACHED_WAKE_LOCKS) {
disabled = mForceSuspendActive
|| (!wakeLock.mUidState.mActive && wakeLock.mUidState.mProcState
!= ActivityManager.PROCESS_STATE_NONEXISTENT &&
wakeLock.mUidState.mProcState > ActivityManager.PROCESS_STATE_RECEIVER);
}
if (mDeviceIdleMode) {
// 2. idle 模式下，不处理白名单的进程的唤醒锁，也需要 disable
final UidState state = wakeLock.mUidState;
if (Arrays.binarySearch(mDeviceIdleWhitelist, appid) < 0 &&
Arrays.binarySearch(mDeviceIdleTempWhitelist, appid) < 0 &&
state.mProcState != ActivityManager.PROCESS_STATE_NONEXISTENT &&
state.mProcState >
ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
disabled = true;
}
}
}
// 3. 更新唤醒锁的 disable 状态
if (wakeLock.mDisabled != disabled) {
wakeLock.mDisabled = disabled;
return true;
}
}
return false;
}
处理 PowerManager.ACQUIRE_CAUSES_WAKEUP 唤醒锁亮屏的情况。
private void applyWakeLockFlagsOnAcquireLocked(WakeLock wakeLock, int uid) {
// 注意，PowerManager.ACQUIRE_CAUSES_WAKEUP 要与如下几个屏幕锁一起使用才有效
// PowerManager.FULL_WAKE_LOCK
// PowerManager.SCREEN_BRIGHT_WAKE_LOCK
// PowerManager.SCREEN_DIM_WAKE_LOCK
if ((wakeLock.mFlags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0
&& isScreenLock(wakeLock)) {
String opPackageName;
int opUid;
if (wakeLock.mWorkSource != null && !wakeLock.mWorkSource.isEmpty()) {
// ...
} else {
opPackageName = wakeLock.mPackageName;
opUid = wakeLock.mOwnerUid;
}
for (int id : mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked()) {
// 更新 wakefulness 为 WAKEFULNESS_AWAKE
wakeDisplayGroupNoUpdateLocked(id, mClock.uptimeMillis(),
PowerManager.WAKE_REASON_APPLICATION, wakeLock.mTag,
opUid, opPackageName, opUid);
}
}
}
注意，PowerManager.ACQUIRE_CAUSES_WAKEUP 是要下屏幕锁一直使用，屏幕锁为 PowerManager.FULL_WAKE_LOCK、PowerManager.SCREEN_BRIGHT_WAKE_LOCK、PowerManager.SCREEN_DIM_WAKE_LOCK。很显然，这些屏幕锁，都是保持屏幕处于点亮的状态。
根据前面的文章，wakeDisplayGroupNoUpdateLocked() 其实就是更新 wakefulness 为 WAKEFULNESS_AWAKE。当后面更新电源状态时，会向 DisplayManagerService 发起屏幕请示，从而进行亮屏。这个过程，请读者参考前面的文章，自行分析。
- 标记唤醒锁已经改变。
- 更新电源状态，根据 mDirty 处理唤醒锁的改变 。
现在来看下最后一步，更新电源状态
// PowerManagerService.java
private void updatePowerStateLocked() {
if (!mSystemReady || mDirty == 0) {
return;
}
// 注意这里的技术，线程可以判断是否获取了某个锁
if (!Thread.holdsLock(mLock)) {
Slog.wtf(TAG, "Power manager lock was not held when calling updatePowerStateLocked");
}
Trace.traceBegin(Trace.TRACE_TAG_POWER, "updatePowerState");
try {
// Phase 0: Basic state updates.
updateIsPoweredLocked(mDirty);
updateStayOnLocked(mDirty);
updateScreenBrightnessBoostLocked(mDirty);
// Phase 1: Update wakefulness.
// Loop because the wake lock and user activity computations are influenced
// by changes in wakefulness.
final long now = mClock.uptimeMillis();
int dirtyPhase2 = 0;
for (;;) {
int dirtyPhase1 = mDirty;
dirtyPhase2 |= dirtyPhase1;
mDirty = 0;
// 1. 归纳唤醒锁
updateWakeLockSummaryLocked(dirtyPhase1);
// 更新用户行为
updateUserActivitySummaryLocked(now, dirtyPhase1);
updateAttentiveStateLocked(now, dirtyPhase1);
if (!updateWakefulnessLocked(dirtyPhase1)) {
break;
}
}
// Phase 2: Lock profiles that became inactive/not kept awake.
updateProfilesLocked(now);
// Phase 3: Update display power state.
// 2. 更新显示屏的电源状态
final boolean displayBecameReady = updateDisplayPowerStateLocked(dirtyPhase2);
// Phase 4: Update dream state (depends on display ready signal).
updateDreamLocked(dirtyPhase2, displayBecameReady);
// Phase 5: Send notifications, if needed.
finishWakefulnessChangeIfNeededLocked();
// Phase 6: Update suspend blocker.
// Because we might release the last suspend blocker here, we need to make sure
// we finished everything else first!
// 3. 唤醒锁保持 CPU 运行
updateSuspendBlockerLocked();
} finally {
Trace.traceEnd(Trace.TRACE_TAG_POWER);
}
}
与唤醒锁相关的主要流程如下
- 归纳唤醒锁。这个过程会把所有的唤醒锁整合到一起，它会影响请求策略，也就是会影响屏幕最终状态。并用它也会决定是否阻止CPU挂起，也就是是否保持CPU运行。详见【归纳唤醒锁】
- 更新电源状态。根据前面的文章可知，屏幕的最终状态是由请求的策略所决定的，而唤醒锁可以响应策略。详见【更新请求策略】
- 如果有唤醒锁需要保证 CPU 运行，那么 PMS 会向底层获取锁，保证 CPU 运行。详见【唤醒锁保持 CPU 运行】
归纳唤醒锁
private void updateWakeLockSummaryLocked(int dirty) {
if ((dirty & (DIRTY_WAKE_LOCKS | DIRTY_WAKEFULNESS | DIRTY_DISPLAY_GROUP_WAKEFULNESS))
!= 0) {
//1. wake lock summary 清 0
mWakeLockSummary = 0;
final int numProfiles = mProfilePowerState.size();
for (int i = 0; i < numProfiles; i++) {
mProfilePowerState.valueAt(i).mWakeLockSummary = 0;
}
for (int groupId : mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked()) {
mDisplayGroupPowerStateMapper.setWakeLockSummaryLocked(groupId, 0);
}
// 2. 获取 wake lock summary
int invalidGroupWakeLockSummary = 0;
final int numWakeLocks = mWakeLocks.size();
// 遍历所有的 WakeLock
for (int i = 0; i < numWakeLocks; i++) {
final WakeLock wakeLock = mWakeLocks.get(i);
final Integer groupId = wakeLock.getDisplayGroupId();
if (groupId == null) {
continue;
}
// 把 PowerManager 定义的 WakeLock flag 转化为 PowerManagerService 定义的 WakeLock flag
final int wakeLockFlags = getWakeLockSummaryFlags(wakeLock);
// 更新 PMS 的 mWakeLockSummary
mWakeLockSummary |= wakeLockFlags;
if (groupId != Display.INVALID_DISPLAY_GROUP) {
int wakeLockSummary = mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(
groupId);
wakeLockSummary |= wakeLockFlags;
mDisplayGroupPowerStateMapper.setWakeLockSummaryLocked(groupId,
wakeLockSummary);
} else {
// 没有指定 group id 的唤醒锁，保存到 invalidGroupWakeLockSummary
invalidGroupWakeLockSummary |= wakeLockFlags;
}
for (int j = 0; j < numProfiles; j++) {
// ...
}
} // 遍历所有 WakeLock 结束
// 3. 调整的 wake lock summary
for (int groupId : mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked()) {
// 从这里可以看出，invalidGroupWakeLockSummary 应用到了所有的 display group 中
// 因此，在获取 WakeLock 没有指定 group id 时，这个 WakeLock 是应用到所有的 display group 上
final int wakeLockSummary = adjustWakeLockSummaryLocked(
mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId),
invalidGroupWakeLockSummary
| mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId));
mDisplayGroupPowerStateMapper.setWakeLockSummaryLocked(groupId, wakeLockSummary);
}
mWakeLockSummary = adjustWakeLockSummaryLocked(getWakefulnessLocked(),
mWakeLockSummary);
for (int i = 0; i < numProfiles; i++) {
// ...
}
}
}
这里的逻辑很清晰，其实就是遍历所有的唤醒锁，然后归纳保存到 mWakeLockSummary。当然这其中有几个重要的函数需要搞清楚
通过 getWakeLockSummaryFlags() 把 PowerManager 定义的唤醒锁转化为 PowerManagerService 定义的唤醒锁
private int getWakeLockSummaryFlags(WakeLock wakeLock) {
switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
// 这个唤醒锁用于保持 CPU 运行
case PowerManager.PARTIAL_WAKE_LOCK:
// disabled 状态的唤醒锁，是不能保证 CPU 运行的
if (!wakeLock.mDisabled) {
return WAKE_LOCK_CPU;
}
break;
// 以下三个唤醒锁用于保持屏幕处于点亮状态
case PowerManager.FULL_WAKE_LOCK:
return WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_BUTTON_BRIGHT;
case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
return WAKE_LOCK_SCREEN_BRIGHT;
case PowerManager.SCREEN_DIM_WAKE_LOCK:
return WAKE_LOCK_SCREEN_DIM;
// 用距离传感器进行灭屏、亮屏
case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:
return WAKE_LOCK_PROXIMITY_SCREEN_OFF;
// PowerManager.DOZE_WAKE_LOCK 由 DreamManagerService 获取
// 它使设备真正进入打盹状态
case PowerManager.DOZE_WAKE_LOCK:
return WAKE_LOCK_DOZE;
// 由 window manager 获取，允许应用在系统doze状态下能够绘制
case PowerManager.DRAW_WAKE_LOCK:
return WAKE_LOCK_DRAW;
}
return 0;
}
通过 adjustWakeLockSummaryLocked() 调整归纳的唤醒锁
private static int adjustWakeLockSummaryLocked(int wakefulness, int wakeLockSummary) {
// 系统处于 非doze 状态，PowerManager.DOZE_WAKE_LOCK 和 PowerManager.DRAW_WAKE_LOCK 无效
// 看来，这两个锁只有当系统处于 doze 状态，才有效果
if (wakefulness != WAKEFULNESS_DOZING) {
wakeLockSummary &= ~(WAKE_LOCK_DOZE | WAKE_LOCK_DRAW);
}
// 系统处于休眠或者doze状态下，如下三个保持屏幕点亮状态的锁是无效的
// PowerManager.FULL_WAKE_LOCK
// PowerManager.SCREEN_BRIGHT_WAKE_LOCK
// PowerManager.SCREEN_DIM_WAKE_LOCK
if (wakefulness == WAKEFULNESS_ASLEEP
|| (wakeLockSummary & WAKE_LOCK_DOZE) != 0) {
wakeLockSummary &= ~(WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM
| WAKE_LOCK_BUTTON_BRIGHT);
// 甚至，当系统处于休眠状态，PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK 无法唤醒屏幕
if (wakefulness == WAKEFULNESS_ASLEEP) {
wakeLockSummary &= ~WAKE_LOCK_PROXIMITY_SCREEN_OFF;
}
}
// 如下三个保持屏幕点亮状态的锁
// PowerManager.FULL_WAKE_LOCK
// PowerManager.SCREEN_BRIGHT_WAKE_LOCK
// PowerManager.SCREEN_DIM_WAKE_LOCK
// 当系统处于唤醒状态或者屏保状态，这两个其实都是亮屏状态
// 需要保证 CPU 运行，也就是下面添加的 WAKE_LOCK_CPU
// 并且系统处于唤醒状态时，还要屏幕长亮，这正好符合上面三个唤醒锁的定义
if ((wakeLockSummary & (WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_SCREEN_DIM)) != 0) {
// 并且如果系统处理唤醒状态，还要保持长亮
if (wakefulness == WAKEFULNESS_AWAKE) {
wakeLockSummary |= WAKE_LOCK_CPU | WAKE_LOCK_STAY_AWAKE;
} else if (wakefulness == WAKEFULNESS_DREAMING) { // 系统处于屏保状态
wakeLockSummary |= WAKE_LOCK_CPU;
}
}
// 系统处于 doze 状态，PowerManager.DRAW_WAKE_LOCK 需要保持 CPU 运行
if ((wakeLockSummary & WAKE_LOCK_DRAW) != 0) {
wakeLockSummary |= WAKE_LOCK_CPU;
}
return wakeLockSummary;
}
调整归纳的唤醒锁，其实就是针对系统处于不同的状态，去掉一些不兼容的唤醒锁或者添加一些合适的锁。
例如，前面说过，PowerManager.FULL_WAKE_LOCK、PowerManager.SCREEN_BRIGHT_WAKE_LOCK、PowerManager.SCREEN_DIM_WAKE_LOCK 不仅仅要保持屏幕的亮度，而且还要保持 CPU 运行，这里就可以看出端倪。
更新请求策略
通过前面的文章可知，屏幕最终的状态是通过请求策略控制的，函数如下
int getDesiredScreenPolicyLocked(int groupId) {
final int wakefulness = mDisplayGroupPowerStateMapper.getWakefulnessLocked(groupId);
final int wakeLockSummary = mDisplayGroupPowerStateMapper.getWakeLockSummaryLocked(groupId);
if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
// 1. 系统处于休眠状态，任何唤醒锁都不起作用，屏幕会进入关闭状态
return DisplayPowerRequest.POLICY_OFF;
} else if (wakefulness == WAKEFULNESS_DOZING) {
// 2. 系统处于 doze 状态，PowerManager.DRAW_WAKE_LOCK 会让屏幕进入 doze 状态
// 当 dream manager 成功启动 doze dream，才会获取 PowerManager.DRAW_WAKE_LOCK，此时系统才真正进入 doze 状态
if ((wakeLockSummary & WAKE_LOCK_DOZE) != 0) {
return DisplayPowerRequest.POLICY_DOZE;
}
if (mDozeAfterScreenOff) {
return DisplayPowerRequest.POLICY_OFF;
}
}
if (mIsVrModeEnabled) {
return DisplayPowerRequest.POLICY_VR;
}
// 下面处理的是系统处于唤醒和屏保状态，都是亮屏的状态
// 3. PowerManager.FULL_WAKE_LOCK 和 PowerManager.SCREEN_BRIGHT_WAKE_LOCK 会
// 让屏幕处于亮屏状态
if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
|| !mBootCompleted
|| (mDisplayGroupPowerStateMapper.getUserActivitySummaryLocked(groupId)
& USER_ACTIVITY_SCREEN_BRIGHT) != 0
|| mScreenBrightnessBoostInProgress) {
return DisplayPowerRequest.POLICY_BRIGHT;
}
// 4. PowerManager.SCREEN_DIM_WAKE_LOCK 允许屏幕变暗
// 当屏幕快要超时时，会进入变暗的状态，此时持有 PowerManager.SCREEN_DIM_WAKE_LOCK 会保持屏幕
// 一直处于 dim 状态
return DisplayPowerRequest.POLICY_DIM;
}
从获取请求策略的过程，我们可以看到，当系统处于不同的状态，不同的唤醒锁，是如何影响屏幕状态的。
例如，PowerManager.FULL_WAKE_LOCK 和 PowerManager.SCREEN_BRIGHT_WAKE_LOCK 会保证屏幕一直处于亮屏状态，而 PowerManager.SCREEN_DIM_WAKE_LOCK 会保证屏幕也处于亮屏状态，但是允许变暗。
唤醒锁保持 CPU 运行
private void updateSuspendBlockerLocked() {
// 1. 检测是否有唤醒锁需要保持 CPU 运行
final boolean needWakeLockSuspendBlocker = ((mWakeLockSummary & WAKE_LOCK_CPU) != 0);
// 2. 检测屏幕的某些状态是否需要保持 CPU 运行
final boolean needDisplaySuspendBlocker = needDisplaySuspendBlockerLocked();
final boolean autoSuspend = !needDisplaySuspendBlocker;
final int[] groupIds = mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked();
boolean interactive = false;
for (int id : groupIds) {
interactive |= mDisplayGroupPowerStateMapper.getPowerRequestLocked(id).isBrightOrDim();
}
// mDecoupleHalAutoSuspendModeFromDisplayConfig 默认为 false
if (!autoSuspend && mDecoupleHalAutoSuspendModeFromDisplayConfig) {
setHalAutoSuspendModeLocked(false);
}
// 3. 向底层获取锁，保证 CPU 运行
// First acquire suspend blockers if needed.
if (needWakeLockSuspendBlocker && !mHoldingWakeLockSuspendBlocker) {
mWakeLockSuspendBlocker.acquire();
mHoldingWakeLockSuspendBlocker = true;
}
if (needDisplaySuspendBlocker && !mHoldingDisplaySuspendBlocker) {
mDisplaySuspendBlocker.acquire();
mHoldingDisplaySuspendBlocker = true;
}
// mDecoupleHalInteractiveModeFromDisplayConfig 默认为 false
if (mDecoupleHalInteractiveModeFromDisplayConfig) {
// ...
}
// 下面表示没有对应的唤醒锁，就需要向底层释放锁
if (!needWakeLockSuspendBlocker && mHoldingWakeLockSuspendBlocker) {
mWakeLockSuspendBlocker.release();
mHoldingWakeLockSuspendBlocker = false;
}
if (!needDisplaySuspendBlocker && mHoldingDisplaySuspendBlocker) {
mDisplaySuspendBlocker.release();
mHoldingDisplaySuspendBlocker = false;
}
// mDecoupleHalAutoSuspendModeFromDisplayConfig 默认为 flase
if (autoSuspend && mDecoupleHalAutoSuspendModeFromDisplayConfig) {
setHalAutoSuspendModeLocked(true);
}
}
如下几个锁会保持 CPU 运行
- PowerManager.PARTIAL_WAKE_LOCK(缓存的后台进程 或 idle模式下，不处于白名单的进程，唤醒锁无效)
- PowerManager.FULL_WAKE_LOCK（系统处于唤醒或屏保状态)
- PowerManager.SCREEN_BRIGHT_WAKE_LOCK（系统处于唤醒或屏保状态)
- PowerManager.SCREEN_DIM_WAKE_LOCK（系统处于唤醒或屏保状态)
- PowerManager.DOZE_WAKE_LOCK(系统处于doze状态)
- PowerManager.DRAW_WAKE_LOCK(系统处于doze状态)
屏幕的几种状态也需要保持 CPU 运行，请看下面代码所展示的所有情况
private boolean needDisplaySuspendBlockerLocked() {
// 1. DisplayManagerService 正在处理请求， 需要保持 CPU 运行
if (!mDisplayGroupPowerStateMapper.areAllDisplaysReadyLocked()) {
return true;
}
// 2. 屏幕亮度正在增强中，需要保持 CPU 运行
if (mScreenBrightnessBoostInProgress) {
return true;
}
// When we transition to DOZING, we have to keep the display suspend blocker
// up until the Doze service has a change to acquire the DOZE wakelock.
// Here we wait for mWakefulnessChanging to become false since the wakefulness
// transition to DOZING isn't considered "changed" until the doze wake lock is
// acquired.
// 3. doze状态的转换中，需要保持 CPU 运行
if (getWakefulnessLocked() == WAKEFULNESS_DOZING && mDozeStartInProgress) {
return true;
}
final int[] groupIds = mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked();
for (int id : groupIds) {
final DisplayPowerRequest displayPowerRequest =
mDisplayGroupPowerStateMapper.getPowerRequestLocked(id);
// 3. 亮屏状态下，需要保持 CPU 运行
// 屏幕处于点亮或者变暗的状态，都是亮屏的状态
if (displayPowerRequest.isBrightOrDim()) {
// If we asked for the screen to be on but it is off due to the proximity
// sensor then we may suspend but only if the configuration allows it.
// On some hardware it may not be safe to suspend because the proximity
// sensor may not be correctly configured as a wake-up source.
if (!displayPowerRequest.useProximitySensor || !mProximityPositive
|| !mSuspendWhenScreenOffDueToProximityConfig) {
return true;
}
}
// 4. 系统真正处于 doze 状态，也需要保持 CPU 运行
// 因此需要在屏幕绘制一些东西，例如时间
if (displayPowerRequest.policy == DisplayPowerRequest.POLICY_DOZE
&& displayPowerRequest.dozeScreenState == Display.STATE_ON) {
// Although we are in DOZE and would normally allow the device to suspend,
// the doze service has explicitly requested the display to remain in the ON
// state which means we should hold the display suspend blocker.
return true;
}
}
// Let the system suspend if the screen is off or dozing.
return false;
}
为何屏幕的状态有时候也需要 CPU 保持运行？举个最简单的例子，如果处于亮屏状态，CPU 允许挂起的话，app 进程就无法运行了。
释放锁
// PowerManager.java
public void release() {
release(0);
}
/**
* Releases the wake lock with flags to modify the release behavior.
* <p>
* This method releases your claim to the CPU or screen being on.
* The screen may turn off shortly after you release the wake lock, or it may
* not if there are other wake locks still held.
* </p>
*
* @param flags Combination of flag values to modify the release behavior.
* Currently only {@link #RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY} is supported.
* Passing 0 is equivalent to calling {@link #release()}.
*/
public void release(int flags) {
synchronized (mToken) {
if (mInternalCount > 0) {
// internal count must only be decreased if it is > 0 or state of
// the WakeLock object is broken.
mInternalCount--;
}
if ((flags & RELEASE_FLAG_TIMEOUT) == 0) {
mExternalCount--;
}
if (!mRefCounted || mInternalCount == 0) {
mHandler.removeCallbacks(mReleaser);
if (mHeld) {
Trace.asyncTraceEnd(Trace.TRACE_TAG_POWER, mTraceName, 0);
try {
mService.releaseWakeLock(mToken, flags);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
mHeld = false;
}
}
if (mRefCounted && mExternalCount < 0) {
throw new RuntimeException("WakeLock under-locked " + mTag);
}
}
}
从这里我们可以验证前面说的一个结论，mRefCounted 默认为 true，表示唤醒锁是引用计数的，如果多少获取唤醒锁，需要释放相应次数的唤醒锁。如果不计数，那么只需要释放一次。
现在看下服务端 PowerManagerService 是如何释放锁的
public void releaseWakeLock(IBinder lock, int flags) {
if (lock == null) {
throw new IllegalArgumentException("lock must not be null");
}
// 需要 android.Manifest.permission.WAKE_LOCK 权限
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null);
final long ident = Binder.clearCallingIdentity();
try {
releaseWakeLockInternal(lock, flags);
} finally {
Binder.restoreCallingIdentity(ident);
}
}
private void releaseWakeLockInternal(IBinder lock, int flags) {
synchronized (mLock) {
// 1. 找到服务端保存的唤醒锁
int index = findWakeLockIndexLocked(lock);
if (index < 0) {
return;
}
WakeLock wakeLock = mWakeLocks.get(index);
// 延迟释放 PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK
// 直到距离传感器检测到物体远离
if ((flags & PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY) != 0) {
mRequestWaitForNegativeProximity = true;
}
// 不再监听客户端进程的死亡
wakeLock.mLock.unlinkToDeath(wakeLock, 0);
// 移除唤醒锁
removeWakeLockLocked(wakeLock, index);
}
}
private void removeWakeLockLocked(WakeLock wakeLock, int index) {
// 2. 从数据结构中移除唤醒锁
mWakeLocks.remove(index);
// 进程状态中减少唤醒锁的数量
UidState state = wakeLock.mUidState;
state.mNumWakeLocks--;
if (state.mNumWakeLocks <= 0 &&
state.mProcState == ActivityManager.PROCESS_STATE_NONEXISTENT) {
mUidState.remove(state.mUid);
}
// 记录唤醒锁被释放的数据
notifyWakeLockReleasedLocked(wakeLock);
// 3. 处理 PowerManager.ON_AFTER_RELEASE
// 带有这个 flag 的锁，在释放的时候，会更新用户行为时间，从而可以延长亮屏的时间
applyWakeLockFlagsOnReleaseLocked(wakeLock);
// 4.标记唤醒已经改变，并更新电源状态
mDirty |= DIRTY_WAKE_LOCKS;
updatePowerStateLocked();
}
PowerManagerService 移除唤醒锁的过程一般如下
- 从数据结构中移除。
- 处于带有 PowerManager.ON_AFTER_RELEASE 这个 flag 的唤醒锁。在释放带有这个 flag 的唤醒锁的时候，会更新用户行为时间，从而可以延长亮屏的时间。
- 标记唤醒锁已经改变，更新电源状态。
距离传感器锁的原理，在看完本文后，大家可以自行分析。
现在来看下，释放带有 PowerManager.ON_AFTER_RELEASE 的唤醒锁，是如何延长亮屏的时间的
private void applyWakeLockFlagsOnReleaseLocked(WakeLock wakeLock) {
// PowerManager.ON_AFTER_RELEASE 必须与如下的屏幕锁一起使用
// PowerManager.FULL_WAKE_LOCK
// PowerManager.SCREEN_BRIGHT_WAKE_LOCK
// PowerManager.SCREEN_DIM_WAKE_LOCK
if ((wakeLock.mFlags & PowerManager.ON_AFTER_RELEASE) != 0
&& isScreenLock(wakeLock)) {
userActivityNoUpdateLocked(mClock.uptimeMillis(),
PowerManager.USER_ACTIVITY_EVENT_OTHER,
PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS,
wakeLock.mOwnerUid);
}
}
private boolean userActivityNoUpdateLocked(long eventTime, int event, int flags, int uid) {
boolean updatePowerState = false;
// 注意，PowerManager.ON_AFTER_RELEASE 影响了所有的 display group 的 用户行为时间
// 那么也说明，它会导致所有的屏幕延长亮屏的时间
for (int id : mDisplayGroupPowerStateMapper.getDisplayGroupIdsLocked()) {
if (userActivityNoUpdateLocked(id, eventTime, event, flags, uid)) {
updatePowerState = true;
}
}
return updatePowerState;
}
// PowerManagerService.java
private boolean userActivityNoUpdateLocked(int groupId, long eventTime, int event, int flags,
int uid) {
// ...
try {
// ...
if ((flags & PowerManager.USER_ACTIVITY_FLAG_NO_CHANGE_LIGHTS) != 0) {
// ...
} else {
if (eventTime > mDisplayGroupPowerStateMapper.getLastUserActivityTimeLocked(
groupId)) {
// 记录用户行为的时间
mDisplayGroupPowerStateMapper.setLastUserActivityTimeLocked(groupId, eventTime);
// 标记用户活动有改变
mDirty |= DIRTY_USER_ACTIVITY;
if (event == PowerManager.USER_ACTIVITY_EVENT_BUTTON) {
mDirty |= DIRTY_QUIESCENT;
}
return true;
}
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_POWER);
}
return false;
}
处理 PowerManager.ON_AFTER_RELEASE 的过程，我们要注意以下几点事情
- PowerManager.ON_AFTER_RELEASE 必须要与屏幕唤醒锁 PowerManager.FULL_WAKE_LOCK, PowerManager.SCREEN_BRIGHT_WAKE_LOCK, PowerManager.SCREEN_DIM_WAKE_LOCK 一起使用.
- PowerManager.ON_AFTER_RELEASE 更新了所有屏幕分组的用户行为时间，也就是说最终会导致所有屏幕都延长亮屏的时间。
- 更新用户行为时间，根据 PowerManagerService之自动灭屏 可知，用户行为时间的更新，最终会导致延长亮屏的时间
结束
通过本文的分析，我们可以看到唤醒锁是如何控制屏幕状态，以及如何保持CPU运行。但是本文写的比较简洁，是因为很多东西已经在前文分析过了，如果读者看本文的时候，有点压力，不妨再回头看看前面的文章。
PowerManagerService 系列的文章，就此结束。虽然还有一些功能我并未分析，但是我写的这些文章都是基础，只要掌握基础，其它功能的分析，岂不是信手拈来。
以上就是PowerManagerService之唤醒锁的使用获取创建示例解析的详细内容，更多关于PowerManagerService 唤醒锁的资料请关注其它相关文章！
