Android13 基座充电屏保

屏幕保护有两个设置可选：默认为插入基座充电时

通过DreamBackend启用屏保，并且保存选择的时机

//QSSI.13\packages\apps\Settings\src\com\android\settings\dream\WhenToDreamPicker.java
@Override
protected boolean setDefaultKey(String key) {
    mBackend.setWhenToDream(DreamSettings.getSettingFromPrefKey(key));
    return true;
}
//QSSI.13\frameworks\base\packages\SettingsLib\src\com\android\settingslib\dream\DreamBackend.java
//启用屏保：
public void startDreaming() {
    logd("startDreaming()");
    if (mDreamManager == null) {
        return;
    }
    try {
        mDreamManager.dream();
    } catch (RemoteException e) {
        Log.w(TAG, "Failed to dream", e);
    }
}
//记录启用时机
public void setWhenToDream(@WhenToDream int whenToDream) {
    setEnabled(whenToDream != NEVER);

    switch (whenToDream) {
        case WHILE_CHARGING:
            setActivatedOnDock(false);
            setActivatedOnSleep(true);
            break;

        case WHILE_DOCKED:
            setActivatedOnDock(true);
            setActivatedOnSleep(false);
            break;

        case EITHER:
            setActivatedOnDock(true);
            setActivatedOnSleep(true);
            break;

        case NEVER:
        default:
            break;
    }
}

public void setActivatedOnDock(boolean value) {
    logd("setActivatedOnDock(%s)", value);
    setBoolean(Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK, value);
}

public void setActivatedOnSleep(boolean value) {
    logd("setActivatedOnSleep(%s)", value);
    setBoolean(Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP, value);
}

DreamBackend是对屏保管理的类，最终会通过IDreamManager来执行到DreamManagerService

启动屏保时，先获取系统安装的所有屏保，通过下列代码可以得到我们自己的开发的屏保

PackageManager pm = mContext.getPackageManager();
Intent dreamIntent = new Intent(DreamService.SERVICE_INTERFACE);
List<ResolveInfo> resolveInfos = pm.queryIntentServices(dreamIntent,
       PackageManager.GET_META_DATA);

然后再将屏保设置我们自己开发的

//QSSI.13\frameworks\base\services\core\java\com\android\server\dreams\DreamManagerService.java
public void setActiveDream(ComponentName dream) {
        logd("setActiveDream(%s)", dream);
        if (mDreamManager == null)
            return;
        try {
            ComponentName[] dreams = { dream };
            mDreamManager.setDreamComponents(dream == null ? null : dreams);
        } catch (RemoteException e) {
            Log.w(TAG, "Failed to set active dream to " + dream, e);
        }
    }

如果没有设置，系统会有一个默认的屏保，使用以下方法可以获取默认屏保

//QSSI.13\frameworks\base\services\core\java\com\android\server\dreams\DreamManagerService.java
public ComponentName getDefaultDream() {
        if (mDreamManager == null)
            return null;
        try {
            return mDreamManager.getDefaultDreamComponent();
        } catch (RemoteException e) {
            Log.w(TAG, "Failed to get default dream", e);
            return null;
        }
    }

然后用户有任何操作，屏保都会停止，实现逻辑是在DreamService里面的

//QSSI.13\frameworks\base\core\java\android\service\dreams\DreamService.java
/** {@inheritDoc} */
@Override
public boolean dispatchTouchEvent(MotionEvent event) {
    // TODO: create more flexible version of mInteractive that allows clicks
    // but finish()es on any other kind of activity
    if (!mInteractive && event.getActionMasked() == MotionEvent.ACTION_UP) {
        if (mDebug) Slog.v(mTag, "Waking up on touchEvent");
        wakeUp();
        return true;
    }
    return mWindow.superDispatchTouchEvent(event);
}
public final void wakeUp() {
    wakeUp(false);
}

private void wakeUp(boolean fromSystem) {
    if (mDebug) {
        Slog.v(mTag, "wakeUp(): fromSystem=" + fromSystem + ", mWaking=" + mWaking
                + ", mFinished=" + mFinished);
    }

    if (!mWaking && !mFinished) {
        mWaking = true;

        if (mActivity != null) {
            // During wake up the activity should be translucent to allow the application
            // underneath to start drawing. Normally, the WM animation system takes care of
            // this, but here we give the dream application some time to perform a custom exit
            // animation. If it uses a view animation, the WM doesn't know about it and can't
            // make the activity translucent in the normal way. Therefore, here we ensure that
            // the activity is translucent during wake up regardless of what animation is used
            // in onWakeUp().
            mActivity.convertToTranslucent(null, null);
        }

        // As a minor optimization, invoke the callback first in case it simply
        // calls finish() immediately so there wouldn't be much point in telling
        // the system that we are finishing the dream gently.
        onWakeUp();

        // Now tell the system we are waking gently, unless we already told
        // it we were finishing immediately.
        if (!fromSystem && !mFinished) {
            if (mActivity == null) {
                Slog.w(mTag, "WakeUp was called before the dream was attached.");
            } else {
                try {
                    mDreamManager.finishSelf(mDreamToken, false /*immediate*/);
                } catch (RemoteException ex) {
                    // system server died
                }
            }
        }
    }
}

