Android The multi-user in Windows is similar to the multi-user in Windows, which can support multiple users to use the system. Usually, the first user registered in the system will default to become a system administrator.

The settings of different users are different, and the application and application data installed by different users are also different. However, hardware-related settings in the system are common, such as network settings.

Android is different from Windows in that the background process run by the previous user can continue to run after the user switches. In this way, there is no need to interrupt some time-consuming operations in the background (downloaded below).

1. System Services for Managing Users--User Manager Service

The main function of UserManagerService is to create and delete users and query user information.

1. Initialization

UserManagerService is created in the construction method of PackageManagerService, as follows:

1. sUserManager = new UserManagerService(context, this, mInstallLock, mPackages);  

The construction method of UserManagerService is as follows:

1. UserManagerService(Context context, PackageManagerService pm,  
2.         Object installLock, Object packagesLock) {  
3.     this(context, pm, installLock, packagesLock,  
4.             Environment.getDataDirectory(),  
5.             new File(Environment.getDataDirectory(), "user"));  
6. }  

Call another constructor and pass two more parameters: / data directory and / data/user file. As follows:

1. private UserManagerService(Context context, PackageManagerService pm,  
2.         Object installLock, Object packagesLock,  
3.         File dataDir, File baseUserPath) {  
4.     mContext = context;  
5.     mPm = pm;  
6.     mInstallLock = installLock;  
7.     mPackagesLock = packagesLock;  
8.     mHandler = new Handler();  
9.     synchronized (mInstallLock) {  
10.         synchronized (mPackagesLock) {  
11.             mUsersDir = new File(dataDir, USER_INFO_DIR);// /data/system/users  
12.             mUsersDir.mkdirs();  
13.             // Make zeroth user directory, for services to migrate their files to that location  
14.             File userZeroDir = new File(mUsersDir, "0");//The first user's directory / data/system/users/0  
15.             userZeroDir.mkdirs();  
16.             mBaseUserPath = baseUserPath;// /data/user  
17.             FileUtils.setPermissions(mUsersDir.toString(),  
18.                     FileUtils.S_IRWXU|FileUtils.S_IRWXG  
19.                     |FileUtils.S_IROTH|FileUtils.S_IXOTH,  
20.                     -1, -1);  
21.             mUserListFile = new File(mUsersDir, USER_LIST_FILENAME);// /data/system/users/userlist.xml  
22.             initDefaultGuestRestrictions();  
23.             readUserListLocked();//Analysis of user information files  
24.             // Prune out any partially created/partially removed users.  
25.             ArrayList<UserInfo> partials = new ArrayList<UserInfo>();  
26.             for (int i = 0; i < mUsers.size(); i++) {  
27.                 UserInfo ui = mUsers.valueAt(i);  
28.                 if ((ui.partial || ui.guestToRemove) && i != 0) {  
29.                     partials.add(ui);//Find the user whose attribute partial is true in the userlist.xml file  
30.                 }  
31.             }  
32.             for (int i = 0; i < partials.size(); i++) {  
33.                 UserInfo ui = partials.get(i);  
34.                 Slog.w(LOG_TAG, "Removing partially created user #" + i  
35.                         + " (name=" + ui.name + ")");  
36.                 removeUserStateLocked(ui.id);//Attribute to partial represents the creation of an incomplete user, removed from the system  
37.             }  
38.             sInstance = this;  
39.         }  
40.     }  
41. }  

Several directories are created in the construction method: / data/system/users, data/system/users/0, / data/system/users/userlist.xml, etc. After that, the basic restrictions are set as follows:

1. private void initDefaultGuestRestrictions() {  
2.     if (mGuestRestrictions.isEmpty()) {  
3.         mGuestRestrictions.putBoolean(UserManager.DISALLOW_OUTGOING_CALLS, true);//"no_outgoing_calls"  
4.         mGuestRestrictions.putBoolean(UserManager.DISALLOW_SMS, true);//"no_sms"  
5.     }  
6. }  

Then the readUserListLocked() method is called to parse the / data/system/users/userlist.xml file, which saves the id information of all users in the system. The document reads as follows:

1. <?xml version='1.0' encoding='utf-8' standalone='yes' ?>  
2. <users nextSerialNumber="11" version="5">  
3.     <guestRestrictions>  
4.         <restrictions no_outgoing_calls="true" no_sms="true" />  
5.     </guestRestrictions>  
6.     <user id="0" />  
7.     <user id="10" />  
8. </users>  

After getting the ID information, the XML file which saves the user registration information is read and expressed by the number of the user id, such as 0.xml. The contents are as follows:

1. <?xml version='1.0' encoding='utf-8' standalone='yes' ?>  
2. <user id="0" serialNumber="0" flags="19" created="0" lastLoggedIn="1436392413074">  
3.     <name>Owner</name>  
4.     <restrictions />  
5. </user>  

After reading the user's xml file content, a UserInfo object will be created and initialized according to the file content to save information, and the object will be added to the mUsers list. If there is partial="true" in the attribute of a user in the xml file, it means that the user has not been created successfully and needs to be removed from the system.

This completes the initialization of the UserManagerService. The main task is to analyze the userlist.xml file and create the UserInfo object in the mUsers list.

2. Definition of UserInfo

In UserManagerService, the UserInfo object represents the user and is defined as follows:

