Analysis of manual screen-destroying process examples of PowerManagerService

// 
@Override // Binder call
public void goToSleep(long eventTime, int reason, int flags) {
    // ...
    try {
        sleepDisplayGroup(Display.DEFAULT_DISPLAY_GROUP, eventTime, reason, flags, uid);
    }
}
private void sleepDisplayGroup(int groupId, long eventTime, int reason, int flags,
        int uid) {
    synchronized (mLock) {
        // 1. Update wakefulness        if (sleepDisplayGroupNoUpdateLocked(groupId, eventTime, reason, flags, uid)) {
            // 2. Update power status            updatePowerStateLocked();
        }
    }
}

private boolean sleepDisplayGroupNoUpdateLocked(int groupId, long eventTime, int reason,
        int flags, int uid) {
    // ...
    try {
        // ...
        // Summoning the sleeping spirit is actually to save a state        (groupId, true);
        // Update wakefulness to WAKEFULNESS_DOZING        setWakefulnessLocked(groupId, WAKEFULNESS_DOZING, eventTime, uid, reason,
                /* opUid= */ 0, /* opPackageName= */ null, /* details= */ null);
        // If flags have PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE, update wakefulness to WAKEFULNESS_ASLEEP        if ((flags & PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE) != 0) {
            reallySleepDisplayGroupNoUpdateLocked(groupId, eventTime, uid);
        }
    }
    return true;
}

public abstract class PowerManagerInternal {
    /**
     * Wakefulness: The device is asleep.  It can only be awoken by a call to wakeUp().
     * The screen should be off or in the process of being turned off by the display controller.
     * The device typically passes through the dozing state first.
     */
    public static final int WAKEFULNESS_ASLEEP = 0;
    /**
     * Wakefulness: The device is fully awake.  It can be put to sleep by a call to goToSleep().
     * When the user activity timeout expires, the device may start dreaming or go to sleep.
     */
    public static final int WAKEFULNESS_AWAKE = 1;
    /**
     * Wakefulness: The device is dreaming.  It can be awoken by a call to wakeUp(),
     * which ends the dream.  The device goes to sleep when goToSleep() is called, when
     * the dream ends or when unplugged.
     * User activity may brighten the screen but does not end the dream.
     */
    public static final int WAKEFULNESS_DREAMING = 2;
    /**
     * Wakefulness: The device is dozing.  It is almost asleep but is allowing a special
     * low-power "doze" dream to run which keeps the display on but lets the application
     * processor be suspended.  It can be awoken by a call to wakeUp() which ends the dream.
     * The device fully goes to sleep if the dream cannot be started or ends on its own.
     */
    public static final int WAKEFULNESS_DOZING = 3;
}    

// 
private void updatePowerStateLocked() {
    if (!mSystemReady || mDirty == 0) {
        return;
    }
    if (!(mLock)) {
        (TAG, "Power manager lock was not held when calling updatePowerStateLocked");
    }
    (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 = ();
        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 display power state.
        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!
        updateSuspendBlockerLocked();
    } finally {
        (Trace.TRACE_TAG_POWER);
    }
}

// 
private void updateUserActivitySummaryLocked(long now, int dirty) {
    // ...
    // traversal display group id    for (int groupId : ()) {
        int groupUserActivitySummary = 0;
        long groupNextTimeout = 0;
        // Note that the dormant state cannot determine the user's behavior        if ((groupId) != WAKEFULNESS_ASLEEP) {
            final long lastUserActivityTime =
                    (groupId);
            final long lastUserActivityTimeNoChangeLights =
                    (
                            groupId);
            // 1. Get user behavior and timeout time            // The last user behavior time >= The last time the screen was awakened            if (lastUserActivityTime >= mLastWakeTime) {
                groupNextTimeout = lastUserActivityTime + screenOffTimeout - screenDimDuration;
                if (now < groupNextTimeout) { // There is no time to dim                    groupUserActivitySummary = USER_ACTIVITY_SCREEN_BRIGHT;
                } else {
                    groupNextTimeout = lastUserActivityTime + screenOffTimeout;
                    if (now < groupNextTimeout) { // In dim time period                        groupUserActivitySummary = USER_ACTIVITY_SCREEN_DIM;
                    }
                }
            }
            // ...
        }
        // 2. DisplayGroupPowerStateMapper Saves user behavior        (groupId,
                groupUserActivitySummary);
        }
    } // traversal display group id ends    // ...
    // 3. Regularly update power status    // This step decides to automatically shut down the screen    if (hasUserActivitySummary && nextTimeout >= 0) {
        scheduleUserInactivityTimeout(nextTimeout);
    }
}