屏保实现充电显示的逻辑在PowerManagerService里面

//QSSI.13\frameworks\base\services\core\java\com\android\server\power\PowerManagerService.java
系统设置启用和时机
//是否打开屏保
mDreamsEnabledSetting = (Settings.Secure.getIntForUser(resolver,
        Settings.Secure.SCREENSAVER_ENABLED,
        mDreamsEnabledByDefaultConfig ? 1 : 0,
        UserHandle.USER_CURRENT) != 0);
//仅充电时设置此值为1                 
mDreamsActivateOnSleepSetting = (Settings.Secure.getIntForUser(resolver,
        Settings.Secure.SCREENSAVER_ACTIVATE_ON_SLEEP,
        mDreamsActivatedOnSleepByDefaultConfig ? 1 : 0,
        UserHandle.USER_CURRENT) != 0);
  //基座充电时，此值为1
mDreamsActivateOnDockSetting = (Settings.Secure.getIntForUser(resolver,
        Settings.Secure.SCREENSAVER_ACTIVATE_ON_DOCK,
        mDreamsActivatedOnDockByDefaultConfig ? 1 : 0,
        UserHandle.USER_CURRENT) != 0);
        

PowerManagerService里面主要是处理电源相关的逻辑，所以updatePowerStateLocked()方法会时时调用，更新电源状态，然后根据不同状态进行不同处理

private void updatePowerStateLocked() {
    if (!mSystemReady || mDirty == 0 || mUpdatePowerStateInProgress) {
        return;
    }
    if (!Thread.holdsLock(mLock)) {
        Slog.wtf(TAG, "Power manager lock was not held when calling updatePowerStateLocked");
    }

    Trace.traceBegin(Trace.TRACE_TAG_POWER, "updatePowerState");
    mUpdatePowerStateInProgress = true;
    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;

            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 power state of all PowerGroups.
        final boolean powerGroupsBecameReady = updatePowerGroupsLocked(dirtyPhase2);

        // Phase 4: Update dream state (depends on power group ready signal).
        updateDreamLocked(dirtyPhase2, powerGroupsBecameReady);

        // 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!
        updateSuspendBlockerLocked();
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_POWER);
        mUpdatePowerStateInProgress = false;
    }
}

private boolean updateWakefulnessLocked(int dirty) {
    ....
      if (shouldNapAtBedTimeLocked()) {
            //判断是否需要屏保
            changed = dreamPowerGroupLocked(powerGroup, time,
                    Process.SYSTEM_UID, /* allowWake= */ false);
        } 
        ...
}

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

在updatePowerStateLocked方法里面，会更新屏保状态，调用updateDreamLocked方法

private void updateDreamLocked(int dirty, boolean powerGroupBecameReady) {
    if ((dirty & (DIRTY_WAKEFULNESS
            | DIRTY_USER_ACTIVITY
            | DIRTY_ACTUAL_DISPLAY_POWER_STATE_UPDATED
            | DIRTY_ATTENTIVE
            | DIRTY_WAKE_LOCKS
            | DIRTY_BOOT_COMPLETED
            | DIRTY_SETTINGS
            | DIRTY_IS_POWERED
            | DIRTY_STAY_ON
            | DIRTY_PROXIMITY_POSITIVE
            | DIRTY_BATTERY_STATE)) != 0 || powerGroupBecameReady) {
        if (areAllPowerGroupsReadyLocked()) {
            scheduleSandmanLocked();
        }
    }
}

scheduleSandmanLocked方法里面会发送一个消息

private void scheduleSandmanLocked() {
    if (!mSandmanScheduled) {
        mSandmanScheduled = true;
        for (int idx = 0; idx < mPowerGroups.size(); idx++) {
            final PowerGroup powerGroup = mPowerGroups.valueAt(idx);
            if (powerGroup.supportsSandmanLocked()) {
                Message msg = mHandler.obtainMessage(MSG_SANDMAN);
                msg.arg1 = powerGroup.getGroupId();
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, mClock.uptimeMillis());
            }
        }
    }
}

在PowerManagerHandler里面处理MSG_SANDMAN消息