1. public class UserInfo implements Parcelable {  
2.   
3.     /** 8 bits for user type User type*/  
4.     public static final int FLAG_MASK_USER_TYPE = 0x000000FF;  
5.   
6.     /** 
7.      * Primary user. Only one user can have this flag set. Meaning of this 
8.      * flag TBD.The logo of the primary user, usually the first user with an Id of 0 
9.      */  
10.     public static final int FLAG_PRIMARY = 0x00000001;  
11.   
12.     /** 
13.      * User with administrative privileges. Such a user can create and 
14.      * delete users.admin User logo, with which users can be created and deleted 
15.      */  
16.     public static final int FLAG_ADMIN   = 0x00000002;  
17.   
18.     /** 
19.      * Indicates a guest user that may be transient.guest user identity 
20.      */  
21.     public static final int FLAG_GUEST   = 0x00000004;  
22.   
23.     /** 
24.      * Indicates the user has restrictions in privileges, Identify users with limited privileges, and the specific restricted functions are undetermined. 
25.      * Exact meaning TBD. For instance, maybe they can't install apps or administer WiFi access pts. 
26.      */  
27.     public static final int FLAG_RESTRICTED = 0x00000008;  
28.   
29.     /** 
30.      * Indicates that this user has gone through its first-time initialization.Identify whether the user has been initialized 
31.      */  
32.     public static final int FLAG_INITIALIZED = 0x00000010;  
33.   
34.     /** 
35.      * Indicates that this user is a profile of another user, for example holding a users 
36.      * corporate data.Identify whether the UserInfo is user information or a profile 
37.      */  
38.     public static final int FLAG_MANAGED_PROFILE = 0x00000020;  
39.   
40.     /** 
41.      * Indicates that this user is disabled.Identify whether the user has been "banned" 
42.      */  
43.     public static final int FLAG_DISABLED = 0x00000040;  
44.   
45.     public static final int NO_PROFILE_GROUP_ID = -1;//Invalid value definition of profile group id  
46.   
47.     public int id;//User id  
48.     public int serialNumber;//User's serial number, no duplication  
49.     public String name;//User name  
50.     public String iconPath;//User's avatar path  
51.     public int flags;//User's logo  
52.     public long creationTime;//Time to create users  
53.     public long lastLoggedInTime;//Time of last login  
54.     public int profileGroupId;//User profile group id  
55.   
56.     /** User is only partially created. */  
57.     public boolean partial;//This flag is true, indicating that the user has not created it.  
58.     public boolean guestToRemove;  

Note: User id is used to identify the user, and after deletion, its id will be assigned to the next new user to keep the id number continuous; while serialNumber is a number that will not be repeated in the device to uniquely identify a user. If you want to record information related to a user in the application, it is better to use serialNumber to represent the user rather than the user id.

3. Restriction

User Manager in Android 5.1 defines many user-related restrictions that allow administrators to give different users different permissions when creating users.

1. public static final String DISALLOW_MODIFY_ACCOUNTS = "no_modify_accounts";//Restrict modification of user accounts  
2. public static final String DISALLOW_CONFIG_WIFI = "no_config_wifi";//Restrict WiFi Configuration  
3. public static final String DISALLOW_INSTALL_APPS = "no_install_apps";//Restrict the installation of app s  
4. public static final String DISALLOW_UNINSTALL_APPS = "no_uninstall_apps";//Restrict unloading app  
5. public static final String DISALLOW_SHARE_LOCATION = "no_share_location";//Limit shared geographic location  
6. public static final String DISALLOW_INSTALL_UNKNOWN_SOURCES = "no_install_unknown_sources";//Limit installation of local applications  
7. public static final String DISALLOW_CONFIG_BLUETOOTH = "no_config_bluetooth";//Restricted Bluetooth Configuration  
8. public static final String DISALLOW_USB_FILE_TRANSFER = "no_usb_file_transfer";//Restrict file transfer through usb  
9. public static final String DISALLOW_CONFIG_CREDENTIALS = "no_config_credentials";//Restrict the security settings of configuration devices  
10. public static final String DISALLOW_REMOVE_USER = "no_remove_user";//Restrict deletion of users  
11. public static final String DISALLOW_DEBUGGING_FEATURES = "no_debugging_features";//Restrict the use of debugging functions  
12. public static final String DISALLOW_CONFIG_VPN = "no_config_vpn";//Restrict configuration of VPN  
13. public static final String DISALLOW_CONFIG_TETHERING = "no_config_tethering";//Restrict configuration Tether  
14. public static final String DISALLOW_FACTORY_RESET = "no_factory_reset";//Restrict factory settings  
15. public static final String DISALLOW_ADD_USER = "no_add_user";//Restrict the creation of users  
16. public static final String ENSURE_VERIFY_APPS = "ensure_verify_apps";//Check the app installed by this user  
17. public static final String DISALLOW_CONFIG_CELL_BROADCASTS = "no_config_cell_broadcasts";//Restrict user configurations for cell broadcasting  
18. public static final String DISALLOW_CONFIG_MOBILE_NETWORKS = "no_config_mobile_networks";//Restriction on configuring mobile networks  
19. public static final String DISALLOW_APPS_CONTROL = "no_control_apps";//Restrict the removal of application data and caches  
20. public static final String DISALLOW_MOUNT_PHYSICAL_MEDIA = "no_physical_media";//Restricted mount  
21. public static final String DISALLOW_UNMUTE_MICROPHONE = "no_unmute_microphone";//Restrict silencing of microphone  
22. public static final String DISALLOW_ADJUST_VOLUME = "no_adjust_volume";//Limit volume  
23. public static final String DISALLOW_OUTGOING_CALLS = "no_outgoing_calls";//Restrict Calling  
24. public static final String DISALLOW_SMS = "no_sms";//Restrict sending SMS  
25. public static final String DISALLOW_CREATE_WINDOWS = "no_create_windows";//Limiting User's Application for Bullet Window Function  
26. public static final String DISALLOW_CROSS_PROFILE_COPY_PASTE = "no_cross_profile_copy_paste";//Restrict copying and pasting profile s  
27. public static final String DISALLOW_OUTGOING_BEAM = "no_outgoing_beam";//limit  

4. Adding Users

The user interface added to the UserManagerService service is createUser(), as follows:

1. public UserInfo createUser(String name, int flags) {  
2.     checkManageUsersPermission("Only the system can create users");  
3.   
4.     return createUserInternal(name, flags, UserHandle.USER_NULL);  
5. }  

The createUser() method first checks the permissions of the caller, which can only be invoked by a process with system identity. Then call the createUserInternal() method to continue execution, as follows:

1.     private UserInfo createUserInternal(String name, int flags, int parentId) {  
2.         if (getUserRestrictions(UserHandle.getCallingUserId()).getBoolean(  
3.                 UserManager.DISALLOW_ADD_USER, false)) {//Get permission to add users  
4.             Log.w(LOG_TAG, "Cannot add user. DISALLOW_ADD_USER is enabled.");  
5.             return null;  
6.         }  
7.         final boolean isGuest = (flags & UserInfo.FLAG_GUEST) != 0;  
8.         final long ident = Binder.clearCallingIdentity();  
9.         UserInfo userInfo = null;  
10.         try {  
11.             synchronized (mInstallLock) {  
12.                 synchronized (mPackagesLock) {  
13.                     UserInfo parent = null;  
14.                     if (parentId != UserHandle.USER_NULL) {  
15.                         parent = getUserInfoLocked(parentId);  
16.                         if (parent == null) return null;  
17.                     }  
18.                     //If the Guest user is not added and reaches the upper limit, return  
19.                     if (!isGuest && isUserLimitReachedLocked()) {  
20.                         return null;  
21.                     }  
22.                     //If the Guest user is added, but the Guest user already exists, return  
23.                     if (isGuest && findCurrentGuestUserLocked() != null) {  
24.                         return null;  
25.                     }  
26.                     //  
27.                     if ((flags & UserInfo.FLAG_MANAGED_PROFILE) != 0  
28.                             && numberOfUsersOfTypeLocked(UserInfo.FLAG_MANAGED_PROFILE, true)  
29.                                 >= MAX_MANAGED_PROFILES) {//At present, the maximum MAX_MANAGED_PROFILES is 1  
30.                         return null;//If a profile of a user is created, check that the user already has a profile  
31.                     }  
32.                     int userId = getNextAvailableIdLocked();//Get the new user ID  
33.                     userInfo = new UserInfo(userId, name, null, flags);  
34.                     File userPath = new File(mBaseUserPath, Integer.toString(userId));  
35.                     userInfo.serialNumber = mNextSerialNumber++;  
36.                     long now = System.currentTimeMillis();  
37.                     userInfo.creationTime = (now > EPOCH_PLUS_30_YEARS) ? now : 0;  
38.                     userInfo.partial = true;//Set the partial attribute to true  
39.                     Environment.getUserSystemDirectory(userInfo.id).mkdirs();  
40.                     mUsers.put(userId, userInfo);//Add new user information to mUsers  
41.                     writeUserListLocked();//Write user information to the file userlist.xml  
42.                     if (parent != null) {  
43.                         if (parent.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID) {  
44.                             parent.profileGroupId = parent.id;  
45.                             writeUserLocked(parent);  
46.                         }  
47.                         userInfo.profileGroupId = parent.profileGroupId;  
48.                     }  
49.                     writeUserLocked(userInfo);//Create user information file 10.xml  
50.                     mPm.createNewUserLILPw(userId, userPath);  
51.                     userInfo.partial = false;//Create success, set partial to false  
52.                     writeUserLocked(userInfo);//Update the user's information file  
53.                     updateUserIdsLocked();  
54.                     Bundle restrictions = new Bundle();  
55.                     mUserRestrictions.append(userId, restrictions);  
56.                 }  
57.             }  
58.             if (userInfo != null) {//Broadcast users create successful messages  
59.                 Intent addedIntent = new Intent(Intent.ACTION_USER_ADDED);  
60.                 addedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userInfo.id);  
61.                 mContext.sendBroadcastAsUser(addedIntent, UserHandle.ALL,  
62.                         android.Manifest.permission.MANAGE_USERS);  
63.             }  
64.         } finally {  
65.             Binder.restoreCallingIdentity(ident);  
66.         }  
67.         return userInfo;  
68.       

(1) Check whether the user to which the calling process belongs is restricted to adding users.

(2) Call the isUserLimitReachedLocked() method to determine whether more users can be created. The isUserLimitReachedLocked() method calls the getMaxSupportedUsers() method to compare the maximum number of users allowed by the system with the current number of users.

(3) Call the getNextAvailableIdLocked() method to get the new user ID. The getNextAvailableIdLocked() method looks up from 10 and returns a user ID if it is not already in use.

(4) Create user's data directory according to user id. UserInfo objects are created for users and added to the mUsers list.

(5) Add user id information to userlist.xml file. Create an XML file in the / data/system/users / directory, which is represented by the user id number, and save the user information in UserInfo. The partial attribute in the file will be set to true.

(6) Call the createNewuserLILPw() method of PackageManagerService to create a data directory for all applications under the directory of the new user.

(7) Update the user's information file and remove the partial attribute from the xml file so that the new user is created. The purpose of using partial attributes is to prevent errors in calling the createNewUserLILPw() method and failing to create users successfully. With this flag, users who failed to create can be cleared when the system restarts.

(8) Broadcast the message Intent.ACTION_USER_ADDED that joins the new user.

5. Guest users

In Android 5.0, creating Guest users needs to be done through the createGuest() method of UserManager. As follows:

1. public UserInfo createGuest(Context context, String name) {  
2.     UserInfo guest = createUser(name, UserInfo.FLAG_GUEST);//Creating Guest Users  
3.     if (guest != null) {  
4.         Settings.Secure.putStringForUser(context.getContentResolver(),  
5.                 Settings.Secure.SKIP_FIRST_USE_HINTS, "1", guest.id);  
6.         try {//Restrict the privileges of Guest users  
7.             Bundle guestRestrictions = mService.getDefaultGuestRestrictions();  
8.             guestRestrictions.putBoolean(DISALLOW_SMS, true);  
9.             guestRestrictions.putBoolean(DISALLOW_INSTALL_UNKNOWN_SOURCES, true);  
10.             mService.setUserRestrictions(guestRestrictions, guest.id);  
11.         } catch (RemoteException re) {  
12.             Log.w(TAG, "Could not update guest restrictions");  
13.         }  
14.     }  
15.     return guest;  
16. }  

createGuest () first calls the createUser() method to create a Guest user, and then calls the setUserRestrictions() method to further restrict the Guest user. Therefore, the difference between Guest users and ordinary users is that they have different permissions.

6. Delete Users

The removeUser() method is used to delete the user's interface in the UserManagerService service, as follows:

1. public boolean removeUser(int userHandle) {  
2.     checkManageUsersPermission("Only the system can remove users");  
3.     if (getUserRestrictions(UserHandle.getCallingUserId()).getBoolean(  
4.             UserManager.DISALLOW_REMOVE_USER, false)) {  
5.         Log.w(LOG_TAG, "Cannot remove user. DISALLOW_REMOVE_USER is enabled.");  
6.         return false;  
7.     }//Check the permissions of the calling process and whether the user to which the process belongs is "restricted"  
8.   
9.     long ident = Binder.clearCallingIdentity();  
10.     try {  
11.         final UserInfo user;  
12.         synchronized (mPackagesLock) {  
13.             user = mUsers.get(userHandle);  
14.             if (userHandle == 0 || user == null || mRemovingUserIds.get(userHandle)) {  
15.                 return false;  
16.             }  
17.   
18.             //Place userHandle in the mRemovingUserIds list to prevent duplicate deletion of a user  
19.             mRemovingUserIds.put(userHandle, true);  
20.   
21.             try {  
22.                 mAppOpsService.removeUser(userHandle);  
23.             } catch (RemoteException e) {  
24.                 Log.w(LOG_TAG, "Unable to notify AppOpsService of removing user", e);  
25.             }  
26.             // Set this to a partially created user, so that the user will be purged  
27.             // on next startup, in case the runtime stops now before stopping and  
28.             // removing the user completely.  
29.             user.partial = true;  
30.             // Mark it as disabled, so that it isn't returned any more when  
31.             // profiles are queried.  
32.             user.flags |= UserInfo.FLAG_DISABLED;  
33.             writeUserLocked(user);//Update user information file  
34.         }  
35.   
36.         if (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID  
37.                 && user.isManagedProfile()) {  
38.             // Send broadcast to notify system that the user removed was a  
39.             // managed user.  
40.             sendProfileRemovedBroadcast(user.profileGroupId, user.id);  
41.         }  
42.   
43.         if (DBG) Slog.i(LOG_TAG, "Stopping user " + userHandle);  
44.         int res;  
45.         try {//Stop running users  
46.             res = ActivityManagerNative.getDefault().stopUser(userHandle,  
47.                     new IStopUserCallback.Stub() {//callback  
48.                         @Override  
49.                         public void userStopped(int userId) {  
50.                             finishRemoveUser(userId);  
51.                         }  
52.                         @Override  
53.                         public void userStopAborted(int userId) {  
54.                         }  
55.                     });  
56.         } catch (RemoteException e) {  
57.             return false;  
58.         }  
59.         return res == ActivityManager.USER_OP_SUCCESS;  
60.     } finally {  
61.         Binder.restoreCallingIdentity(ident);  
62.     }  
63. }  

The removeUser() method does not delete user-related files immediately, but first changes the partial attribute of user information to true. The advantage is that if the subsequent process is terminated unexpectedly, all directories and files of the user will be deleted after the system restarts.

Considering that the deleted user may be running, the removeUser() method calls the stopUser() method of ActivityManagerService to change the user's running status. After that, AMS calls the callback method in the function parameter and finally calls the finishRemoveUser() method. As follows:

1. void finishRemoveUser(final int userHandle) {  
2.     if (DBG) Slog.i(LOG_TAG, "finishRemoveUser " + userHandle);  
3.     // Let other services shutdown any activity and clean up their state before completely  
4.     // wiping the user's system directory and removing from the user list  
5.     long ident = Binder.clearCallingIdentity();  
6.     try {  
7.         Intent addedIntent = new Intent(Intent.ACTION_USER_REMOVED);  
8.         addedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userHandle);  
9.         mContext.sendOrderedBroadcastAsUser(addedIntent, UserHandle.ALL,  
10.                 android.Manifest.permission.MANAGE_USERS,  
11.   
12.                 new BroadcastReceiver() {  
13.                     @Override  
14.                     public void onReceive(Context context, Intent intent) {  
15.                         if (DBG) {  
16.                             Slog.i(LOG_TAG,  
17.                                     "USER_REMOVED broadcast sent, cleaning up user data "  
18.                                     + userHandle);  
19.                         }  
20.                         new Thread() {  
21.                             public void run() {  
22.                                 synchronized (mInstallLock) {  
23.                                     synchronized (mPackagesLock) {  
24.                                         removeUserStateLocked(userHandle);  
25.                                     }  
26.                                 }  
27.                             }  
28.                         }.start();  
29.                     }  
30.                 },  
31.   
32.                 null, Activity.RESULT_OK, null, null);  
33.     } finally {  
34.         Binder.restoreCallingIdentity(ident);  
35.     }  
36. }  