private static final int USER_ACTIVITY_SCREEN_BRIGHT = 1 << 0;
private static final int USER_ACTIVITY_SCREEN_DIM = 1 << 1;
private static final int USER_ACTIVITY_SCREEN_DREAM = 1 << 2;

// 
int getDesiredScreenPolicyLocked(int groupId) {
    final int wakefulness = (groupId);
    final int wakeLockSummary = (groupId);
    if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
        return DisplayPowerRequest.POLICY_OFF;
    } else if (wakefulness == WAKEFULNESS_DOZING) {
        // The following conditions indicate that the dream manager has obtained the PowerManager.DOZE_WAKE_LOCK wake-up lock        if ((wakeLockSummary & WAKE_LOCK_DOZE) != 0) {
            return DisplayPowerRequest.POLICY_DOZE;
        }
        // mDozeAfterScreenOff defaults to false        // However, it can be set to true by SystemUI, indicating that the screen is first turned off and then enters the doze state        if (mDozeAfterScreenOff) {
            return DisplayPowerRequest.POLICY_OFF;
        }
    }
    if (mIsVrModeEnabled) {
        return DisplayPowerRequest.POLICY_VR;
    }
    if ((wakeLockSummary & WAKE_LOCK_SCREEN_BRIGHT) != 0
            || !mBootCompleted
            || ((groupId)
            & USER_ACTIVITY_SCREEN_BRIGHT) != 0
            || mScreenBrightnessBoostInProgress) {
        return DisplayPowerRequest.POLICY_BRIGHT;
    }
    return DisplayPowerRequest.POLICY_DIM;
}

// 
private void updateDreamLocked(int dirty, boolean displayBecameReady) {
    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 || displayBecameReady) {
        if (()) {
            // The final call handleSandman()            scheduleSandmanLocked();
        }
    }
}
private void handleSandman(int groupId) { // runs on handler thread
    // Handle preconditions.
    final boolean startDreaming;
    final int wakefulness;
    synchronized (mLock) {
        mSandmanScheduled = false;
        final int[] ids = ();
        if (!(ids, groupId)) {
            // Group has been removed.
            return;
        }
        wakefulness = (groupId);
        if ((wakefulness == WAKEFULNESS_DREAMING || wakefulness == WAKEFULNESS_DOZING) &&
                (groupId)
                && (groupId)) {
            // 1. Decide whether to start the dream            // canDreamLocked() indicates whether to start the screen saver in the dream            // canDozeLocked() indicates whether to start the doze component in the dream. The judgment condition is that wakefulness is WAKEFULNESS_DOZING            startDreaming = canDreamLocked(groupId) || canDozeLocked();
            // Reset the "Summoning Sleeping Elf" state            (groupId, false);
        } else {
            startDreaming = false;
        }
    }
    final boolean isDreaming;
    if (mDreamManager != null) {
        // Restart the dream whenever the sandman is summoned.
        if (startDreaming) {
            (false /*immediate*/);
            // 2. Start the dream doze component            (wakefulness == WAKEFULNESS_DOZING);
        }
        // Determine whether it is being started        isDreaming = ();
    } else {
        isDreaming = false;
    }
    mDozeStartInProgress = false;
    synchronized (mLock) {
        final int[] ids = ();
        if (!(ids, groupId)) {
            return;
        }
        if (startDreaming && isDreaming) {
            // ...
        }
        if ((groupId)
                || (groupId) != wakefulness) {
            return; // wait for next cycle
        }
        // Determine whether the dream should continue.
        long now = ();
        if (wakefulness == WAKEFULNESS_DREAMING) {
            // ...
        } else if (wakefulness == WAKEFULNESS_DOZING) {
            // 3. The doze component of the dream is being activated, then continue            if (isDreaming) {
                return; // continue dozing
            }
            // 4. The startup is not successful, or the doze component ends the dream by itself and enters the update wakefulness for WAKEFULNESS_ASLEEP process            // Doze has ended or will be stopped.  Update the power state.
            reallySleepDisplayGroupNoUpdateLocked(groupId, now, Process.SYSTEM_UID);
            updatePowerStateLocked();
        }
    }
    // ...
}