private final class PowerManagerHandlerCallback implements Handler.Callback {
    @Override
    public boolean handleMessage(Message msg) {
        switch (msg.what) {
            case MSG_USER_ACTIVITY_TIMEOUT:
                handleUserActivityTimeout();
                break;
            case MSG_SANDMAN:
                handleSandman(msg.arg1);
                break;
            case MSG_SCREEN_BRIGHTNESS_BOOST_TIMEOUT:
                handleScreenBrightnessBoostTimeout();
                break;
            case MSG_CHECK_FOR_LONG_WAKELOCKS:
                checkForLongWakeLocks();
                break;
            case MSG_ATTENTIVE_TIMEOUT:
                handleAttentiveTimeout();
                break;
        }

        return true;
    }
}

主要处理逻辑是在handleSandman里面

private void handleSandman(int groupId) { // runs on handler thread
    // Handle preconditions.
    final boolean startDreaming;
    final int wakefulness;
    synchronized (mLock) {
        mSandmanScheduled = false;
        if (!mPowerGroups.contains(groupId)) {
            // Group has been removed.
            return;
        }
        final PowerGroup powerGroup = mPowerGroups.get(groupId);
        wakefulness = powerGroup.getWakefulnessLocked();
         //  首先判断是否可以启动屏保
        // 如果可以启动屏保且当前锁状态为WAKEFULNESS_NAPPING时，由表示需要启动屏保
        if (powerGroup.isSandmanSummonedLocked() && powerGroup.isReadyLocked()) {
            startDreaming = canDreamLocked(powerGroup) || canDozeLocked(powerGroup);
            powerGroup.setSandmanSummonedLocked(/* isSandmanSummoned= */ false);
        } else {
            startDreaming = false;
        }
    }

    // Start dreaming if needed.
    // We only control the dream on the handler thread, so we don't need to worry about
    // concurrent attempts to start or stop the dream.
    final boolean isDreaming;
    if (mDreamManager != null) {
        // Restart the dream whenever the sandman is summoned.
         //启动屏保
        if (startDreaming) {
            mDreamManager.stopDream(/* immediate= */ false,
                    "power manager request before starting dream" /*reason*/);
            mDreamManager.startDream(wakefulness == WAKEFULNESS_DOZING,
                    "power manager request" /*reason*/);
        }
        isDreaming = mDreamManager.isDreaming();
    } else {
        isDreaming = false;
    }

    // At this point, we either attempted to start the dream or no attempt will be made,
    // so stop holding the display suspend blocker for Doze.
    mDozeStartInProgress = false;

    // Update dream state.
    synchronized (mLock) {
        if (!mPowerGroups.contains(groupId)) {
            // Group has been removed.
            return;
        }

        // Remember the initial battery level when the dream started.
         //如果屏保正在运行且相关设置允许启动屏保，将状态设置为WAKEFULNESS_DREAMING
        if (startDreaming && isDreaming) {
            mDreamsBatteryLevelDrain = 0;
            if (wakefulness == WAKEFULNESS_DOZING) {
                Slog.i(TAG, "Dozing...");
            } else {
                Slog.i(TAG, "Dreaming...");
            }
        }

        // If preconditions changed, wait for the next iteration to determine
        // whether the dream should continue (or be restarted).
        final PowerGroup powerGroup = mPowerGroups.get(groupId);
        if (powerGroup.isSandmanSummonedLocked()
                || powerGroup.getWakefulnessLocked() != wakefulness) {
            return; // wait for next cycle
        }
....

    // Stop dream.
    if (isDreaming) {
        mDreamManager.stopDream(/* immediate= */ false, "power manager request" /*reason*/);
    }
}

从代码可以看出mWakefulness变量与是否启动屏保密切相关，当启动屏保时，mWakefulness状态发生变化

@GuardedBy("mLock")
int recalculateGlobalWakefulnessLocked() {
    int deviceWakefulness = WAKEFULNESS_ASLEEP;
    for (int i = 0; i < mPowerGroups.size(); i++) {
        final int wakefulness = mPowerGroups.valueAt(i).getWakefulnessLocked();
        if (wakefulness == WAKEFULNESS_AWAKE) {
            return WAKEFULNESS_AWAKE;
        } else if (wakefulness == WAKEFULNESS_DREAMING
                && (deviceWakefulness == WAKEFULNESS_ASLEEP
                || deviceWakefulness == WAKEFULNESS_DOZING)) {
                    //此状态下，屏保会被启动
            deviceWakefulness = WAKEFULNESS_DREAMING;
        } else if (wakefulness == WAKEFULNESS_DOZING
                && deviceWakefulness == WAKEFULNESS_ASLEEP) {
            deviceWakefulness = WAKEFULNESS_DOZING;
        }
    }

    return deviceWakefulness;
}

在停止屏保时，会依次调用handleDreamFinishedLocked –>wakeUpNoUpdateLocked

在wakeUpNoUpdateLocked方法里面，mWakefulness 状态发生变化