In the finishRemoveUser() method, the broadcast Intent.ACTION_USER_REMOVED is issued, and a Broadcast Receiver object is created to receive the broadcast. Note that the broadcast receiver created at this time will finally receive the broadcast notification. This is in order to let other places in the system concerned about this broadcast process first, and finally return here to continue to complete the deletion of users. After receiving the broadcast, considering the time-consuming work ahead, a thread is started in the onReceiver() method to run the removeUserStateLocked() method. The code is as follows:

1. private void removeUserStateLocked(final int userHandle) {  
2.     //Cleanup package manager settings call the cleanUpUserLILPw method of PackageManagerService to delete app data from all user directories  
3.     mPm.cleanUpUserLILPw(this, userHandle);  
4.   
5.     //Remove this user from the list to delete the user's UserInfo object in the mUsers list  
6.     mUsers.remove(userHandle);  
7.   
8.     mRestrictionsPinStates.remove(userHandle);//Remove users from the mRestrictions PinStates list  
9.     //Remove user file to delete user's information file  
10.     AtomicFile userFile = new AtomicFile(new File(mUsersDir, userHandle + XML_SUFFIX));  
11.     userFile.delete();  
12.     // Update the user list  
13.     writeUserListLocked();//Update the file userlists.xml to remove user information  
14.     updateUserIdsLocked();  
15.     removeDirectoryRecursive(Environment.getUserSystemDirectory(userHandle));//Delete all files in the user directory  
16. }  

