This class use {@link #mLock} to synchronize access to internal state. Methods that require * {@link #mLock} to be held should have "LU" suffix in the name. * *
Important: Synchronized code, i.e. one executed inside a synchronized(mLock) * block or inside LU method, should only access internal state of this class or make calls to * other LU methods. Non-LU method calls or calls to external classes are discouraged as they * may cause lock inversion. */ class UserController implements Handler.Callback { private static final String TAG = UserController.class.getSimpleName(); // Amount of time we wait for observers to handle a user switch before // giving up on them and dismissing the user switching dialog. static final int DEFAULT_USER_SWITCH_TIMEOUT_MS = 3 * 1000; /** * Amount of time we wait for an observer to handle a user switch before we log a warning. This * wait time is per observer. */ private static final int LONG_USER_SWITCH_OBSERVER_WARNING_TIME_MS = 500; // ActivityManager thread message constants static final int REPORT_USER_SWITCH_MSG = 10; static final int CONTINUE_USER_SWITCH_MSG = 20; static final int USER_SWITCH_TIMEOUT_MSG = 30; static final int START_PROFILES_MSG = 40; static final int USER_START_MSG = 50; static final int USER_CURRENT_MSG = 60; static final int FOREGROUND_PROFILE_CHANGED_MSG = 70; static final int REPORT_USER_SWITCH_COMPLETE_MSG = 80; static final int USER_SWITCH_CALLBACKS_TIMEOUT_MSG = 90; static final int USER_UNLOCK_MSG = 100; static final int USER_UNLOCKED_MSG = 105; static final int REPORT_LOCKED_BOOT_COMPLETE_MSG = 110; static final int START_USER_SWITCH_FG_MSG = 120; static final int COMPLETE_USER_SWITCH_MSG = 130; static final int USER_COMPLETED_EVENT_MSG = 140; static final int SCHEDULE_STOP_BACKGROUND_USER_MSG = 150; static final int SCHEDULE_JUDGE_FATE_OF_BACKGROUND_USER_MSG = 160; static final int USER_SWITCHING_DIALOG_ANIMATION_TIMEOUT_MSG = 170; private static final int NO_ARG2 = 0; // Message constant to clear {@link UserJourneySession} from {@link mUserIdToUserJourneyMap} if // the user journey, defined in the UserLifecycleJourneyReported atom for statsd, is not // complete within {@link USER_JOURNEY_TIMEOUT}. static final int CLEAR_USER_JOURNEY_SESSION_MSG = 200; // Wait time for completing the user journey. If a user journey is not complete within this // time, the remaining lifecycle events for the journey would not be logged in statsd. // Timeout set for 90 seconds. private static final int USER_JOURNEY_TIMEOUT_MS = 90_000; // UI thread message constants static final int START_USER_SWITCH_UI_MSG = 1000; /** * If a callback wasn't called within USER_SWITCH_CALLBACKS_TIMEOUT_MS after * {@link #getUserSwitchTimeoutMs}, an error is reported. Usually it indicates a problem in the * observer when it never calls back. */ private static final int USER_SWITCH_CALLBACKS_TIMEOUT_MS = 5 * 1000; /** * Time after last scheduleOnUserCompletedEvent() call at which USER_COMPLETED_EVENT_MSG will be * scheduled (although it may fire sooner instead). * When it fires, {@link #reportOnUserCompletedEvent} will be processed. */ // TODO(b/197344658): Increase to 10s or 15s once we have a switch-UX-is-done invocation too. private static final int USER_COMPLETED_EVENT_DELAY_MS = 5 * 1000; /** * If a user has an alarm in the next this many milliseconds, avoid stopping it due to * scheduled background stopping. */ private static final long TIME_BEFORE_USERS_ALARM_TO_AVOID_STOPPING_MS = 60 * 60_000; // 60 mins /** * If a background user stop is requested, but doing so right now isn't suitable (e.g. because * it is currently playing audio) and we have to reschedule that background stop, we should * schedule that stop for this many seconds from now. */ private static final int POSTPONEMENT_TIME_FOR_BACKGROUND_USER_STOP_SECS = 10 * 60; // 10 mins /** * How many seconds to wait until checking whether there has been lmk activity, as required when * passing judgement on whether to automatically stop a background user. * This is actually used for two distinct (but related) purposes: *
This is NOT directly related to config_backgroundUserConsideredDispensableTimeSecs, which * is generally a much longer time indicating when the background user is declared dispensable. */ private static final long POLLING_TIME_FOR_JUDGING_BACKGROUND_USER_SECS = 10 * 60; // 10 mins @VisibleForTesting static final String EXCEPTION_TEMPLATE_CANNOT_START_USER_WHEN_NOT_READY = "Trying to start user %d before ready"; /** * Maximum number of users we allow to be running at a time, including system user. * *
This parameter only affects how many background users will be stopped when * switching to, or starting, a new user. It does not prevent starting a user. * *
Note: This is a soft limit; the actual number of running users can exceed mMaxRunningUsers * in several situations. For example:
Guarantees (by the end of startUser): *
NOTE: it lists all profiles, regardless of their running state (i.e., they're in * this list even if not running). */ @GuardedBy("mLock") private int[] mCurrentProfileIds = new int[] {}; /** * Mapping from each known user ID to the profile group ID it is associated with. *
Users not present in this array have a profile group of NO_PROFILE_GROUP_ID. *
Users present in this array do not have a profile group of NO_PROFILE_GROUP_ID. * *
For better or worse, this class sometimes assumes that the profileGroupId of a parent user
* is always identical with its userId. If that ever becomes false, this class needs updating.
*/
@GuardedBy("mLock")
private final SparseIntArray mUserProfileGroupIds = new SparseIntArray();
/**
* Registered observers of the user switching mechanics.
*/
private final RemoteCallbackList Note: Even if this is false for the device as a whole, it is possible some users may
* individually allow delayed locking, as specified by
* {@link UserProperties#getAllowStoppingUserWithDelayedLocking()}.
*/
@GuardedBy("mLock")
private boolean mDelayUserDataLocking;
/**
* Users are only allowed to be unlocked after boot complete.
*/
private volatile boolean mAllowUserUnlocking;
/**
* Keep track of last active users for delayUserDataLocking.
* The most recently stopped user with delayed locking is placed in front, while the least
* recently stopped user in back.
*/
@GuardedBy("mLock")
private final ArrayList It's useful to ignore external operations (i.e., originated outside {@code system_server},
* like from {@code adb shell am switch-user})) that could happen before such call is made and
* the system is ready.
*/
@GuardedBy("mLock")
private boolean mInitialized;
/**
* Defines the behavior of whether the background users should be stopped when the foreground
* user is switched.
*/
@GuardedBy("mLock")
private @StopUserOnSwitch int mStopUserOnSwitch = STOP_USER_ON_SWITCH_DEFAULT;
/** @see #getLastUserUnlockingUptime */
private volatile long mLastUserUnlockingUptime = 0;
/**
* Pending user starts waiting for shutdown step to complete.
*/
@GuardedBy("mLock")
private final List For example, we don't abort shutdown for users whose processes have already been stopped
* due to {@link #isEarlyPackageKillEnabledForUserSwitch(int, int)}.
*/
@GuardedBy("mLock")
private final ArraySet The primary use case of this method is for {@link com.android.server.SystemService}
* classes to call this API in their
* {@link com.android.server.SystemService#onUserSwitching} method implementation to prevent
* restarting any of the previous user's processes that will be killed during the user switch.
*/
boolean isEarlyPackageKillEnabledForUserSwitch(int fromUserId, int toUserId) {
// NOTE: The logic in this method could be extended to cover other cases where
// the previous user is also stopped like: guest users, ephemeral users,
// and users with DISALLOW_RUN_IN_BACKGROUND. Currently, this is not done
// because early killing is not enabled for these cases by default.
if (fromUserId == UserHandle.USER_SYSTEM) {
return false;
}
return isStopUserOnSwitchEnabled();
}
void finishUserSwitch(UserState uss) {
// This call holds the AM lock so we post to the handler.
mHandler.post(() -> {
finishUserBoot(uss);
startProfiles();
stopExcessRunningUsers();
});
}
/** Adds a user to mUserLru, moving it to the end of the list if it was already present. */
private void addUserToUserLru(@UserIdInt int userId) {
synchronized (mLock) {
final Integer userIdObj = userId;
mUserLru.remove(userIdObj);
mUserLru.add(userIdObj);
// Now also move the user's parent to the end (if applicable).
Integer parentIdObj = mUserProfileGroupIds.get(userId, UserInfo.NO_PROFILE_GROUP_ID);
if (parentIdObj != UserInfo.NO_PROFILE_GROUP_ID && !parentIdObj.equals(userIdObj)
&& mUserLru.remove(parentIdObj)) {
mUserLru.add(parentIdObj);
}
}
}
/** Returns a list of running users, in order of when they were started (oldest first). */
@GuardedBy("mLock")
@VisibleForTesting
List The logout process involves two main steps:
*
* The logout operation will fail under the following conditions:
*
* To be called from {@link com.android.server.am.ActivityManagerService}.
*
* @param userId the id of the profile user to start.
* @param evenWhenDisabled whether the profile should be started if it's not enabled yet
* (most callers should pass {@code false}, except when starting the profile while it's
* being provisioned).
* @param unlockListener listener to be informed when the profile has started and unlocked.
*
* @return {@code true} if the operation was successful.
*
* @throws IllegalArgumentException if the user doesn't exist or is not a profile.
*/
@RequiresPermission(anyOf = {android.Manifest.permission.MANAGE_USERS,
android.Manifest.permission.INTERACT_ACROSS_USERS_FULL})
boolean startProfile(@UserIdInt int userId, boolean evenWhenDisabled,
@Nullable IProgressListener unlockListener) {
if (mInjector.checkCallingPermission(android.Manifest.permission.MANAGE_USERS)
== PackageManager.PERMISSION_DENIED && mInjector.checkCallingPermission(
android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
== PackageManager.PERMISSION_DENIED) {
throw new SecurityException(
"You either need MANAGE_USERS or INTERACT_ACROSS_USERS_FULL permission to "
+ "start a profile");
}
final UserInfo userInfo = getUserInfo(userId);
if (userInfo == null || !userInfo.isProfile()) {
throw new IllegalArgumentException("User " + userId + " is not a profile");
}
if (!userInfo.isEnabled() && !evenWhenDisabled) {
Slogf.w(TAG, "Cannot start disabled profile #%d", userId);
return false;
}
return startUserNoChecks(userId, Display.DEFAULT_DISPLAY,
USER_START_MODE_BACKGROUND_VISIBLE, unlockListener);
}
boolean startUserInBackgroundTemporarily(@UserIdInt int userId, int durationSecs) {
synchronized (mLock) {
if (!mReady) {
return false;
}
}
return startUserNoChecks(userId, Display.DEFAULT_DISPLAY, USER_START_MODE_BACKGROUND,
durationSecs, /* unlockListener= */ null);
}
@VisibleForTesting
boolean startUser(@UserIdInt int userId, @UserStartMode int userStartMode) {
return startUser(userId, userStartMode, /* unlockListener= */ null);
}
/**
* Start user, if its not already running.
*
* The user will be brought to the foreground, if {@code userStartMode} parameter is
* set to {@link UserManagerInternal#USER_START_MODE_FOREGROUND}
* When starting the user, multiple intents will be broadcast in the following order: This call will trigger the usual "user started" lifecycle events (i.e., `SystemService`
* callbacks and app intents), plus a call to
* {@link UserManagerInternal.UserVisibilityListener#onUserVisibilityChanged(int, boolean)} if
* the user visibility changed. Notice that the visibility change is independent of the user
* workflow state, and they can mismatch in some corner events (for example, if the user was
* already running in the background but not associated with a display, this call for that user
* would not trigger any lifecycle event but would trigger {@code onUserVisibilityChanged}).
*
* See {@link ActivityManager#startUserInBackgroundOnSecondaryDisplay(int, int)} for more
* semantics.
*
* @param userId user to be started
* @param displayId display where the user will be visible
* @param unlockListener Listener to be informed when the user has started and unlocked.
*
* @return whether the user was started
*/
boolean startUserVisibleOnDisplay(@UserIdInt int userId, int displayId,
@Nullable IProgressListener unlockListener) {
checkCallingHasOneOfThosePermissions("startUserOnDisplay",
MANAGE_USERS, INTERACT_ACROSS_USERS);
try {
return startUserNoChecks(userId, displayId, USER_START_MODE_BACKGROUND_VISIBLE,
unlockListener);
} catch (RuntimeException e) {
Slogf.e(TAG, "startUserOnSecondaryDisplay(%d, %d) failed: %s", userId, displayId, e);
return false;
}
}
private boolean startUserNoChecks(@UserIdInt int userId, int displayId,
@UserStartMode int userStartMode, @Nullable IProgressListener unlockListener) {
return startUserNoChecks(userId, displayId, userStartMode, -1, unlockListener);
}
private boolean startUserNoChecks(@UserIdInt int userId, int displayId,
@UserStartMode int userStartMode, int autoStopUserInSecs,
@Nullable IProgressListener unlockListener) {
TimingsTraceAndSlog t = new TimingsTraceAndSlog();
t.traceBegin("UserController.startUser-" + userId
+ (displayId == Display.DEFAULT_DISPLAY ? "" : "-display-" + displayId)
+ "-" + (userStartMode == USER_START_MODE_FOREGROUND ? "fg" : "bg")
+ (autoStopUserInSecs > 0 ? "-for-" + autoStopUserInSecs + "s" : "")
+ "-start-mode-" + userStartMode);
try {
return startUserInternal(userId, displayId, userStartMode, autoStopUserInSecs,
unlockListener, t);
} finally {
t.traceEnd();
}
}
private boolean startUserInternal(@UserIdInt int userId, int displayId,
@UserStartMode int userStartMode, int autoStopUserInSecs,
@Nullable IProgressListener unlockListener, TimingsTraceAndSlog t) {
synchronized (mLock) {
if (DEBUG_MU) {
Slogf.i(TAG, "Starting user %d on display %d with mode %s (when ready=%b)", userId,
displayId, userStartModeToString(userStartMode), mReady);
}
// NOTE: for now this is the only place that's mReady, but if it's needed in others,
// this check should be encapsulated into a private helper.
Preconditions.checkState(mReady, EXCEPTION_TEMPLATE_CANNOT_START_USER_WHEN_NOT_READY,
userId);
}
boolean foreground = userStartMode == USER_START_MODE_FOREGROUND;
boolean onSecondaryDisplay = displayId != Display.DEFAULT_DISPLAY;
if (onSecondaryDisplay) {
Preconditions.checkArgument(!foreground, "Cannot start user %d in foreground AND "
+ "on secondary display (%d)", userId, displayId);
}
if (autoStopUserInSecs > 0) {
Preconditions.checkArgument(userStartMode == USER_START_MODE_BACKGROUND,
"Cannot auto-stop a non-bg (%d) user %d in %d s",
userStartMode, userId, autoStopUserInSecs);
}
EventLog.writeEvent(EventLogTags.UC_START_USER_INTERNAL, userId, foreground ? 1 : 0,
displayId);
final int callingUid = Binder.getCallingUid();
final int callingPid = Binder.getCallingPid();
final long ident = Binder.clearCallingIdentity();
try {
t.traceBegin("getStartedUserState");
final int oldCurrentUserId = getCurrentUserId();
if (oldCurrentUserId == userId) {
// The user we're requested to start is already the current user.
final UserState state = getStartedUserState(userId);
if (state == null) {
Slogf.wtf(TAG, "Current user has no UserState");
// continue starting.
} else {
if (userId == UserHandle.USER_SYSTEM && state.state == STATE_BOOTING) {
// system user start explicitly requested. should continue starting as it
// is not in running state.
} else {
if (state.state == STATE_RUNNING_UNLOCKED) {
// We'll skip all later code, so we must tell listener it's already
// unlocked.
notifyFinished(userId, unlockListener);
}
t.traceEnd(); //getStartedUserState
return true;
}
}
}
t.traceEnd(); //getStartedUserState
if (foreground) {
t.traceBegin("clearAllLockedTasks");
mInjector.clearAllLockedTasks("startUser");
t.traceEnd();
}
t.traceBegin("getUserInfo");
final UserInfo userInfo = getUserInfo(userId);
t.traceEnd();
if (userInfo == null) {
Slogf.w(TAG, "No user info for user #" + userId);
return false;
}
if (foreground && userInfo.isProfile()) {
Slogf.w(TAG, "Cannot switch to User #" + userId + ": not a full user");
return false;
}
if ((foreground || onSecondaryDisplay) && userInfo.preCreated) {
Slogf.w(TAG, "Cannot start pre-created user #" + userId + " in foreground or on "
+ "secondary display");
return false;
}
t.traceBegin("assignUserToDisplayOnStart");
int result = mInjector.getUserManagerInternal().assignUserToDisplayOnStart(userId,
userInfo.profileGroupId, userStartMode, displayId);
t.traceEnd();
if (result == USER_ASSIGNMENT_RESULT_FAILURE) {
Slogf.e(TAG, "%s user(%d) / display (%d) assignment failed: %s",
userStartModeToString(userStartMode), userId, displayId,
userAssignmentResultToString(result));
return false;
}
boolean needStart = false;
boolean updateUmState = false;
UserState uss;
// If the user we are switching to is not currently started, then
// we need to start it now.
t.traceBegin("updateStartedUserArrayStarting");
synchronized (mLock) {
uss = mStartedUsers.get(userId);
if (uss == null) {
uss = new UserState(UserHandle.of(userId));
uss.mUnlockProgress.addListener(new UserProgressListener());
mStartedUsers.put(userId, uss);
updateStartedUserArrayLU();
needStart = true;
updateUmState = true;
} else if (uss.state == UserState.STATE_SHUTDOWN
|| mDoNotAbortShutdownUserIds.contains(userId)) {
Slogf.i(TAG, "User #" + userId
+ " is shutting down - will start after full shutdown");
// TODO(b/416746742): Don't we need to track the displayId too?
mPendingUserStarts.add(new PendingUserStart(userId, userStartMode,
autoStopUserInSecs, unlockListener));
t.traceEnd(); // updateStartedUserArrayStarting
return true;
}
}
// No matter what, the fact that we're requested to start the user (even if it is
// already running) puts it towards the end of the mUserLru list.
addUserToUserLru(userId);
if (unlockListener != null) {
uss.mUnlockProgress.addListener(unlockListener);
}
t.traceEnd(); // updateStartedUserArrayStarting
if (updateUmState) {
t.traceBegin("setUserState");
mInjector.getUserManagerInternal().setUserState(userId, uss.state);
t.traceEnd();
}
if (foreground) {
// Make sure the old user is no longer considering the display to be on.
mInjector.reportGlobalUsageEvent(UsageEvents.Event.SCREEN_NON_INTERACTIVE);
synchronized (mLock) {
mCurrentUserId = userId;
ActivityManager.invalidateGetCurrentUserIdCache();
}
}
UserState finalUss = uss;
boolean finalNeedStart = needStart;
final Runnable continueStartUserInternal = () -> continueStartUserInternal(userInfo,
oldCurrentUserId, userStartMode, autoStopUserInSecs, finalUss, finalNeedStart,
callingUid, callingPid);
if (foreground) {
mHandler.post(() -> dispatchOnBeforeUserSwitching(userId, () ->
mHandler.post(continueStartUserInternal)));
} else {
continueStartUserInternal.run();
}
} finally {
Binder.restoreCallingIdentity(ident);
}
return true;
}
private void continueStartUserInternal(UserInfo userInfo, int oldCurUserId,
int userStartMode, int autoStopUserInSecs, UserState uss, boolean needStart,
int callingUid, int callingPid) {
final TimingsTraceAndSlog t = new TimingsTraceAndSlog();
final boolean foreground = userStartMode == USER_START_MODE_FOREGROUND;
final int userId = userInfo.id;
t.traceBegin("updateConfigurationAndProfileIds");
if (foreground) {
boolean userSwitchUiEnabled;
synchronized (mLock) {
userSwitchUiEnabled = mUserSwitchUiEnabled;
}
mInjector.updateUserConfiguration();
// NOTE: updateProfileRelatedCaches() is called on both if and else parts, ideally
// it should be moved outside, but for now it's not as there are many calls to
// external components here afterwards
updateProfileRelatedCaches();
if (DesktopExperienceFlags.ENABLE_APPLY_DESK_ACTIVATION_ON_USER_SWITCH.isTrue()) {
mInjector.getWindowManager().prepareUserStart(userId);
} else {
mInjector.getWindowManager().setCurrentUser(userId);
}
mInjector.reportCurWakefulnessUsageEvent();
// Once the internal notion of the active user has switched, we lock the device
// with the option to show the user switcher on the keyguard.
if (userSwitchUiEnabled) {
mInjector.getWindowManager().setSwitchingUser(true);
// Only lock if the user has a secure keyguard PIN/Pattern/Pwd
if (mInjector.getKeyguardManager().isDeviceSecure(userId)) {
Slogf.d(TAG, "Locking the device before moving on with the user switch");
mInjector.lockDeviceNowAndWaitForKeyguardShown();
}
}
} else {
updateProfileRelatedCaches();
// We are starting a non-foreground user. They have already been added to the end
// of mUserLru, so we need to ensure that the foreground user isn't displaced.
addUserToUserLru(mCurrentUserId);
}
t.traceEnd();
// Make sure user is in the started state. If it is currently
// stopping, we need to knock that off.
if (uss.state == UserState.STATE_STOPPING) {
t.traceBegin("updateStateStopping");
// If we are stopping, we haven't sent ACTION_SHUTDOWN,
// so we can just fairly silently bring the user back from
// the almost-dead.
uss.setState(uss.lastState);
mInjector.getUserManagerInternal().setUserState(userId, uss.state);
synchronized (mLock) {
updateStartedUserArrayLU();
}
needStart = true;
t.traceEnd();
} else if (uss.state == UserState.STATE_SHUTDOWN) {
t.traceBegin("updateStateShutdown");
// This means ACTION_SHUTDOWN has been sent, so we will
// need to treat this as a new boot of the user.
uss.setState(UserState.STATE_BOOTING);
mInjector.getUserManagerInternal().setUserState(userId, uss.state);
synchronized (mLock) {
updateStartedUserArrayLU();
}
needStart = true;
t.traceEnd();
}
if (uss.state == UserState.STATE_BOOTING) {
t.traceBegin("updateStateBooting");
// Give user manager a chance to propagate user restrictions
// to other services and prepare app storage
mInjector.getUserManager().onBeforeStartUser(userId);
// Booting up a new user, need to tell system services about it.
// Note that this is on the same handler as scheduling of broadcasts,
// which is important because it needs to go first.
mHandler.sendMessage(mHandler.obtainMessage(USER_START_MSG, userId, NO_ARG2));
t.traceEnd();
}
if (android.multiuser.Flags.scheduleStopOfBackgroundUserByDefault()) {
if (userStartMode != USER_START_MODE_BACKGROUND || isCurrentProfile(userId)) {
// User isn't (or is no longer) a background user. Clear any prior plans to stop it.
clearAnyPlansForStoppingBackgroundUser(userId);
} else {
// User is a background user. If it's supposed to only run temporarily, schedule it
// for stopping; otherwise, schedule it for eventual background user judgement.
if (autoStopUserInSecs > 0 && (needStart || isUserScheduledForStopping(userId))) {
// Request is for a temp start and user wasn't already bg-running-in-perpetuity.
scheduleStopOfBackgroundUser(userId, autoStopUserInSecs);
} else {
// This wasn't designated a temporary background run. So clear any previous
// scheduled stops, and initiate a new inactivity trial.
mHandler.removeEqualMessages(SCHEDULE_STOP_BACKGROUND_USER_MSG,
Integer.valueOf(userId));
initiateJudgeFateOfBackgroundUser(userId);
}
}
} else if (android.multiuser.Flags.scheduleStopOfBackgroundUser()) {
if (userStartMode == USER_START_MODE_BACKGROUND && !isCurrentProfile(userId) &&
autoStopUserInSecs > 0) {
if (!needStart
&& !mHandler.hasEqualMessages(SCHEDULE_STOP_BACKGROUND_USER_MSG,
Integer.valueOf(userId))) {
Slogf.d(TAG, "Not scheduling background user stop: user %d is already running"
+ " in background in perpetuity, so keep it that way", userId);
} else {
scheduleStopOfBackgroundUser(userId, autoStopUserInSecs);
}
} else {
// This start shouldn't be scheduled for stopping. Clear existing scheduled stops.
mHandler.removeEqualMessages(SCHEDULE_STOP_BACKGROUND_USER_MSG,
Integer.valueOf(userId));
}
}
t.traceBegin("sendMessages");
if (foreground) {
mHandler.sendMessage(mHandler.obtainMessage(USER_CURRENT_MSG, userId, oldCurUserId));
mHandler.removeMessages(REPORT_USER_SWITCH_MSG);
mHandler.removeMessages(USER_SWITCH_TIMEOUT_MSG);
mHandler.sendMessage(mHandler.obtainMessage(REPORT_USER_SWITCH_MSG,
oldCurUserId, userId, uss));
mHandler.sendMessageDelayed(mHandler.obtainMessage(USER_SWITCH_TIMEOUT_MSG,
oldCurUserId, userId, uss), getUserSwitchTimeoutMs());
}
if (userInfo.preCreated) {
needStart = false;
}
// In most cases, broadcast for the system user starting/started is sent by
// ActivityManagerService#systemReady(). However on some HSUM devices (e.g. tablets)
// the user switches from the system user to a secondary user while running
// ActivityManagerService#systemReady(), thus broadcast is not sent for the system user.
// Therefore we send the broadcast for the system user here as well in HSUM.
// TODO(b/266158156): Improve/refactor the way broadcasts are sent for the system user
// in HSUM. Ideally it'd be best to have one single place that sends this notification.
final boolean isSystemUserInHeadlessMode = (userId == UserHandle.USER_SYSTEM)
&& mInjector.isHeadlessSystemUserMode();
if (needStart || isSystemUserInHeadlessMode) {
sendUserStartedBroadcast(userId, callingUid, callingPid);
}
t.traceEnd();
if (foreground) {
t.traceBegin("moveUserToForeground");
if (DesktopExperienceFlags.ENABLE_APPLY_DESK_ACTIVATION_ON_USER_SWITCH.isTrue()) {
mInjector.getWindowManager().startUserSwitchTransition(oldCurUserId, userId, uss);
} else {
mInjector.getWindowManager().moveUserToForeground(userId, uss,
"continueStartUserInternal");
}
EventLogTags.writeAmSwitchUser(userId);
t.traceEnd();
} else {
t.traceBegin("finishUserBoot");
finishUserBoot(uss);
t.traceEnd();
if (android.multiuser.Flags.stopExcessForBackgroundStarts()) {
// We're willing to let this background start exceed maxRunningUsers if it's
// just an explicitly temporary thing, but otherwise, trim the excess.
final boolean shouldStopExcessRunningUsers = autoStopUserInSecs <= 0;
if (shouldStopExcessRunningUsers) {
mHandler.post(() -> stopExcessRunningUsers(userId));
}
}
}
if (needStart || isSystemUserInHeadlessMode) {
t.traceBegin("sendRestartBroadcast");
sendUserStartingBroadcast(userId, callingUid, callingPid);
t.traceEnd();
}
}
/**
* Start user, if it's not already running, and bring it to foreground.
*/
void startUserInForeground(@UserIdInt int targetUserId) {
if (android.multiuser.Flags.setPowerModeDuringUserSwitch()) {
mInjector.setPerformancePowerMode(true);
}
boolean success = startUser(targetUserId, USER_START_MODE_FOREGROUND);
if (!success) {
mInjector.getWindowManager().setSwitchingUser(false);
dismissUserSwitchDialog(this::endUserSwitch);
}
}
boolean unlockUser(@UserIdInt int userId, @Nullable IProgressListener listener) {
checkCallingPermission(INTERACT_ACROSS_USERS_FULL, "unlockUser");
EventLog.writeEvent(EventLogTags.UC_UNLOCK_USER, userId);
final long binderToken = Binder.clearCallingIdentity();
try {
return maybeUnlockUser(userId, listener);
} finally {
Binder.restoreCallingIdentity(binderToken);
}
}
private static void notifyFinished(@UserIdInt int userId,
@Nullable IProgressListener listener) {
if (listener == null) return;
try {
listener.onFinished(userId, null);
} catch (RemoteException ignored) {
}
}
private boolean maybeUnlockUser(@UserIdInt int userId) {
return maybeUnlockUser(userId, null);
}
/**
* Tries to unlock the given user.
*
* This will succeed only if the user's CE storage key is already unlocked or if the user
* doesn't have a lockscreen credential set.
*/
private boolean maybeUnlockUser(@UserIdInt int userId, @Nullable IProgressListener listener) {
// We cannot allow users to be unlocked before PHASE_BOOT_COMPLETED, for two reasons.
// First, emulated volumes aren't supposed to be used until then; StorageManagerService
// assumes it can reset everything upon reaching PHASE_BOOT_COMPLETED. Second, on some
// devices the Weaver HAL needed to unlock the user's storage isn't available until sometime
// shortly before PHASE_BOOT_COMPLETED. The below logic enforces a consistent flow across
// all devices, regardless of their Weaver implementation.
//
// Any unlocks that get delayed by this will be done by onBootComplete() instead.
if (!mAllowUserUnlocking) {
Slogf.i(TAG, "Not unlocking user %d yet because boot hasn't completed", userId);
notifyFinished(userId, listener);
return false;
}
UserState uss;
if (!StorageManager.isCeStorageUnlocked(userId)) {
// We always want to try to unlock CE storage, even if the user is not started yet.
mLockPatternUtils.unlockUserKeyIfUnsecured(userId);
}
synchronized (mLock) {
// Register the given listener to watch for unlock progress
uss = mStartedUsers.get(userId);
if (uss != null) {
uss.mUnlockProgress.addListener(listener);
}
}
// Bail if user isn't actually running
if (uss == null) {
notifyFinished(userId, listener);
return false;
}
final TimingsTraceAndSlog t = new TimingsTraceAndSlog();
t.traceBegin("finishUserUnlocking-" + userId);
final boolean finishUserUnlockingResult = finishUserUnlocking(uss);
t.traceEnd();
if (!finishUserUnlockingResult) {
notifyFinished(userId, listener);
return false;
}
// We just unlocked a user, so let's now attempt to unlock any profiles under that user.
// First, get list of userIds. Requires mLock, so we cannot make external calls, e.g. to UMS
int[] userIds;
synchronized (mLock) {
userIds = new int[mStartedUsers.size()];
for (int i = 0; i < userIds.length; i++) {
userIds[i] = mStartedUsers.keyAt(i);
}
}
for (int testUserId : userIds) {
final UserInfo parent = mInjector.getUserManager().getProfileParent(testUserId);
if (parent != null && parent.id == userId && testUserId != userId) {
Slogf.d(TAG, "User " + testUserId + " (parent " + parent.id
+ "): attempting unlock because parent was just unlocked");
maybeUnlockUser(testUserId);
}
}
return true;
}
boolean switchUser(final int targetUserId) {
enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, targetUserId);
EventLog.writeEvent(EventLogTags.UC_SWITCH_USER, targetUserId);
int currentUserId = getCurrentUserId();
UserInfo targetUserInfo = getUserInfo(targetUserId);
boolean userSwitchUiEnabled;
synchronized (mLock) {
if (targetUserId == currentUserId && mTargetUserId == UserHandle.USER_NULL) {
Slogf.i(TAG, "user #" + targetUserId + " is already the current user");
mHandler.post(this::endUserSwitch);
return true;
}
if (targetUserInfo == null) {
Slogf.w(TAG, "No user info for user #" + targetUserId);
return false;
}
if (!mInjector.doesUserSupportSwitchTo(targetUserInfo)) {
Slogf.w(TAG, "Cannot switch to User #" + targetUserId + ": not supported");
return false;
}
if (FactoryResetter.isFactoryResetting()) {
Slogf.w(TAG, "Cannot switch to User #" + targetUserId
+ ": factory reset in progress");
return false;
}
if (!mInitialized) {
Slogf.e(TAG, "Cannot switch to User #" + targetUserId
+ ": UserController not ready yet");
return false;
}
if (mTargetUserId != UserHandle.USER_NULL) {
Slogf.w(TAG, "There is already an ongoing user switch to User #" + mTargetUserId
+ ". User #" + targetUserId + " will be added to the queue.");
mPendingTargetUserIds.offer(targetUserId);
return true;
}
mTargetUserId = targetUserId;
ActivityManager.invalidateGetCurrentUserIdCache();
userSwitchUiEnabled = mUserSwitchUiEnabled;
}
if (userSwitchUiEnabled) {
UserInfo currentUserInfo = getUserInfo(currentUserId);
Pair It's called every time a user is started.
*/
private void updateProfileRelatedCaches() {
final List Note that this is whether the user itself is considered a visible user, not merely a user
* that happens to be displaying a {@link Injector#getVisibleActivityUsers() visible activity}.
*/
private boolean isUserVisible(@UserIdInt int userId) {
return mInjector.getUserManagerInternal().isUserVisible(userId);
}
int[] getUsers() {
UserManagerService ums = mInjector.getUserManager();
return ums != null ? ums.getUserIds() : new int[] { 0 };
}
private UserInfo getUserInfo(@UserIdInt int userId) {
return mInjector.getUserManager().getUserInfo(userId);
}
private @Nullable UserProperties getUserProperties(@UserIdInt int userId) {
return mInjector.getUserManagerInternal().getUserProperties(userId);
}
int[] getUserIds() {
return mInjector.getUserManager().getUserIds();
}
/**
* If {@code userId} is {@link UserHandle#USER_ALL}, then return an array with all running user
* IDs. Otherwise return an array whose only element is the given user id.
*
* It doesn't handle other special user IDs such as {@link UserHandle#USER_CURRENT}.
*/
int[] expandUserId(@CanBeALL @UserIdInt int userId) {
if (userId != UserHandle.USER_ALL) {
return new int[] {userId};
} else {
return getUsers();
}
}
boolean exists(@UserIdInt int userId) {
return mInjector.getUserManager().exists(userId);
}
private void checkCallingPermission(String permission, String methodName) {
checkCallingHasOneOfThosePermissions(methodName, permission);
}
private void checkCallingHasOneOfThosePermissions(String methodName, String...permissions) {
for (String permission : permissions) {
if (mInjector.checkCallingPermission(permission) == PackageManager.PERMISSION_GRANTED) {
return;
}
}
String msg = "Permission denial: " + methodName
+ "() from pid=" + Binder.getCallingPid()
+ ", uid=" + Binder.getCallingUid()
+ " requires "
+ (permissions.length == 1
? permissions[0]
: "one of " + Arrays.toString(permissions));
Slogf.w(TAG, msg);
throw new SecurityException(msg);
}
private void enforceShellRestriction(String restriction, @UserIdInt int userId) {
if (Binder.getCallingUid() == SHELL_UID) {
if (userId < 0 || hasUserRestriction(restriction, userId)) {
throw new SecurityException("Shell does not have permission to access user "
+ userId);
}
}
}
boolean hasUserRestriction(String restriction, @UserIdInt int userId) {
return mInjector.getUserManager().hasUserRestriction(restriction, userId);
}
/** Returns whether the two users are in the same profile group. */
boolean isSameProfileGroup(int callingUserId, int targetUserId) {
if (callingUserId == targetUserId) {
return true;
}
synchronized (mLock) {
int callingProfile = mUserProfileGroupIds.get(callingUserId,
UserInfo.NO_PROFILE_GROUP_ID);
int targetProfile = mUserProfileGroupIds.get(targetUserId,
UserInfo.NO_PROFILE_GROUP_ID);
return callingProfile != UserInfo.NO_PROFILE_GROUP_ID
&& callingProfile == targetProfile;
}
}
boolean isUserOrItsParentRunning(@UserIdInt int userId) {
synchronized (mLock) {
if (isUserRunning(userId, 0)) {
return true;
}
final int parentUserId = mUserProfileGroupIds.get(userId, UserInfo.NO_PROFILE_GROUP_ID);
if (parentUserId == UserInfo.NO_PROFILE_GROUP_ID) {
return false;
}
return isUserRunning(parentUserId, 0);
}
}
boolean isCurrentProfile(@UserIdInt int userId) {
synchronized (mLock) {
return ArrayUtils.contains(mCurrentProfileIds, userId);
}
}
int[] getCurrentProfileIds() {
synchronized (mLock) {
return mCurrentProfileIds;
}
}
private void onUserAdded(UserInfo user) {
if (!user.isProfile()) {
return;
}
synchronized (mLock) {
if (user.profileGroupId == mCurrentUserId) {
mCurrentProfileIds = ArrayUtils.appendInt(mCurrentProfileIds, user.id);
}
if (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID) {
mUserProfileGroupIds.put(user.id, user.profileGroupId);
}
}
}
void onUserRemoved(@UserIdInt int userId) {
synchronized (mLock) {
int size = mUserProfileGroupIds.size();
for (int i = size - 1; i >= 0; i--) {
if (mUserProfileGroupIds.keyAt(i) == userId
|| mUserProfileGroupIds.valueAt(i) == userId) {
mUserProfileGroupIds.removeAt(i);
}
}
mCurrentProfileIds = ArrayUtils.removeInt(mCurrentProfileIds, userId);
mUserLru.remove((Integer) userId);
mStartedUsers.remove(userId);
updateStartedUserArrayLU();
}
}
/**
* Returns whether the given user requires credential entry at this time. This is used to
* intercept activity launches for apps corresponding to locked profiles due to separate
* challenge being triggered or when the profile user is yet to be unlocked.
*/
protected boolean shouldConfirmCredentials(@UserIdInt int userId) {
if (getStartedUserState(userId) == null) {
return false;
}
final UserProperties properties = getUserProperties(userId);
if (properties == null || !properties.isCredentialShareableWithParent()) {
return false;
}
if (mLockPatternUtils.isSeparateProfileChallengeEnabled(userId)) {
final KeyguardManager km = mInjector.getKeyguardManager();
return km.isDeviceLocked(userId) && km.isDeviceSecure(userId);
} else {
// For unified challenge, need to confirm credential if user is RUNNING_LOCKED.
return isUserRunning(userId, ActivityManager.FLAG_AND_LOCKED);
}
}
boolean isLockScreenDisabled(@UserIdInt int userId) {
return mLockPatternUtils.isLockScreenDisabled(userId);
}
void setSwitchingFromUserMessage(@UserIdInt int user, @Nullable String message) {
synchronized (mLock) {
mSwitchingFromUserMessage.put(user, message);
}
}
void setSwitchingToUserMessage(@UserIdInt int user, @Nullable String message) {
synchronized (mLock) {
mSwitchingToUserMessage.put(user, message);
}
}
// Called by AMS, must check permission
@Nullable String getSwitchingFromUserMessage(@UserIdInt int userId) {
checkHasManageUsersPermission("getSwitchingFromUserMessage()");
return getSwitchingFromUserMessageUnchecked(userId);
}
// Called by AMS, must check permission
@Nullable String getSwitchingToUserMessage(@UserIdInt int userId) {
checkHasManageUsersPermission("getSwitchingToUserMessage()");
return getSwitchingToUserMessageUnchecked(userId);
}
private @Nullable String getSwitchingFromUserMessageUnchecked(@UserIdInt int userId) {
synchronized (mLock) {
return mSwitchingFromUserMessage.get(userId);
}
}
private @Nullable String getSwitchingToUserMessageUnchecked(@UserIdInt int userId) {
synchronized (mLock) {
return mSwitchingToUserMessage.get(userId);
}
}
private void checkHasManageUsersPermission(String operation) {
if (mInjector.checkCallingPermission(
android.Manifest.permission.MANAGE_USERS) == PackageManager.PERMISSION_DENIED) {
throw new SecurityException(
"You need MANAGE_USERS permission to call " + operation);
}
}
void dumpDebug(ProtoOutputStream proto, long fieldId) {
synchronized (mLock) {
long token = proto.start(fieldId);
for (int i = 0; i < mStartedUsers.size(); i++) {
UserState uss = mStartedUsers.valueAt(i);
final long uToken = proto.start(UserControllerProto.STARTED_USERS);
proto.write(UserControllerProto.User.ID, uss.mHandle.getIdentifier());
uss.dumpDebug(proto, UserControllerProto.User.STATE);
proto.end(uToken);
}
for (int i = 0; i < mStartedUserArray.length; i++) {
proto.write(UserControllerProto.STARTED_USER_ARRAY, mStartedUserArray[i]);
}
for (int i = 0; i < mUserLru.size(); i++) {
proto.write(UserControllerProto.USER_LRU, mUserLru.get(i));
}
if (mUserProfileGroupIds.size() > 0) {
for (int i = 0; i < mUserProfileGroupIds.size(); i++) {
final long uToken = proto.start(UserControllerProto.USER_PROFILE_GROUP_IDS);
proto.write(UserControllerProto.UserProfile.USER,
mUserProfileGroupIds.keyAt(i));
proto.write(UserControllerProto.UserProfile.PROFILE,
mUserProfileGroupIds.valueAt(i));
proto.end(uToken);
}
}
proto.write(UserControllerProto.CURRENT_USER, mCurrentUserId);
for (int i = 0; i < mCurrentProfileIds.length; i++) {
proto.write(UserControllerProto.CURRENT_PROFILES, mCurrentProfileIds[i]);
}
proto.write(UserControllerProto.READY, mReady);
proto.end(token);
}
}
void dump(PrintWriter pw) {
synchronized (mLock) {
pw.println(" mStartedUsers:");
for (int i = 0; i < mStartedUsers.size(); i++) {
UserState uss = mStartedUsers.valueAt(i);
pw.print(" User #");
pw.print(uss.mHandle.getIdentifier());
pw.print(": ");
uss.dump("", pw);
}
pw.print(" mStartedUserArray: [");
for (int i = 0; i < mStartedUserArray.length; i++) {
if (i > 0)
pw.print(", ");
pw.print(mStartedUserArray[i]);
}
pw.println("]");
pw.print(" mUserLru: [");
for (int i = 0; i < mUserLru.size(); i++) {
if (i > 0)
pw.print(", ");
pw.print(mUserLru.get(i));
}
pw.println("]");
if (mUserProfileGroupIds.size() > 0) {
pw.println(" mUserProfileGroupIds:");
for (int i=0; i< mUserProfileGroupIds.size(); i++) {
pw.print(" User #");
pw.print(mUserProfileGroupIds.keyAt(i));
pw.print(" -> profile #");
pw.println(mUserProfileGroupIds.valueAt(i));
}
}
pw.println(" mCurrentProfileIds:" + Arrays.toString(mCurrentProfileIds));
pw.println(" mCurrentUserId:" + mCurrentUserId);
pw.println(" mTargetUserId:" + mTargetUserId);
pw.println(" mPendingTargetUserIds:" + mPendingTargetUserIds);
pw.println(" mPendingLogoutTargetUser:" + mPendingLogoutTargetUser);
pw.println(" mLastActiveUsersForDelayedLocking:" + mLastActiveUsersForDelayedLocking);
pw.println(" mDelayUserDataLocking:" + mDelayUserDataLocking);
pw.println(" mAllowUserUnlocking:" + mAllowUserUnlocking);
pw.println(" isStopUserOnSwitchEnabled():" + isStopUserOnSwitchEnabled());
pw.println(" mStopUserOnSwitch:" + mStopUserOnSwitch);
pw.println(" mMaxRunningUsers:" + mMaxRunningUsers);
pw.println(" mBackgroundUserConsideredDispensableTimeSecs:"
+ mBackgroundUserConsideredDispensableTimeSecs);
pw.println(" mUserSwitchUiEnabled:" + mUserSwitchUiEnabled);
pw.println(" mInitialized:" + mInitialized);
pw.println(" mIsBroadcastSentForSystemUserStarted:"
+ mIsBroadcastSentForSystemUserStarted);
pw.println(" mIsBroadcastSentForSystemUserStarting:"
+ mIsBroadcastSentForSystemUserStarting);
pw.println(" mSwitchingFromUserMessage:" + mSwitchingFromUserMessage);
pw.println(" mSwitchingToUserMessage:" + mSwitchingToUserMessage);
pw.println(" mLastUserUnlockingUptime: " + mLastUserUnlockingUptime);
pw.println(" mReady: " + mReady);
}
}
@Override
public boolean handleMessage(Message msg) {
switch (msg.what) {
case START_USER_SWITCH_FG_MSG:
logUserJourneyBegin(msg.arg1, USER_JOURNEY_USER_SWITCH_FG);
startUserInForeground(msg.arg1);
break;
case REPORT_USER_SWITCH_MSG:
dispatchUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2);
break;
case CONTINUE_USER_SWITCH_MSG:
continueUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2);
break;
case USER_SWITCH_TIMEOUT_MSG:
timeoutUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2);
break;
case USER_SWITCH_CALLBACKS_TIMEOUT_MSG:
timeoutUserSwitchCallbacks(msg.arg1, msg.arg2);
break;
case START_PROFILES_MSG:
startProfiles();
break;
case USER_START_MSG:
mInjector.batteryStatsServiceNoteEvent(
BatteryStats.HistoryItem.EVENT_USER_RUNNING_START,
Integer.toString(msg.arg1), msg.arg1);
logUserJourneyBegin(msg.arg1, USER_JOURNEY_USER_START);
mInjector.onUserStarting(/* userId= */ msg.arg1);
scheduleOnUserCompletedEvent(msg.arg1,
UserCompletedEventType.EVENT_TYPE_USER_STARTING,
USER_COMPLETED_EVENT_DELAY_MS);
mInjector.getUserJourneyLogger().logUserJourneyFinish(-1 , getUserInfo(msg.arg1),
USER_JOURNEY_USER_START);
break;
case USER_UNLOCK_MSG:
final int userId = msg.arg1;
mInjector.getSystemServiceManager().onUserUnlocking(userId);
// Loads recents on a worker thread that allows disk I/O
FgThread.getHandler().post(() -> {
mInjector.loadUserRecents(userId);
});
mInjector.getUserJourneyLogger().logUserLifecycleEvent(msg.arg1,
USER_LIFECYCLE_EVENT_UNLOCKING_USER, EVENT_STATE_FINISH);
mInjector.getUserJourneyLogger().logUserLifecycleEvent(msg.arg1,
USER_LIFECYCLE_EVENT_UNLOCKED_USER, EVENT_STATE_BEGIN);
final TimingsTraceAndSlog t = new TimingsTraceAndSlog();
t.traceBegin("finishUserUnlocked-" + userId);
finishUserUnlocked((UserState) msg.obj);
t.traceEnd();
break;
case USER_UNLOCKED_MSG:
mInjector.getSystemServiceManager().onUserUnlocked(msg.arg1);
scheduleOnUserCompletedEvent(msg.arg1,
UserCompletedEventType.EVENT_TYPE_USER_UNLOCKED,
// If it's the foreground user, we wait longer to let it fully load.
// Else, there's nothing specific to wait for, so we basically just proceed.
// (No need to acquire lock to read mCurrentUserId since it is volatile.)
// TODO: Find something to wait for in the case of a profile.
mCurrentUserId == msg.arg1 ? USER_COMPLETED_EVENT_DELAY_MS : 1000);
mInjector.getUserJourneyLogger().logUserLifecycleEvent(msg.arg1,
USER_LIFECYCLE_EVENT_UNLOCKED_USER, EVENT_STATE_FINISH);
// Unlocking user is not a journey no need to clear sessionId
break;
case USER_CURRENT_MSG:
mInjector.batteryStatsServiceNoteEvent(
BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_FINISH,
Integer.toString(msg.arg2), msg.arg2);
mInjector.batteryStatsServiceNoteEvent(
BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START,
Integer.toString(msg.arg1), msg.arg1);
mInjector.getSystemServiceManager().onUserSwitching(msg.arg2, msg.arg1);
stopPreviousUserPackagesIfEnabled(msg.arg2, msg.arg1);
scheduleOnUserCompletedEvent(msg.arg1,
UserCompletedEventType.EVENT_TYPE_USER_SWITCHING,
USER_COMPLETED_EVENT_DELAY_MS);
break;
case USER_COMPLETED_EVENT_MSG:
reportOnUserCompletedEvent((Integer) msg.obj);
break;
case FOREGROUND_PROFILE_CHANGED_MSG:
dispatchForegroundProfileChanged(msg.arg1);
break;
case REPORT_USER_SWITCH_COMPLETE_MSG:
dispatchUserSwitchComplete(msg.arg1, msg.arg2);
UserJourneySession session = mInjector.getUserJourneyLogger()
.logUserSwitchJourneyFinish(msg.arg1, getUserInfo(msg.arg2));
if (session != null) {
mHandler.removeMessages(CLEAR_USER_JOURNEY_SESSION_MSG, session);
}
break;
case REPORT_LOCKED_BOOT_COMPLETE_MSG:
dispatchLockedBootComplete(msg.arg1);
break;
case START_USER_SWITCH_UI_MSG:
final Pair
* This is basically just a Pair, except that the equality of two UserAndLmkThreshold objects is
* determined *only* by the userId, ignoring the lmkCountThreshold. This means that, when used
* as the obj in {@code mHandler.removeEqualMessage()}, all messages with for the same userId
* will be purposefully removed, regardless of the lmkCountThreshold values.
*/
@VisibleForTesting
static class UserAndLmkThreshold {
public @UserIdInt int userId;
public int lmkCountThreshold;
public UserAndLmkThreshold(int userId, int lmkCountThreshold) {
this.userId = userId;
this.lmkCountThreshold = lmkCountThreshold;
}
/**
* Two UserAndLmkThreshold objects are considered equal if and only if their {@code userId}
* fields are equal. The {@code lmkCountThreshold} is not considered in this comparison.
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return userId == ((UserAndLmkThreshold) o).userId;
}
@Override
public int hashCode() {
// Must use the same fields as equals() to ensure that equal objects have the same hash!
return Objects.hash(userId);
}
@Override
public String toString() {
return "UserAndLmkThreshold{userId=" + userId
+ ", lmkCountThreshold=" + lmkCountThreshold + "}";
}
}
@VisibleForTesting
static class Injector {
private final ActivityManagerService mService;
private UserManagerService mUserManager;
private UserManagerInternal mUserManagerInternal;
private LockSettingsInternal mLockSettingsInternal;
private PowerManagerInternal mPowerManagerInternal;
private Handler mHandler;
private final Object mUserSwitchingDialogLock = new Object();
@GuardedBy("mUserSwitchingDialogLock")
private UserSwitchingDialog mUserSwitchingDialog;
Injector(ActivityManagerService service) {
mService = service;
}
protected Handler getHandler(Handler.Callback callback) {
return mHandler = new Handler(mService.mHandlerThread.getLooper(), callback);
}
protected Handler getUiHandler(Handler.Callback callback) {
return new Handler(mService.mUiHandler.getLooper(), callback);
}
protected UserJourneyLogger getUserJourneyLogger() {
return getUserManager().getUserJourneyLogger();
}
protected Context getContext() {
return mService.mContext;
}
protected LockPatternUtils getLockPatternUtils() {
return new LockPatternUtils(getContext());
}
protected int broadcastIntent(Intent intent, String resolvedType,
IIntentReceiver resultTo, int resultCode, String resultData,
Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions,
boolean sticky, int callingPid, int callingUid, int realCallingUid,
int realCallingPid, @UserIdInt int userId) {
int logUserId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
if (logUserId == UserHandle.USER_NULL) {
logUserId = userId;
}
EventLog.writeEvent(EventLogTags.UC_SEND_USER_BROADCAST, logUserId, intent.getAction());
TimingsTraceAndSlog t = new TimingsTraceAndSlog();
// TODO b/64165549 Verify that mLock is not held before calling AMS methods
synchronized (mService) {
t.traceBegin("broadcastIntent-" + userId + "-" + intent.getAction());
final int result = mService.broadcastIntentLocked(null, null, null, intent,
resolvedType, resultTo, resultCode, resultData, resultExtras,
requiredPermissions, null, null, appOp, bOptions, false, sticky,
callingPid, callingUid, realCallingUid, realCallingPid, userId);
t.traceEnd();
return result;
}
}
int checkCallingPermission(String permission) {
return mService.checkCallingPermission(permission);
}
WindowManagerService getWindowManager() {
return mService.mWindowManager;
}
void activityManagerOnUserStopped(@UserIdInt int userId) {
LocalServices.getService(ActivityTaskManagerInternal.class).onUserStopped(userId);
}
void systemServiceManagerOnUserStopped(@UserIdInt int userId) {
getSystemServiceManager().onUserStopped(userId);
}
void systemServiceManagerOnUserCompletedEvent(@UserIdInt int userId, int eventTypes) {
getSystemServiceManager().onUserCompletedEvent(userId, eventTypes);
}
protected UserManagerService getUserManager() {
if (mUserManager == null) {
IBinder b = ServiceManager.getService(Context.USER_SERVICE);
mUserManager = (UserManagerService) IUserManager.Stub.asInterface(b);
}
return mUserManager;
}
UserManagerInternal getUserManagerInternal() {
if (mUserManagerInternal == null) {
mUserManagerInternal = LocalServices.getService(UserManagerInternal.class);
}
return mUserManagerInternal;
}
LockSettingsInternal getLockSettingsInternal() {
if (mLockSettingsInternal == null) {
mLockSettingsInternal = LocalServices.getService(LockSettingsInternal.class);
}
return mLockSettingsInternal;
}
PowerManagerInternal getPowerManagerInternal() {
if (mPowerManagerInternal == null) {
mPowerManagerInternal = LocalServices.getService(PowerManagerInternal.class);
}
return mPowerManagerInternal;
}
AudioManagerInternal getAudioManagerInternal() {
return LocalServices.getService(AudioManagerInternal.class);
}
AlarmManagerInternal getAlarmManagerInternal() {
return LocalServices.getService(AlarmManagerInternal.class);
}
KeyguardManager getKeyguardManager() {
return mService.mContext.getSystemService(KeyguardManager.class);
}
void batteryStatsServiceNoteEvent(int code, String name, int uid) {
mService.mBatteryStatsService.noteEvent(code, name, uid);
}
boolean isRuntimeRestarted() {
return getSystemServiceManager().isRuntimeRestarted();
}
SystemServiceManager getSystemServiceManager() {
return mService.mSystemServiceManager;
}
boolean isFirstBootOrUpgrade() {
IPackageManager pm = AppGlobals.getPackageManager();
try {
return pm.isFirstBoot() || pm.isDeviceUpgrading();
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
void sendPreBootBroadcast(@UserIdInt int userId, boolean quiet, final Runnable onFinish) {
EventLog.writeEvent(EventLogTags.UC_SEND_USER_BROADCAST,
userId, Intent.ACTION_PRE_BOOT_COMPLETED);
new PreBootBroadcaster(mService, userId, null, quiet) {
@Override
public void onFinished() {
onFinish.run();
}
}.sendNext();
}
void activityManagerForceStopUserPackages(@UserIdInt int userId, String reason,
boolean evenImportantServices) {
synchronized (mService) {
mService.forceStopUserPackagesLocked(userId, reason, evenImportantServices);
}
};
int checkComponentPermission(String permission, int pid, int uid, int owningUid,
boolean exported) {
return mService.checkComponentPermission(permission, pid, uid, owningUid, exported);
}
boolean checkPermissionForPreflight(String permission, int pid, int uid, String pkg) {
return PermissionChecker.PERMISSION_GRANTED
== PermissionChecker.checkPermissionForPreflight(
getContext(), permission, pid, uid, pkg);
}
protected void startHomeActivity(@UserIdInt int userId, String reason) {
mService.mAtmInternal.startHomeActivity(userId, reason);
}
void startUserWidgets(@UserIdInt int userId) {
AppWidgetManagerInternal awm = LocalServices.getService(AppWidgetManagerInternal.class);
if (awm != null) {
// Out of band, because this is called during a sequence with
// sensitive cross-service lock management
FgThread.getHandler().post(() -> {
awm.unlockUser(userId);
});
}
}
void updateUserConfiguration() {
mService.mAtmInternal.updateUserConfiguration();
}
void clearBroadcastQueueForUser(@UserIdInt int userId) {
synchronized (mService) {
mService.clearBroadcastQueueForUserLocked(userId);
}
}
void loadUserRecents(@UserIdInt int userId) {
mService.mAtmInternal.loadRecentTasksForUser(userId);
}
void startPersistentApps(int matchFlags) {
mService.startPersistentApps(matchFlags);
}
void installEncryptionUnawareProviders(@UserIdInt int userId) {
mService.mCpHelper.installEncryptionUnawareProviders(userId);
}
void dismissUserSwitchingDialog(@Nullable Runnable onDismissed) {
synchronized (mUserSwitchingDialogLock) {
if (mUserSwitchingDialog != null) {
mUserSwitchingDialog.dismiss(onDismissed);
mUserSwitchingDialog = null;
} else if (onDismissed != null) {
onDismissed.run();
}
}
}
void showUserSwitchingDialog(UserInfo fromUser, UserInfo toUser,
@Nullable String switchingFromUserMessage, @Nullable String switchingToUserMessage,
@NonNull Runnable onShown) {
if (mService.mContext.getPackageManager()
.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
// config_customUserSwitchUi is set to true on Automotive as CarSystemUI is
// responsible to show the UI; OEMs should not change that, but if they do, we
// should at least warn the user...
Slogf.w(TAG, "Showing user switch dialog on UserController, it could cause a race "
+ "condition if it's shown by CarSystemUI as well");
}
synchronized (mUserSwitchingDialogLock) {
dismissUserSwitchingDialog(null);
mUserSwitchingDialog = new UserSwitchingDialog(mService.mContext, fromUser, toUser,
mHandler, switchingFromUserMessage, switchingToUserMessage);
mUserSwitchingDialog.show(onShown);
}
}
void reportGlobalUsageEvent(int event) {
mService.reportGlobalUsageEvent(event);
}
void reportCurWakefulnessUsageEvent() {
mService.reportCurWakefulnessUsageEvent();
}
void taskSupervisorRemoveUser(@UserIdInt int userId) {
mService.mAtmInternal.removeUser(userId);
}
protected boolean taskSupervisorSwitchUser(@UserIdInt int userId, UserState uss) {
return mService.mAtmInternal.switchUser(userId, uss);
}
protected void taskSupervisorResumeFocusedStackTopActivity() {
mService.mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
}
protected void clearAllLockedTasks(String reason) {
mService.mAtmInternal.clearLockedTasks(reason);
}
boolean isCallerRecents(int callingUid) {
return mService.mAtmInternal.isCallerRecents(callingUid);
}
boolean isHeadlessSystemUserMode() {
return UserManager.isHeadlessSystemUserMode();
}
boolean doesUserSupportSwitchTo(UserInfo user) {
return user.supportsSwitchTo();
}
boolean isUsersOnSecondaryDisplaysEnabled() {
return UserManager.isVisibleBackgroundUsersEnabled();
}
void onUserStarting(@UserIdInt int userId) {
getSystemServiceManager().onUserStarting(TimingsTraceAndSlog.newAsyncLog(), userId);
}
void setPerformancePowerMode(boolean enabled) {
Slogf.i(TAG, "Setting power mode MODE_FIXED_PERFORMANCE to " + enabled);
getPowerManagerInternal().setPowerMode(
PowerManagerInternal.MODE_FIXED_PERFORMANCE, enabled);
}
void onSystemUserVisibilityChanged(boolean visible) {
getUserManagerInternal().onSystemUserVisibilityChanged(visible);
}
void lockDeviceNowAndWaitForKeyguardShown() {
final TimingsTraceAndSlog t = new TimingsTraceAndSlog();
t.traceBegin("lockDeviceNowAndWaitForKeyguardShown");
final CountDownLatch latch = new CountDownLatch(1);
Bundle bundle = new Bundle();
bundle.putBinder(LOCK_ON_USER_SWITCH_CALLBACK, new IRemoteCallback.Stub() {
public void sendResult(Bundle data) {
latch.countDown();
}
});
getWindowManager().lockNow(bundle);
try {
if (!latch.await(20, TimeUnit.SECONDS)) {
throw new RuntimeException("User controller expected a callback while waiting "
+ "to show the keyguard. Timed out after 20 seconds.");
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
} finally {
t.traceEnd();
}
}
/**
* Returns the set of users that are currently displaying visible activities.
*
* Even a non-visible background user could be visibly displaying an activity in special
* circumstances, such as if it is running an app with
* {@link android.content.pm.ActivityInfo#FLAG_SHOW_FOR_ALL_USERS}.
*/
ArraySet
*
*
*
*
*
* @see ActivityManager#logoutUser(int)
* @param userId The ID of the user to log out.
* @return true if logout is successfully initiated.
* @throws UnsupportedOperationException if device is in HSUM and cannot switch to system user.
*/
boolean logoutUser(@UserIdInt int userId) {
// TODO(b/380125011): To handle the edge case of trying to logout the user that the device
// is in the process of switching to (i.e. userId == mTargetUserId), we had to logout to the
// system user (not the previous foreground user). Thus we cannot support HSUM devices
// without interactive headless system user. To solve it for the long term, a refactor might
// be needed, see more details in the bug.
if (!mInjector.doesUserSupportSwitchTo(getUserInfo(UserHandle.USER_SYSTEM))) {
throw new UnsupportedOperationException("device does not support logoutUser");
}
boolean shouldSwitchUser = false;
synchronized (mLock) {
if (userId == UserHandle.USER_SYSTEM) {
Slogf.e(TAG, "Cannot logout system user %d", userId);
return false;
}
// Since we are logging out of userId, let's not switch to userId (after possible
// ongoing user switch).
mPendingTargetUserIds.removeIf(id -> id == userId);
if (userId == mTargetUserId) {
Slogf.w(TAG, "Cannot logout user %d now as we're in the process of switching to it,"
+ " it will be logged out when the ongoing user-switch is complete.",
userId);
mPendingLogoutTargetUser = true;
return true;
}
if (userId == getCurrentUserId() && mTargetUserId == UserHandle.USER_NULL) {
shouldSwitchUser = true;
}
}
if (shouldSwitchUser) {
if (!switchUser(UserHandle.USER_SYSTEM)) {
Slogf.e(TAG, "Cannot logout user %d; switch to system user failed", userId);
return false;
}
}
// Now, userId is not current, so we can simply stop it.
final int result = stopUser(userId, /* allowDelayedLocking= */ false,
/* stopUserCallback= */ null, /* keyEvictedCallback */ null);
if (result != USER_OP_SUCCESS) {
Slogf.e(TAG, "Cannot logout user %d; stop user failed with result %d", userId, result);
return false;
}
return true;
}
int restartUser(final int userId, @UserStartMode int userStartMode) {
return stopUser(userId, /* allowDelayedLocking= */ false,
/* stopUserCallback= */ null, new KeyEvictedCallback() {
@Override
public void keyEvicted(@UserIdInt int userId) {
// Post to the same handler that this callback is called from to ensure
// the user cleanup is complete before restarting.
mHandler.post(() -> UserController.this.startUser(userId, userStartMode));
}
});
}
/**
* Stops a user only if it's a profile, with a more relaxed permission requirement:
* {@link android.Manifest.permission#MANAGE_USERS} or
* {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL}.
* To be called from ActivityManagerService.
* @param userId the id of the user to stop.
* @return true if the operation was successful.
*/
boolean stopProfile(final @UserIdInt int userId) {
if (mInjector.checkCallingPermission(android.Manifest.permission.MANAGE_USERS)
== PackageManager.PERMISSION_DENIED && mInjector.checkCallingPermission(
android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
== PackageManager.PERMISSION_DENIED) {
throw new SecurityException(
"You either need MANAGE_USERS or INTERACT_ACROSS_USERS_FULL permission to "
+ "stop a profile");
}
final UserInfo userInfo = getUserInfo(userId);
if (userInfo == null || !userInfo.isProfile()) {
throw new IllegalArgumentException("User " + userId + " is not a profile");
}
enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, userId);
synchronized (mLock) {
return stopUsersLU(userId, /* allowDelayedLocking= */ false,
/* stopUserCallback= */ null, /* keyEvictedCallback= */ null)
== ActivityManager.USER_OP_SUCCESS;
}
}
int stopUser(final int userId, boolean allowDelayedLocking,
final IStopUserCallback stopUserCallback, KeyEvictedCallback keyEvictedCallback) {
return stopUser(userId, true, allowDelayedLocking, stopUserCallback, keyEvictedCallback);
}
int stopUser(final int userId,
final boolean stopProfileRegardlessOfParent, final boolean allowDelayedLocking,
final IStopUserCallback stopUserCallback, KeyEvictedCallback keyEvictedCallback) {
TimingsTraceAndSlog t = new TimingsTraceAndSlog();
t.traceBegin("UserController"
+ (stopProfileRegardlessOfParent ? "-stopProfileRegardlessOfParent" : "")
+ (allowDelayedLocking ? "-allowDelayedLocking" : "")
+ (stopUserCallback != null ? "-withStopUserCallback" : "")
+ "-" + userId + "-[stopUser]");
try {
checkCallingPermission(INTERACT_ACROSS_USERS_FULL, "stopUser");
Preconditions.checkArgument(userId >= 0, "Invalid user id %d", userId);
enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, userId);
synchronized (mLock) {
return stopUsersLU(userId, stopProfileRegardlessOfParent, allowDelayedLocking,
stopUserCallback, keyEvictedCallback);
}
} finally {
t.traceEnd();
}
}
/** Stops the user along with its profiles. */
@GuardedBy("mLock")
private int stopUsersLU(final int userId, boolean allowDelayedLocking,
final IStopUserCallback stopUserCallback, KeyEvictedCallback keyEvictedCallback) {
return stopUsersLU(userId, /* stopProfileRegardlessOfParent= */ true,
allowDelayedLocking, stopUserCallback, keyEvictedCallback);
}
/**
* Stops the user along with its profiles. The method calls
* {@link #getUsersToStopLU(int)} to determine the list of users that should be stopped.
*
* @param stopProfileRegardlessOfParent whether to stop the profile regardless of who its
* parent is, e.g. even if the parent is the current user
*/
@GuardedBy("mLock")
private int stopUsersLU(final int userId,
boolean stopProfileRegardlessOfParent, boolean allowDelayedLocking,
final IStopUserCallback stopUserCallback, KeyEvictedCallback keyEvictedCallback) {
if (userId == UserHandle.USER_SYSTEM) {
return USER_OP_ERROR_IS_SYSTEM;
}
if (isCurrentUserLU(userId)) {
return USER_OP_IS_CURRENT;
}
if (!stopProfileRegardlessOfParent) {
final int parentId = mUserProfileGroupIds.get(userId, UserInfo.NO_PROFILE_GROUP_ID);
if (parentId != UserInfo.NO_PROFILE_GROUP_ID && parentId != userId) {
if ((!android.multiuser.Flags.stopExcessForBackgroundStarts()
&& UserHandle.USER_SYSTEM == parentId)
|| isCurrentUserLU(parentId)) {
return USER_OP_ERROR_RELATED_USERS_CANNOT_STOP;
}
}
}
final int[] usersToStop = getUsersToStopLU(userId);
// Final safety check: abort if one of the users we would plan to stop must not be stopped.
// This should be impossible in the current code, but just in case.
for (int relatedUserId : usersToStop) {
if ((UserHandle.USER_SYSTEM == relatedUserId) || isCurrentUserLU(relatedUserId)) {
Slogf.e(TAG, "Cannot stop user %d because it is related to user %d. ",
userId, relatedUserId);
return USER_OP_ERROR_RELATED_USERS_CANNOT_STOP;
}
}
TimingsTraceAndSlog t = new TimingsTraceAndSlog();
if (DEBUG_MU) Slogf.i(TAG, "stopUsersLocked usersToStop=" + Arrays.toString(usersToStop));
for (int userIdToStop : usersToStop) {
t.traceBegin("stopSingleUserLU-" + userIdToStop + "-[stopUser]");
stopSingleUserLU(userIdToStop, allowDelayedLocking,
userIdToStop == userId ? stopUserCallback : null,
userIdToStop == userId ? keyEvictedCallback : null);
t.traceEnd();
}
return USER_OP_SUCCESS;
}
/**
* Stops a single User.
*
* This should only ever be called by {@link #stopUsersLU},
* which is responsible to making sure any associated users are appropriately stopped too.
*
* This can also trigger locking user data out depending on device's
* config ({@code mDelayUserDataLocking}) and arguments.
*
* In the default configuration for most device and users, users will be locked when stopping.
* User will remain unlocked only if all the following are true
*
*
*
* @param userId ID of the user to start
* @param userStartMode user starting mode
* @param unlockListener Listener to be informed when the user has started and unlocked.
* @return true if the user has been successfully started
*/
boolean startUser(@UserIdInt int userId, @UserStartMode int userStartMode,
@Nullable IProgressListener unlockListener) {
checkCallingPermission(INTERACT_ACROSS_USERS_FULL, "startUser");
return startUserNoChecks(userId, Display.DEFAULT_DISPLAY, userStartMode, unlockListener);
}
/**
* Starts a user in background and make it visible in the given display.
*
*
*
*
* @param userAndLmkThreshold the background user under consideration, coupled with the
* lmkCountThreshold above which we would decide to stop this user if
* it had been inactive for sufficiently long. A lmkCountThreshold
* value below 0 indicates that we haven't yet recorded it.
*/
@VisibleForTesting
void processJudgeFateOfBackgroundUser(UserAndLmkThreshold userAndLmkThreshold) {
if (mBackgroundUserConsideredDispensableTimeSecs < 0) {
// Feature is not enabled on this device. This line should be unreachable.
return;
}
final @UserIdInt int userId = userAndLmkThreshold.userId;
if (!isBackgroundUserEligibleForAutomaticStopping(userId)
|| isUserScheduledForStopping(userId)) {
// Sanity check. Make sure the user is still indeed running non-visibly in the
// background and isn't already slated for stopping.
return;
}
// Phase 1 was already initiated by initiateJudgeFateOfBackgroundUser() and has finished.
final int lmkCountThreshold = userAndLmkThreshold.lmkCountThreshold;
final int currentLmkCount = mInjector.getLmkdKillCount();
Slogf.v(TAG, "Comparing current lmkCount %d with threshold level %d for judgement",
currentLmkCount, lmkCountThreshold);
if (lmkCountThreshold < 0) {
// Entering Phase 2. Time to gather evidence.
// The user only recently entered the background; now we wait to see if the user stays
// there for a long time. We also record the initial lmkCount value.
// (Can also happen if lmkdKillCount has yet to give us an initial valid value; we'll
// try again later, but don't want to poll too frequently if it isn't working anyway.)
Slogf.i(TAG, "Scheduling judgement of background user %d in %d secs with %d lmks",
userId, mBackgroundUserConsideredDispensableTimeSecs, currentLmkCount);
mHandler.sendMessageDelayed(mHandler.obtainMessage(
SCHEDULE_JUDGE_FATE_OF_BACKGROUND_USER_MSG,
new UserAndLmkThreshold(userId, currentLmkCount)),
mBackgroundUserConsideredDispensableTimeSecs * 1000);
} else if (currentLmkCount <= lmkCountThreshold) {
// We are in Phase 3.
// currentLmkCount hasn't increased (or is invalid). Check again soon.
Slogf.i(TAG, "Judgement: User %d is dispensable; wait %d secs to see if lmks exceed %d",
userId, POLLING_TIME_FOR_JUDGING_BACKGROUND_USER_SECS, lmkCountThreshold);
mHandler.sendMessageDelayed(mHandler.obtainMessage(
SCHEDULE_JUDGE_FATE_OF_BACKGROUND_USER_MSG, userAndLmkThreshold),
POLLING_TIME_FOR_JUDGING_BACKGROUND_USER_SECS * 1000);
} else { // 0 <= lmkCountThreshold < currentLmkCount
// Entering Phase 4.
// The user has been in the background for the requisite length of time and lmkCount has
// increased. We render the verdict to stop the user.
// Rather than stop it immediately, we'll delay the sentence in case the recent lmks
// indicate recent CPU stress too, and also to benefit from the scheduling checks.
Slogf.i(TAG, "Judgement: User %d is sentenced for stopping", userId);
rescheduleStopOfBackgroundUser(userId);
}
}
/**
* Cancels both SCHEDULE_STOP_BACKGROUND_USER_MSG and SCHEDULE_JUDGE_FATE_OF_BACKGROUND_USER_MSG
* for the given user.
*/
private void clearAnyPlansForStoppingBackgroundUser(@UserIdInt Integer userIdInteger) {
if (android.multiuser.Flags.scheduleStopOfBackgroundUser()) {
mHandler.removeEqualMessages(SCHEDULE_STOP_BACKGROUND_USER_MSG, userIdInteger);
}
ceaseJudgeFateOfBackgroundUser(userIdInteger);
}
private void ceaseJudgeFateOfBackgroundUser(@UserIdInt Integer userIdInteger) {
if (!android.multiuser.Flags.scheduleStopOfBackgroundUserByDefault()) {
return;
}
final UserAndLmkThreshold userAndAnyLmk = new UserAndLmkThreshold(userIdInteger, 0);
mHandler.removeEqualMessages(SCHEDULE_JUDGE_FATE_OF_BACKGROUND_USER_MSG, userAndAnyLmk);
}
private boolean isUserScheduledForStopping(@UserIdInt Integer userIdInteger) {
return mHandler.hasEqualMessages(SCHEDULE_STOP_BACKGROUND_USER_MSG, userIdInteger);
}
/**
* Possibly schedules the user to be stopped at a future point, even though we had originally
* wanted to stop it now. For example, perhaps we have to postpone a scheduled user stop for
* some reason, and therefore are rescheduling it until a later point.
*
* This is only intended for background users (including profiles).
*/
private boolean rescheduleStopOfBackgroundUser(@UserIdInt Integer userIdInteger) {
// Clear any previous schedule (since we've already evaluated that we need to postpone) if
// necessary, and schedule stopping the user soon.
mHandler.removeEqualMessages(SCHEDULE_STOP_BACKGROUND_USER_MSG, userIdInteger);
return scheduleStopOfBackgroundUser(userIdInteger,
POSTPONEMENT_TIME_FOR_BACKGROUND_USER_STOP_SECS);
}
/**
* Possibly schedules the user to be stopped after the given number of seconds.
*
* This is only intended for background users (including profiles).
*
* Supplements, rather than replaces, any previous schedule. Ultimately, the future-most
* scheduled stop is what matters.
*/
private boolean scheduleStopOfBackgroundUser(@UserIdInt int userId, int delayUptimeSecs) {
if (!android.multiuser.Flags.scheduleStopOfBackgroundUser()) {
return false;
}
if (delayUptimeSecs <= 0) {
return false;
}
if (!isBackgroundUserEligibleForAutomaticStopping(userId)) {
Slogf.i(TAG, "Not scheduling to stop user %d since it's ineligible", userId);
return false;
}
// We're deciding to stop the user, so its fate is already sealed. No point judging it now.
ceaseJudgeFateOfBackgroundUser(userId);
Slogf.i(TAG, "Scheduling to stop user %d in %d seconds", userId, delayUptimeSecs);
final int delayUptimeMs = delayUptimeSecs * 1000;
final Object msgObj = userId;
mHandler.sendMessageDelayed(
mHandler.obtainMessage(SCHEDULE_STOP_BACKGROUND_USER_MSG, msgObj),
delayUptimeMs);
return true;
}
/**
* Possibly stops the given user due to it having been in the background for a long time.
* There is no guarantee of stopping the user; it is done discretionarily.
*
* This should never be called for background visible users; devices that support this should
* not use {@link #scheduleStopOfBackgroundUser(int, int)}.
*
* @param userIdInteger a user to be stopped if it is still in the background
*/
@VisibleForTesting
void processScheduledStopOfBackgroundUser(Integer userIdInteger) {
final int userId = userIdInteger;
Slogf.d(TAG, "Considering stopping-on-schedule background user %d", userId);
if (isUserScheduledForStopping(userIdInteger)) {
Slogf.i(TAG, "User %d is scheduled for bg stopping later, so wait until then", userId);
return;
}
if (avoidStoppingUserRightNow(userId)) {
Slogf.i(TAG, "Rescheduling bg stopping of user %d because it (or its profile) should "
+ "not be stopped right now ", userId);
rescheduleStopOfBackgroundUser(userIdInteger);
return;
}
synchronized (mLock) {
final Integer userOrParent = mUserProfileGroupIds.get(userId, userIdInteger);
if (getCurrentOrTargetUserIdLU() == userOrParent) {
// User is (somehow) already in the foreground, or we're currently switching to it.
return;
}
if (mPendingTargetUserIds.contains(userOrParent)) {
// We'll soon want to switch to this user, so don't kill it now.
return;
}
final UserInfo currentOrTargetUser = getCurrentUserLU();
if (currentOrTargetUser != null && currentOrTargetUser.isGuest()) {
// Don't kill any background users for the sake of a Guest. Just reschedule instead.
Slogf.i(TAG, "Current user %d is a Guest, so reschedule bg stopping of user %d",
currentOrTargetUser.id, userId);
rescheduleStopOfBackgroundUser(userIdInteger);
return;
}
Slogf.i(TAG, "Stopping-on-schedule background user %d", userId);
stopUsersLU(userId, /* stopProfileRegardlessOfParent= */ false,
/* allowDelayedLocking= */ true, null, null);
}
}
/**
* Returns whether to avoid stopping the given user because, even though it may only be in the
* background, it (or {@link #getUsersToStopLU(int) a user that would stop if it stopped}) is
* still currently useful (e.g. playing audio, or has an upcoming alarm).
*
* Makes requests of other services, so don't call while holding a lock.
*/
private boolean avoidStoppingUserRightNow(@UserIdInt int userId) {
return avoidStoppingUserRightNow(userId, mInjector.getVisibleActivityUsers());
}
/**
* Same as {@link #avoidStoppingUserRightNow(int)} but, for efficiency, takes the output of
* {@link Injector#getVisibleActivityUsers()} as a parameter.
*/
private boolean avoidStoppingUserRightNow(
@UserIdInt int userId, ArraySet