int getDesiredScreenPolicyLocked(int groupId) {
    final int wakefulness = (groupId);
    final int wakeLockSummary = (groupId);
    if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
        return DisplayPowerRequest.POLICY_OFF;
    } else if (wakefulness == WAKEFULNESS_DOZING) {
        // ...
    }
    // ...
}

// 
private void startDreamInternal(boolean doze) {
    final int userId = ();
    // Get doze dream or screensaver    final ComponentName dream = chooseDreamForUser(doze, userId);
    if (dream != null) {
        synchronized (mLock) {
            // Start dream, the doze dream started at this time,            startDreamLocked(dream, false /*isTest*/, doze, userId);
        }
    }
}
private ComponentName chooseDreamForUser(boolean doze, int userId) {
    if (doze) {
        ComponentName dozeComponent = getDozeComponent(userId);
        return validateDream(dozeComponent) ? dozeComponent : null;
    }
    // ...
}
private ComponentName getDozeComponent(int userId) {
    if (mForceAmbientDisplayEnabled || (userId)) {
        // Get config_dozeComponent from the configuration file        return (());
    } else {
        return null;
    }
}

// 
private void startDreamLocked(final ComponentName name,
        final boolean isTest, final boolean canDoze, final int userId) {
    // ...
    final Binder newToken = new Binder();
    mCurrentDreamToken = newToken;
    mCurrentDreamName = name;
    mCurrentDreamIsTest = isTest;
    mCurrentDreamCanDoze = canDoze;
    mCurrentDreamUserId = userId;
     wakeLock = mPowerManager
            .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "startDream");
    // WakeLockThe #wrap() method ensures that the lock is acquired before the Runnbale is executed and the lock is released after the Runnable is executed. // That is, keep the CPU running until the doze dream is finished starting.    ((() -> {
        (true);
        if (!(mAmbientDisplayComponent)) {
            (DreamManagerEvent.DREAM_START);
        }
        // Turn on dream        (newToken, name, isTest, canDoze, userId, wakeLock);
    }));
}

// 
public void startDream(Binder token, ComponentName name,
        boolean isTest, boolean canDoze, int userId,  wakeLock) {
    stopDream(true /*immediate*/, "starting new dream");
    try {
        // In fact, it is to send Intent.ACTION_CLOSE_SYSTEM_DIALOGS broadcast        // Close the notification shade. No need to send to all, but better to be explicit.
        (mCloseNotificationShadeIntent, );
        // 1. Create a record dream record        // Note that DreamRecord implements ServiceConnection        mCurrentDream = new DreamRecord(token, name, isTest, canDoze, userId, wakeLock);
        mDreamStartTime = ();
        (mContext,
                 ?  : );
        Intent intent = new Intent(DreamService.SERVICE_INTERFACE);
        (name);
        (Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
        try {
            // 2. Connect to Service            if (!(intent, mCurrentDream,
                    Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE,
                    new UserHandle(userId))) {
                (TAG, "Unable to bind dream service: " + intent);
                stopDream(true /*immediate*/, "bindService failed");
                return;
            }
        } catch (SecurityException ex) {
            (TAG, "Unable to bind dream service: " + intent, ex);
            stopDream(true /*immediate*/, "unable to bind service: SecExp.");
            return;
        }
         = true;
        (mStopUnconnectedDreamRunnable, DREAM_CONNECTION_TIMEOUT);
    } finally {
        (Trace.TRACE_TAG_POWER);
    }
}