The removeUserStateLocked() method deletes all user-related files. First, the data file of app, then the user information file and the user Id information in userlist.xml. Finally, all the files in the user directory are deleted.

Package Manager Service and Multi-user

In a multi-user environment, all applications installed by users are still located in the / data/app directory, but the data of these applications is a separate copy under each user's directory / data / user /< user id >/. Directory / data/data also saves application data, but these data are only valid for users with id 0.

1. Creating User's Application Data

As mentioned above, the createNewUserLILPw() method of PackageManagerService is invoked when creating users, as follows:

1. /** Called by UserManagerService */  
2. void createNewUserLILPw(int userHandle, File path) {  
3.     if (mInstaller != null) {  
4.         mInstaller.createUserConfig(userHandle);  
5.         mSettings.createNewUserLILPw(this, mInstaller, userHandle, path);  
6.     }  
7. }  

The createNewUserLILPw() method simply calls mInstaller's createUserConfig() and mSettings'createNewUserLILPw() methods.

Let's first look at how mInstaller's createUserConfig() method handles it, as follows:

1. public int createUserConfig(int userId) {  
2.     StringBuilder builder = new StringBuilder("mkuserconfig");  
3.     builder.append(' ');  
4.     builder.append(userId);  
5.     return mInstaller.execute(builder.toString());  
6. }  

mInstaller is the object of InstallerConnection, where the execute() method of the InstallConnection object is called, as follows:

1. public int execute(String cmd) {  
2.     String res = transact(cmd);  
3.     try {  
4.         return Integer.parseInt(res);  
5.     } catch (NumberFormatException ex) {  
6.         return -1;  
7.     }  
8. }  

The process of communication with installd service is realized here, and the specific operation is completed by installd service. Looking at mSettings'createNewUserLILPw() method, we know that mSettings holds information about all applications read from files. As follows:

1. void createNewUserLILPw(PackageManagerService service, Installer installer,  
2.         int userHandle, File path) {  
3.     path.mkdir();//Create a directory / data/user for users to save application data  
4.     FileUtils.setPermissions(path.toString(), FileUtils.S_IRWXU | FileUtils.S_IRWXG  
5.             | FileUtils.S_IXOTH, -1, -1);  
6.     for (PackageSetting ps : mPackages.values()) {  
7.         if (ps.pkg == null || ps.pkg.applicationInfo == null) {  
8.             continue;  
9.         }//Create a data directory for each application in the user's directory  
10.         // Only system apps are initially installed.  
11.         ps.setInstalled((ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) != 0, userHandle);  
12.         // Need to create a data directory for all apps under this user.  
13.         installer.createUserData(ps.name,  
14.                 UserHandle.getUid(userHandle, ps.appId), userHandle,  
15.                 ps.pkg.applicationInfo.seinfo);  
16.     }  
17.     readDefaultPreferredAppsLPw(service, userHandle);  
18.     writePackageRestrictionsLPr(userHandle);  
19. }  

The createNewUserLILPw() method traverses the mPackages list, which stores all installed application information in the system. Then for each application, the installer's createUserData() method is invoked, and the Installer method eventually invokes the command of the installd daemon, where the installd "mkuserdata" command is finally invoked to perform the creation of the application data directory. Work.

1. public int createUserData(String name, int uid, int userId, String seinfo) {  
2.     StringBuilder builder = new StringBuilder("mkuserdata");  
3.     builder.append(' ');  
4.     builder.append(name);  
5.     builder.append(' ');  
6.     builder.append(uid);  
7.     builder.append(' ');  
8.     builder.append(userId);  
9.     builder.append(' ');  
10.     builder.append(seinfo != null ? seinfo : "!");  
11.      
12.     return mInstaller.execute(builder.toString());  
13. }  

At the same time, there is an array userState in each application's setup object PackageSetting, which indicates which users the application has been installed into. The setInstalled method calling ps here is to insert user information into the array userState.

The readDefault Preferred Apps LPw () method is called to analyze all xml files in the directory / etc/preferred-apps, where the xml files hold the most appropriate components specified by the device user to respond to an intent. Because each user can specify the most appropriate component it likes, each user needs to add its own Preferred IntentResolver object to the mPreferred Activities list, which stores the intent and the associated data of the component.

2. Delete User's Application Data

The cleanUpUserLILPw() method is used to delete users in PackageManagerService, as follows:

1. /** Called by UserManagerService */  
2. void cleanUpUserLILPw(UserManagerService userManager, int userHandle) {  
3.     mDirtyUsers.remove(userHandle);  
4.     mSettings.removeUserLPw(userHandle);  
5.     mPendingBroadcasts.remove(userHandle);  
6.     if (mInstaller != null) {  
7.         // Technically, we shouldn't be doing this with the package lock  
8.         // held.  However, this is very rare, and there is already so much  
9.         // other disk I/O going on, that we'll let it slide for now.  
10.         mInstaller.removeUserDataDirs(userHandle);//Delete all application data in user directory  
11.     }  
12.     mUserNeedsBadging.delete(userHandle);  
13.     removeUnusedPackagesLILPw(userManager, userHandle);  
14. }  

The main task of the cleanUpUserLILPw method is to call mInstaller's removeUserDataDirs() method to delete the data of all applications in the user directory. At the same time, the removeUserLPw() method of mSettings is called to delete the user-related data in PackageManagerService, as follows:

1. void removeUserLPw(int userId) {  
2.     Set<Entry<String, PackageSetting>> entries = mPackages.entrySet();  
3.     for (Entry<String, PackageSetting> entry : entries) {  
4.         entry.getValue().removeUser(userId);  
5.     }<span style="font-family: Arial, Helvetica, sans-serif;">//Delete the user's information in each application information</span>  
6.     mPreferredActivities.remove(userId);//Delete the user's data from the mPreferred Activities list  
7.     File file = getUserPackagesStateFile(userId);  
8.     file.delete();//Delete the package-restrictions.xml file in the user directory  
9.     file = getUserPackagesStateBackupFile(userId);  
10.     file.delete();  
11.     removeCrossProfileIntentFiltersLPw(userId);  
12. }  

Activity Manager Service and Multi-user

User Manager Service mainly manages user's account information, and user management in operation is implemented by Activity Manager Service.

1. User's Status

Users have four operating states, which are defined as follows:

1. public final class UserStartedState {  
2.     // User is first coming up.  
3.     public final static int STATE_BOOTING = 0;//User is booting  
4.     // User is in the normal running state.  
5.     public final static int STATE_RUNNING = 1;//The user is running  
6.     // User is in the initial process of being stopped.  
7.     public final static int STATE_STOPPING = 2;//Users are stopping  
8.     // User is in the final phase of stopping, sending Intent.ACTION_SHUTDOWN.  
9.     public final static int STATE_SHUTDOWN = 3;//User has been turned off  

In AMS, the variable mCurrentUserId records the current user Id, while the mStartedUsers list saves the running user. Only the users in the mStartedUsers list will have the four States listed above. Those who are not in the list are registered but not running users.

2. Switching Current Users

The interface switchUser() for switching current users is provided in Activity Manager Service as follows:

1. public boolean switchUser(final int userId) {  
2.     enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, userId);  
3.     String userName;  
4.     synchronized (this) {  
5.         UserInfo userInfo = getUserManagerLocked().getUserInfo(userId);//Get the UserInfo corresponding to userId  
6.         if (userInfo == null) {  
7.             Slog.w(TAG, "No user info for user #" + userId);  
8.             return false;  
9.         }  
10.         if (userInfo.isManagedProfile()) {//If this UserInfo is just another profile of User, exit  
11.             Slog.w(TAG, "Cannot switch to User #" + userId + ": not a full user");  
12.             return false;  
13.         }  
14.         userName = userInfo.name;  
15.         mTargetUserId = userId;  
16.     }  
17.     mHandler.removeMessages(START_USER_SWITCH_MSG);  
18.     mHandler.sendMessage(mHandler.obtainMessage(START_USER_SWITCH_MSG, userId, 0, userName));//Send messages to switched users  
19.     return true;  
20. }  

switchUser() first calls the getUserInfo() method to get the user information corresponding to userId, and then uses the isManagedProfile() method to determine whether the UserInfo is just a profile(Android allows one user to have another profile). If it is indeed a user, the message START_USER_SWITCH_MSG is sent.

The processing of the message START_USER_SWITCH_MSG is to call the method showUserSwitchDialog, which will pop up a dialog box to determine whether to switch users. Once the user clicks the confirmation button, the startUserInForeground() method is called.

1. case START_USER_SWITCH_MSG: {  
2.     showUserSwitchDialog(msg.arg1, (String) msg.obj);  
3.     break;  
4. }  

1. private void showUserSwitchDialog(int userId, String userName) {  
2.     // The dialog will show and then initiate the user switch by calling startUserInForeground  
3.     Dialog d = new UserSwitchingDialog(this, mContext, userId, userName,  
4.             true /* above system */);  
5.     d.show();  
6. }  

The startUserInForeground() method is as follows:

1. /** 
2.  * Start user, if its not already running, and bring it to foreground. 
3.  */  
4. boolean startUserInForeground(final int userId, Dialog dlg) {  
5.     boolean result = startUser(userId, /* foreground */ true);  
6.     dlg.dismiss();  
7.     return result;  
8. }  

In the startUserInForeground() method, only the startUser() method is called, as follows:

1. private boolean startUser(final int userId, final boolean foreground) {  
2.     if (checkCallingPermission(INTERACT_ACROSS_USERS_FULL)  
3.             != PackageManager.PERMISSION_GRANTED) {  
4.         . . . . . . //Check caller privileges  
5.     }  
6.     final long ident = Binder.clearCallingIdentity();  
7.     try {  
8.         synchronized (this) {  
9.             final int oldUserId = mCurrentUserId;  
10.             if (oldUserId == userId) {  
11.                 return true;//The current user is the user whose parameters are specified. Exit  
12.             }  
13.   
14.             mStackSupervisor.setLockTaskModeLocked(null, false, "startUser");  
15.   
16.             final UserInfo userInfo = getUserManagerLocked().getUserInfo(userId);  
17.             . . . . . . //Some error handling, returning false  
18.             if (foreground) {  
19.                 mWindowManager.startFreezingScreen(R.anim.screen_user_exit,  
20.                         R.anim.screen_user_enter);  
21.             }  
22.   
23.             boolean needStart = false;  
24.   
25.             //If the user has not started yet, the user needs to start first and switch the user status to be started  
26.             if (mStartedUsers.get(userId) == null) {  
27.                 mStartedUsers.put(userId, new UserStartedState(new UserHandle(userId), false));  
28.                 updateStartedUserArrayLocked();  
29.                 needStart = true;  
30.             }  
31.   
32.             final Integer userIdInt = Integer.valueOf(userId);  
33.             mUserLru.remove(userIdInt);  
34.             mUserLru.add(userIdInt);//Adjust the user's position in the mUserLru list, with the current user at the bottom  
35.   
36.             if (foreground) {//Foreground switching  
37.                 mCurrentUserId = userId;//Switching the current user  
38.                 mTargetUserId = UserHandle.USER_NULL; // reset, mCurrentUserId has caught up  
39.                 updateCurrentProfileIdsLocked();  
40.                 mWindowManager.setCurrentUser(userId, mCurrentProfileIds);//Set up the current user in WMS  
41.                 mWindowManager.lockNow(null);//Lock screen  
42.             } else {  
43.                 final Integer currentUserIdInt = Integer.valueOf(mCurrentUserId);  
44.                 updateCurrentProfileIdsLocked();  
45.                 mWindowManager.setCurrentProfileIds(mCurrentProfileIds);  
46.                 mUserLru.remove(currentUserIdInt);  
47.                 mUserLru.add(currentUserIdInt);  
48.             }  
49.   
50.             final UserStartedState uss = mStartedUsers.get(userId);  
51.   
52.             // Make sure user is in the started state.  If it is currently  
53.             // stopping, we need to knock that off.  
54.             if (uss.mState == UserStartedState.STATE_STOPPING) {  
55.                 //If the user's status is stopping, switch to running  
56.                 uss.mState = UserStartedState.STATE_RUNNING;  
57.                 updateStartedUserArrayLocked();  
58.                 needStart = true;  
59.             } else if (uss.mState == UserStartedState.STATE_SHUTDOWN) {  
60.                 //If the user's status is positive or closed, switch to active  
61.                 uss.mState = UserStartedState.STATE_BOOTING;  
62.                 updateStartedUserArrayLocked();  
63.                 needStart = true;  
64.             }  
65.   
66.             if (uss.mState == UserStartedState.STATE_BOOTING) {  
67.                 //Send message SYSTEM_USER_START_MSG if the user's status is booting  
68.                 mHandler.sendMessage(mHandler.obtainMessage(SYSTEM_USER_START_MSG, userId, 0));  
69.             }  
70.   
71.             if (foreground) {  
72.                 mHandler.sendMessage(mHandler.obtainMessage(SYSTEM_USER_CURRENT_MSG, userId,  
73.                         oldUserId));  
74.                 mHandler.removeMessages(REPORT_USER_SWITCH_MSG);  
75.                 mHandler.removeMessages(USER_SWITCH_TIMEOUT_MSG);  
76.                 mHandler.sendMessage(mHandler.obtainMessage(REPORT_USER_SWITCH_MSG,  
77.                         oldUserId, userId, uss));  
78.                 mHandler.sendMessageDelayed(mHandler.obtainMessage(USER_SWITCH_TIMEOUT_MSG,  
79.                         oldUserId, userId, uss), USER_SWITCH_TIMEOUT);  
80.             }  
81.   
82.             if (needStart) {  
83.                 //If the user is not in the STATE_RUNNING state before handover, broadcast ACTION_USER_STARTED to the user  
84.                 Intent intent = new Intent(Intent.ACTION_USER_STARTED);  
85.                 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY  
86.                         | Intent.FLAG_RECEIVER_FOREGROUND);  
87.                 intent.putExtra(Intent.EXTRA_USER_HANDLE, userId);  
88.                 broadcastIntentLocked(null, null, intent,  
89.                         null, null, 0, null, null, null, AppOpsManager.OP_NONE,  
90.                         false, false, MY_PID, Process.SYSTEM_UID, userId);  
91.             }  
92.   
93.             if ((userInfo.flags&UserInfo.FLAG_INITIALIZED) == 0) {  
94.                 if (userId != UserHandle.USER_OWNER) {//If the user has not been initialized, send the broadcast ACTION_USER_INITIALIZE to the user  
95.                     Intent intent = new Intent(Intent.ACTION_USER_INITIALIZE);  
96.                     intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);  
97.                     broadcastIntentLocked(null, null, intent, null,  
98.                             new IIntentReceiver.Stub() {  
99.                                 public void performReceive(Intent intent, int resultCode,  
100.                                         String data, Bundle extras, boolean ordered,  
101.                                         boolean sticky, int sendingUser) {  
102.                                     onUserInitialized(uss, foreground, oldUserId, userId);  
103.                                 }  
104.                             }, 0, null, null, null, AppOpsManager.OP_NONE,  
105.                             true, false, MY_PID, Process.SYSTEM_UID,  
106.                             userId);  
107.                     uss.initializing = true;  
108.                 } else {//Otherwise, call the makeInitialized method of UserManagerService directly  
109.                     getUserManagerLocked().makeInitialized(userInfo.id);  
110.                 }  
111.             }  
112.   
113.             if (foreground) {  
114.                 if (!uss.initializing) {//If the user has been initialized, set it as a front-end user  
115.                     moveUserToForeground(uss, oldUserId, userId);  
116.                 }  
117.             } else {//Otherwise, add users to mStartingBackgroundUser first  
118.                 mStackSupervisor.startBackgroundUserLocked(userId, uss);  
119.             }  
120.   
121.             if (needStart) {//If the user is not in STATE_RUNNING state, broadcast ACTION_USER_STARTING to all users  
122.                 Intent intent = new Intent(Intent.ACTION_USER_STARTING);  
123.                 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);  
124.                 intent.putExtra(Intent.EXTRA_USER_HANDLE, userId);  
125.                 broadcastIntentLocked(null, null, intent,  
126.                         null, new IIntentReceiver.Stub() {  
127.                             @Override  
128.                             public void performReceive(Intent intent, int resultCode, String data,  
129.                                     Bundle extras, boolean ordered, boolean sticky, int sendingUser)  
130.                                     throws RemoteException {  
131.                             }  
132.                         }, 0, null, null,  
133.                         INTERACT_ACROSS_USERS, AppOpsManager.OP_NONE,  
134.                         true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL);  
135.             }  
136.         }  
137.     } finally {  
138.         Binder.restoreCallingIdentity(ident);  
139.     }  
140.   
141.     return true;  
142. }  

The startUser() method code is long. The method first determines the user's status, and if the user is not running, there will be no user information in the mStartedUsers list. Therefore, we need to create the object UserStartedState that represents the user's status, and then add it to the mStartedUsers list. You also need to adjust the user's position in the mUserLru list to the last item. The maximum number of users running simultaneously in the system is 3 (the current definition). The mUserLru list is to record the login order of users and stop the redundant users running when needed.

For users already in the mStarted Users list, first determine whether its state is STATE_RUNNING, if not, it needs to complete the state transition, if in STATE_STOPPING state, directly into STATE_RUNNING state, if in STATE_SHUTDOWN state, first into STATE_BOOTING state. Therefore, after the switchUser() method is finished, the user may be in STATE_BOOTING state. When will the user switch to STATE_RUNNING state again? A little later.

Switching users also includes setting the variable mCurrentUserId that records the current user id, calling the setCurrentUser() method of WMS to change the current user, locking the current screen, and so on.

In addition to these tasks, the most important work of the startUser() method is broadcasting and user-related Intent. Because user switching also involves many modules, such as wallpaper management, input method, account management module, they need to know that the current user has changed, and then make corresponding adjustments. Here we should pay attention to the objects of broadcasting, some for new users, some for old users, some for all users.

(1) If the user is not in STATE_RUNNING state before handover, broadcast ACTION_USER_STARTED to the user.

(2) If the user whose id is not zero has not been initialized, the broadcast ACTION_USER_INITIALIZE is sent to the user.

(3) Call sendUserSwitchBroadcastsLocked() method to send broadcast ACTION_USER_BACKGROUND to old users, broadcast ACTION_USER_FOREGROUND to new users, and broadcast ACTION_USER_SWUTCHED to all users.

(4) If the user is not in STATE_RUNNING state before handover, broadcast ACTION_USER_STARTING to all users.

In addition, two messages are sent in the startUser() method: REPORT_USER_SWITCH_MSG and USER_SWITCH_TIMEOUT_MSG. The REPORT_USER_SWITCH_MSG message processing method is dispatchUserSwitch, as follows:

1. case REPORT_USER_SWITCH_MSG: {  
2.     dispatchUserSwitch((UserStartedState) msg.obj, msg.arg1, msg.arg2);  
3.     break;  
4. }  

1. void dispatchUserSwitch(final UserStartedState uss, final int oldUserId,  
2.         final int newUserId) {  
3.     final int N = mUserSwitchObservers.beginBroadcast();  
4.     if (N > 0) {  
5.         final IRemoteCallback callback = new IRemoteCallback.Stub() {  
6.             int mCount = 0;  
7.             @Override  
8.             public void sendResult(Bundle data) throws RemoteException {  
9.                 synchronized (ActivityManagerService.this) {  
10.                     if (mCurUserSwitchCallback == this) {  
11.                         mCount++;//If you receive a call that returns the result, mCount++.  
12.                         if (mCount == N) {//If all the results are returned, send a message to continue processing  
13.                             sendContinueUserSwitchLocked(uss, oldUserId, newUserId);  
14.                         }  
15.                     }  
16.                 }  
17.             }  
18.         };  
19.         synchronized (this) {  
20.             uss.switching = true;  
21.             mCurUserSwitchCallback = callback;  
22.         }  
23.         for (int i=0; i<N; i++) {  
24.             try {//Calling onUserSwitching Method for Observed Objects  
25.                 mUserSwitchObservers.getBroadcastItem(i).onUserSwitching(  
26.                         newUserId, callback);  
27.             } catch (RemoteException e) {  
28.             }  
29.         }  
30.     } else {//If there is no observation object, call sendContinueUserSwitchLocked directly  
31.         synchronized (this) {  
32.             sendContinueUserSwitchLocked(uss, oldUserId, newUserId);  
33.         }  
34.     }  
35.     mUserSwitchObservers.finishBroadcast();  
36. }  