// 
public void onServiceConnected(ComponentName name, final IBinder service) {
    (() -> {
        mConnected = true;
        if (mCurrentDream ==  && mService == null) {
            attach((service));
            // Wake lock will be released once dreaming starts.
        } else {
            releaseWakeLockIfNeeded();
        }
    });
}
private void attach(IDreamService service) {
    try {
        // DreamRecord Monitor Service Life and Death        ().linkToDeath(mCurrentDream, 0);
        // The third parameter is a binder callback, used to receive the result        (, ,
                );
    } catch (RemoteException ex) {
        (TAG, "The dream service died unexpectedly.", ex);
        stopDream(true /*immediate*/, "attach failed");
        return;
    }
     = service;
    // Send Intent.ACTION_DREAMING_STARTED broadcast    if (!) {
        (mDreamingStartedIntent, );
         = true;
    }
}

public class DozeService extends DreamService
        implements , RequestDoze, PluginListener<DozeServicePlugin> {
    @Override
    public void onCreate() {
        ();
        // Set to windowless mode        setWindowless(true);
        (this, , false /* allowMultiple */);
        DozeComponent dozeComponent = (this);
        mDozeMachine = ();
    }
}    

private void attach(IBinder dreamToken, boolean canDoze, IRemoteCallback started) {
    // ...
    mDreamToken = dreamToken;
    mCanDoze = canDoze;
    // Only doze dream can have no windows    if (mWindowless && !mCanDoze) {
        throw new IllegalStateException("Only doze dreams can be windowless");
    }
    mDispatchAfterOnAttachedToWindow = () -> {
        if (mWindow != null || mWindowless) {
            mStarted = true;
            try {
                // Implemented by subclasses                onDreamingStarted();
            } finally {
                try {
                    (null);
                } catch (RemoteException e) {
                    throw ();
                }
            }
        }
    };
    if (!mWindowless) {
        // ...
    } else {
        // In the absence of window, call onDreamingStarted() directly        ();
    }
}

// 
public void onDreamingStarted() {
    ();
    ();
    // Call the parent class method    startDozing();
    if (mDozePlugin != null) {
        ();
    }
}

public void startDozing() {
    if (mCanDoze && !mDozing) {
        mDozing = true;
        updateDoze();
    }
}
private void updateDoze() {
    if (mDreamToken == null) {
        (TAG, "Updating doze without a dream token.");
        return;
    }
    if (mDozing) {
        try {
            // Notify the dream manager that the service is starting the doze function            (mDreamToken, mDozeScreenState, mDozeScreenBrightness);
        } catch (RemoteException ex) {
            // system server died
        }
    }
}

// 
private void startDozingInternal(IBinder token, int screenState,
        int screenBrightness) {
    synchronized (mLock) {
        if (mCurrentDreamToken == token && mCurrentDreamCanDoze) {
            mCurrentDreamDozeScreenState = screenState;
            mCurrentDreamDozeScreenBrightness = screenBrightness;
            // 1. Notify PowerManagerService to save the screen status and screen brightness in doze state            (
                    screenState, screenBrightness);
            if (!mCurrentDreamIsDozing) {
                mCurrentDreamIsDozing = true;
                //2. Get PowerManager.DOZE_WAKE_LOCK wake-up lock                ();
            }
        }
    }
}

// 
int getDesiredScreenPolicyLocked(int groupId) {
    final int wakefulness = (groupId);
    final int wakeLockSummary = (groupId);
    if (wakefulness == WAKEFULNESS_ASLEEP || sQuiescent) {
        return DisplayPowerRequest.POLICY_OFF;
    } else if (wakefulness == WAKEFULNESS_DOZING) {
        // The following conditions indicate that the dream manager has obtained the PowerManager.DOZE_WAKE_LOCK wake-up lock        if ((wakeLockSummary & WAKE_LOCK_DOZE) != 0) {
            return DisplayPowerRequest.POLICY_DOZE;
        }
        if (mDozeAfterScreenOff) {
            return DisplayPowerRequest.POLICY_OFF;
        }
    }
    // ...
}