The main function of the dispatchUserSwitch() method is to call the onUserSwitching() interface of the IUserSwitchObserver object in the mUserSwitchObservers list. If a module in the system is interested in user switching, it can call the registerUserSwitchObserver() interface of AMS to register an observation object, which will be saved in the list of mUserSwitchObservers. In the processing of its callback interface onUserSwitching(), the module registering the observation object needs to notify AMS by calling the sendResult method of the passed parameter object callback. Let's look at the sendResult() method in the code above. Only when all registrants call the sendResult() method, mCount will eventually equal N. Then the sendContinueUserSwitchLocked method will be called to send the CONTINUE_USER_SWITCH_MSG message to continue switching users.

Let's take a look at the processing of USER_SWITCH_TIMEOUT_MSG message. The purpose of sending USER_SWITCH_TIMEOUT_MSG message is to prevent the processing time of ONTINUE_USER_SWITCH_MSG message from being too long. After all, only when all registrants have finished processing can they continue. Android 5.1 is different from previous versions. It will continue to send CONTINUE_USER_SWITCH_MSG messages and continue user switching. As follows:

1. case USER_SWITCH_TIMEOUT_MSG: {  
2.     timeoutUserSwitch((UserStartedState) msg.obj, msg.arg1, msg.arg2);  
3.     break;  
4. }  

1. void timeoutUserSwitch(UserStartedState uss, int oldUserId, int newUserId) {  
2.     synchronized (this) {  
3.         Slog.w(TAG, "User switch timeout: from " + oldUserId + " to " + newUserId);  
4.         sendContinueUserSwitchLocked(uss, oldUserId, newUserId);  
5.     }  
6. }  

1. void sendContinueUserSwitchLocked(UserStartedState uss, int oldUserId, int newUserId) {  
2.     mCurUserSwitchCallback = null;  
3.     mHandler.removeMessages(USER_SWITCH_TIMEOUT_MSG);  
4.     mHandler.sendMessage(mHandler.obtainMessage(CONTINUE_USER_SWITCH_MSG,  
5.             oldUserId, newUserId, uss));  
6. }  

1. case CONTINUE_USER_SWITCH_MSG: {  
2.     continueUserSwitch((UserStartedState) msg.obj, msg.arg1, msg.arg2);  
3.     break;  
4. }  

1. void continueUserSwitch(UserStartedState uss, int oldUserId, int newUserId) {  
2.     completeSwitchAndInitalize(uss, newUserId, false, true);  
3. }  

1. void completeSwitchAndInitalize(UserStartedState uss, int newUserId,  
2.         boolean clearInitializing, boolean clearSwitching) {  
3.     boolean unfrozen = false;  
4.     synchronized (this) {  
5.         if (clearInitializing) {  
6.             uss.initializing = false;  
7.             getUserManagerLocked().makeInitialized(uss.mHandle.getIdentifier());  
8.         }  
9.         if (clearSwitching) {  
10.             uss.switching = false;  
11.         }  
12.         if (!uss.switching && !uss.initializing) {  
13.             mWindowManager.stopFreezingScreen();  
14.             unfrozen = true;  
15.         }  
16.     }  
17.     if (unfrozen) {  
18.         final int N = mUserSwitchObservers.beginBroadcast();  
19.         for (int i=0; i<N; i++) {  
20.             try {  
21.                 mUserSwitchObservers.getBroadcastItem(i).onUserSwitchComplete(newUserId);  
22.             } catch (RemoteException e) {  
23.             }  
24.         }  
25.         mUserSwitchObservers.finishBroadcast();  
26.     }  
27.     stopGuestUserIfBackground();  
28. }  

The processing method of CONTINUE_USER_SWITCH_MSG message is continueUserSwitch(), which calls completeSwitchAndInitalize() method to continue processing. The result of processing is to call their onUserSwitchComplete() method on all observation objects in the mUserSwitchObservers list.

So far, the work on the startUser() method is complete. But there is another question: when will the user with STATE_BOOTING switch to STATE_RUNNING? In the activityIdleInternalLocked() method, there is a section of code as follows:

1.    for (int i = 0; i < startingUsers.size(); i++) {  
2.      mService.finishUserSwitch(startingUsers.get(i));  
3.   }  

The activityIdleInternalLocked() method is called when the Activity enters the Idle state, which means that the user has completed the switch. The finishUserBoot() method is called for each user in the startingUsers list, as follows:

1. void finishUserSwitch(UserStartedState uss) {  
2.     synchronized (this) {  
3.         finishUserBoot(uss);  
4.   
5.         startProfilesLocked();  
6.   
7.         int num = mUserLru.size();  
8.         int i = 0;  
9.         while (num > MAX_RUNNING_USERS && i < mUserLru.size()) {  
10.             Integer oldUserId = mUserLru.get(i);  
11.             UserStartedState oldUss = mStartedUsers.get(oldUserId);  
12.             if (oldUss == null) {//Normally, null does not occur.  
13.                 // Shouldn't happen, but be sane if it does.  
14.                 mUserLru.remove(i);  
15.                 num--;  
16.                 continue;  
17.             }  
18.             if (oldUss.mState == UserStartedState.STATE_STOPPING  
19.                     || oldUss.mState == UserStartedState.STATE_SHUTDOWN) {  
20.                 //This user is already stopping, does't count. If the user has stopped, continue  
21.                 num--;  
22.                 i++;  
23.                 continue;  
24.             }  
25.             if (oldUserId == UserHandle.USER_OWNER || oldUserId == mCurrentUserId) {  
26.                 // Owner and current can't be stopped, but count as running.  
27.                 i++;//If it is the primary user or the current user, continue  
28.                 continue;  
29.             }  
30.             //This is a user to be stopped.  
31.             stopUserLocked(oldUserId, null);  
32.             num--;  
33.             i++;  
34.         }  
35.     }  
36. }  

The finishUserSwitch() method completes two tasks. One is to call the method finishUserBoot() to switch the user whose state is still STATE_BOOTING to STATE_RUNNING, and send the broadcast ACTION_BOOT_COMPLETED to the user to indicate the end of the user's start-up. Another job is to stop redundant users. Beginning with item 0 of the mUserLru list, users in the state of STATE_RUNNING will stop as long as they are not the primary user or the current user, leaving only those in the state of STATE_RUNNING.

3. Stop User Running

The stop user interface in Activity Manager Service is stopUser(). After checking the permissions of the calling process, this method calls the internal method stopUserLocked() to continue to stop the user's work. The stopUserLocked() code is as follows:

1. private int stopUserLocked(final int userId, final IStopUserCallback callback) {  
2.     if (DEBUG_MU) Slog.i(TAG_MU, "stopUserLocked userId=" + userId);  
3.     if (mCurrentUserId == userId && mTargetUserId == UserHandle.USER_NULL) {  
4.         return ActivityManager.USER_OP_IS_CURRENT;  
5.     }//If the user requesting to stop is the current user, cannot stop, return  
6.   
7.     final UserStartedState uss = mStartedUsers.get(userId);  
8.     if (uss == null) {  
9.         // User is not started, nothing to do...  but we do need to  
10.         // callback if requested.  
11.         if (callback != null) {  
12.             mHandler.post(new Runnable() {  
13.                 @Override  
14.                 public void run() {  
15.                     try {  
16.                         callback.userStopped(userId);//Callback method userStopped  
17.                     } catch (RemoteException e) {  
18.                     }  
19.                 }  
20.             });  
21.         }  
22.         return ActivityManager.USER_OP_SUCCESS;//0  
23.     }  
24.   
25.     if (callback != null) {  
26.         uss.mStopCallbacks.add(callback);  
27.     }  
28.   
29.     if (uss.mState != UserStartedState.STATE_STOPPING  
30.             && uss.mState != UserStartedState.STATE_SHUTDOWN) {  
31.         uss.mState = UserStartedState.STATE_STOPPING;//Switch the user's status to stop  
32.         updateStartedUserArrayLocked();//Update the mStartedUserArray array to store the UserStartedState object  
33.   
34.         long ident = Binder.clearCallingIdentity();  
35.         try {  
36.             // We are going to broadcast ACTION_USER_STOPPING and then  
37.             // once that is done send a final ACTION_SHUTDOWN and then  
38.             // stop the user.  
39.             final Intent stoppingIntent = new Intent(Intent.ACTION_USER_STOPPING);  
40.             stoppingIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);  
41.             stoppingIntent.putExtra(Intent.EXTRA_USER_HANDLE, userId);  
42.             stoppingIntent.putExtra(Intent.EXTRA_SHUTDOWN_USERSPACE_ONLY, true);  
43.             final Intent shutdownIntent = new Intent(Intent.ACTION_SHUTDOWN);  
44.             // This is the result receiver for the final shutdown broadcast.  
45.             final IIntentReceiver shutdownReceiver = new IIntentReceiver.Stub() {  
46.                 @Override  
47.                 public void performReceive(Intent intent, int resultCode, String data,  
48.                         Bundle extras, boolean ordered, boolean sticky, int sendingUser) {  
49.                     finishUserStop(uss);//Receive ACTION_SHUTDOWN broadcast and continue execution  
50.                 }  
51.             };  
52.             // This is the result receiver for the initial stopping broadcast.  
53.             final IIntentReceiver stoppingReceiver = new IIntentReceiver.Stub() {  
54.                 @Override  
55.                 public void performReceive(Intent intent, int resultCode, String data,  
56.                         Bundle extras, boolean ordered, boolean sticky, int sendingUser) {  
57.                     // On to the next.  
58.                     synchronized (ActivityManagerService.this) {  
59.                         if (uss.mState != UserStartedState.STATE_STOPPING) {  
60.                             // Whoops, we are being started back up.  Abort, abort!  
61.                             return;  
62.                         }  
63.                         uss.mState = UserStartedState.STATE_SHUTDOWN;//Change user status after receiving ACTION_USER_STOPPING broadcast  
64.                     }  
65.                     mBatteryStatsService.noteEvent(  
66.                             BatteryStats.HistoryItem.EVENT_USER_RUNNING_FINISH,  
67.                             Integer.toString(userId), userId);  
68.                     mSystemServiceManager.stopUser(userId);  
69.                     broadcastIntentLocked(null, null, shutdownIntent,  
70.                             null, shutdownReceiver, 0, null, null, null, AppOpsManager.OP_NONE,  
71.                             true, false, MY_PID, Process.SYSTEM_UID, userId);//Re-transmit broadcast shutdown Intent (Intent.ACTION_SHUTDOWN)  
72.                 }  
73.             };  
74.             // Kick things off.  
75.             broadcastIntentLocked(null, null, stoppingIntent,  
76.                     null, stoppingReceiver, 0, null, null,  
77.                     INTERACT_ACROSS_USERS, AppOpsManager.OP_NONE,  
78.                     true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL);//Send Broadcast Stopping Intent (Intent. ACTION_USER_STOPPING)  
79.         } finally {  
80.             Binder.restoreCallingIdentity(ident);  
81.         }  
82.     }  
83.   
84.     return ActivityManager.USER_OP_SUCCESS;  
85. }  

The stopUserLocked() method first determines whether the user requesting the stop is the current user, yes, and returns. It can be seen that the current running user can not stop, it must be switched to other users before stopping the user.

Next, it determines whether the user is running or not, post s a message without running, and callbacks in the parameters are invoked in the message processing method to end the processing.

If the user is already running, first switch the user's state to STATE_STOPPING, then broadcast a message ACTION_USER_STOPPING that the user is stopping. At the same time, the method also receives the broadcast. After receiving, switch the user's state to STATE_SHUTDOWN, then send a broadcast of ACTION_SHUTDOWN. The method also accepts the broadcast, and then calls finishUserStop() Methods Continue to process as follows:

1. void finishUserStop(UserStartedState uss) {  
2.     final int userId = uss.mHandle.getIdentifier();  
3.     boolean stopped;  
4.     ArrayList<IStopUserCallback> callbacks;  
5.     synchronized (this) {  
6.         callbacks = new ArrayList<IStopUserCallback>(uss.mStopCallbacks);  
7.         if (mStartedUsers.get(userId) != uss) {  
8.             stopped = false;  
9.         } else if (uss.mState != UserStartedState.STATE_SHUTDOWN) {  
10.             stopped = false;  
11.         } else {  
12.             stopped = true;  
13.             //User can no longer run. Delete users from AMS user-managed data structures  
14.             mStartedUsers.remove(userId);  
15.             mUserLru.remove(Integer.valueOf(userId));  
16.             updateStartedUserArrayLocked();  
17.   
18.             // Clean up all state and processes associated with the user.  
19.             // Kill all the processes for the user.  
20.             forceStopUserLocked(userId, "finish user");//Send Broadcast Intent.ACTION_USER_STOPPED  
21.         }  
22.   
23.         // Explicitly remove the old information in mRecentTasks.  
24.         removeRecentTasksForUserLocked(userId);//Clear the user-related Recent Task list  
25.     }  
26.   
27.     for (int i=0; i<callbacks.size(); i++) {  
28.         try {//Callback method calling UserManagerService  
29.             if (stopped) callbacks.get(i).userStopped(userId);  
30.             else callbacks.get(i).userStopAborted(userId);  
31.         } catch (RemoteException e) {  
32.         }  
33.     }  
34.   
35.     if (stopped) {  
36.         mSystemServiceManager.cleanupUser(userId);//Delete users from mStackSupervisor  
37.         synchronized (this) {  
38.             mStackSupervisor.removeUserLocked(userId);  
39.         }  
40.     }  
41. }  

The main work of finishUserStop() method is to delete users from mStartedUsers and mUserLru, and then send a broadcast Intent.ACTION_USER_STOPPED to notify a user that it has stopped. Next, call the callback method of UserManagerService to notify UserManagerService to process, and finally call the removeUserLocked() method to delete relevant information from the mStackSupervisor list.