Android-0.UMS简介及VA中多用户的实现

最新推荐文章于 2023-04-24 22:10:07 发布

花熊

最新推荐文章于 2023-04-24 22:10:07 发布

阅读量1.4k

点赞数

分类专栏： va Android

本文链接：https://blog.csdn.net/hgy413/article/details/98071591

版权

Android 同时被 2 个专栏收录

65 篇文章 2 订阅

订阅专栏

7 篇文章 6 订阅

订阅专栏

1.多用户涉及的基本类和知识点简介

代码参考AOSP 中 API 23 (android 6.0.1)

Android从4.2开始支持多用户模式，不同的用户运行在独立的用户空间，不同用户安装的应用和应用数据都是不一样的，但是系统中与硬件相关的设置则是共用的，比如网络设置等。

通常第一个在系统中注册的用户将成为系统管理员，可以管理手机上的其他用户。但由于专利的原因，目前手机上并没有开启多用户模式，这种模式只能用在平板上面。

手机上经常见到的一个功能就是访客模式，它是多用户模式的一种应用。访客模式下用户的所有数据（通讯录，短信，应用等）会被隐藏，访客只能查看和使用手机的基本功能，此外你还可以设置访客是否有接听电话、发送短信等权限。

1.1 基础慨念

1.1.1 userid

代表不同的用户，即手机里的主机、访客等多用户，类似于windows

1.1.2 UID

==>Linux uid
Linux是多用户系统，每个用户都拥有一个uid，这个uid由系统和用户名做映射绑定。同时，为了便于用户管理（譬如管理文档权限），Linux引入了群组的概念，可以将多个用户归于一个群组。每一个群组拥有一个群组id（gid）。

==>Android uid
Android的应用的uid的范围是从10000到19999(FIRST_APPLICATION_UID到LAST_APPLICATION_UID)。
使用adb shell的ps命令查看到的pid，例如 u0_a94，a表示FIRST_APPLICATION_UID, 后面的数字就是该应用的UID值减去FIRST_APPLICATION_UID所得的值，也就是appid, 具体字符串构造规则可参考后面介绍的formatUid函数。

应用安装后，系统重启和应用重启都不会改变uid。
uid记录在data/system/packages.xml中,如查询VA的uid

generic_x86:/ # dumpsys package io.busniess.va |grep uid
    uid=10085 gids=null type=0 prot=signature

但要切记，userid用户不同，包名相同的uid也会不同,转换关系：

uid = userId * 100000  + appId

也就是真正不变的是appId

1.1.3 appId

跟userid用户无关的应用程序id, 取值范围 0<= appId <100000

即使是不同用户，包名相同的appid都一样。比如前面列举的 u0_a94中的94

由UserHandle的PER_USER_RANGE可知每个userid用户最大可以有100000个appid

1.1.4 userid区间分布

userid用户区间分布如下：

用户	区间
system	[1000, 9999]
application	[10000, 19999]
SharedAppGid	[50000, 59999]
isolated	[99000, 99999]

isolated是隔离空间，也就是沙箱。

1.2 UserHandle类简介

常见函数如下:(结合前面提到的慨念，较好理解)

方法	用途
public static final boolean `isSameUser`(int uid1, int uid2)	比较两个`uid`的`userId`是否相同
public static final boolean `isSameApp`(int uid1, int uid2)	比较两个`uid`的`appId`是否相同
public static boolean `isApp`(int uid)	`appId`是否属于区间[10000,19999]
public static final int `getUserId`(int uid)	得到 `userId`，其实就是`uid`/10000
public static final int `getCallingUserId`()	得到调用者的 `userId`
public static final UserHandle `getCallingUserHandle`()	得到调用者的`UserHandle`类对象
public static final int `getUid`(int userId, int appId)	得到`Uid` ,其实就是uid = userId * 100000 + appId
public static final int `getAppId`(int uid)	得到`appId`
public int `getIdentifier`()	得到当前`UserHandle`类对象所在的 `userId`
public static void `formatUid`(StringBuilder sb, int uid)	将`uid`组成字符串,如`u0_a94`

常见成员变量：(UserHandle的成员变量mHandle便是它所在的userId)

userId	赋值	含义
USER_OWNER	0	拥有者
USER_ALL	-1	所有用户
USER_CURRENT	-2	当前活动用户
USER_CURRENT_OR_SELF	-3	当前用户或者调用者所在用户
USER_NULL	-1000	未定义用户

类成员变量：

UserHandle OWNER = new UserHandle(USER_OWNER); // 0
UserHandle ALL = new UserHandle(USER_ALL); // -1
UserHandle CURRENT = new UserHandle(USER_CURRENT); // -2
UserHandle CURRENT_OR_SELF = new UserHandle(USER_CURRENT_OR_SELF); // -3

1.2.1 UserHandle得到当前进程的userid

要得到当前进程的userId（mHandle即userId），客户端可以使用Process.myUserHandle().getIdentifier(), 代码实现如下：

    public static final UserHandle myUserHandle() {
        return new UserHandle(UserHandle.getUserId(myUid()));
    }
    --->UserHandle构造如下:
    public UserHandle(Parcel in) {
        mHandle = in.readInt();
    }
    --->UserHandle的getIdentifier如下：
    public int getIdentifier() {
        return mHandle;
    }

要得到调用者的进程userId，，服务端直接使用UserHandle.getCallingUserId()。

1.2.2 UserHandle组成uid字符串规则

前面列举的 u0_a94，它的字符串组成可以参考formatUid方法：

    public static void formatUid(StringBuilder sb, int uid) {
        if (uid < Process.FIRST_APPLICATION_UID) {
            sb.append(uid);
        } else {
            sb.append('u');
            sb.append(getUserId(uid));
            final int appId = getAppId(uid);
            if (appId >= Process.FIRST_ISOLATED_UID && appId <= Process.LAST_ISOLATED_UID) {
                sb.append('i');
                sb.append(appId - Process.FIRST_ISOLATED_UID);
            } else if (appId >= Process.FIRST_APPLICATION_UID) {
                sb.append('a');
                sb.append(appId - Process.FIRST_APPLICATION_UID);
            } else {
                sb.append('s');
                sb.append(appId);
            }
        }
    }

所以 u0_a94可以这样拆分，0是userId，a是Process.FIRST_APPLICATION_UID（10000）为基数，前面提到，由UserHandle的PER_USER_RANGE可知每个userid用户最大可以有100000（十万）个appid，所以 u0_a94= 0*100000 + （10000 + 94）= 10094

1.3 UserInfo类简介

UserInfo代表的是一个用户的信息, 涉及到的flags及其含义，如下：

     * *************************** NOTE ***************************
     * 这些标志值无法更改，因为它们已被写入直接存储
     */

    /**
     * 主用户 仅仅只有一个user具有该标识. Meaning of this
     * flag TBD.
     */
    public static final int FLAG_PRIMARY = 0x00000001;

    /**
     * 具有管理特权的用户，例如它能创建或删除其他用户
     */
    public static final int FLAG_ADMIN   = 0x00000002;

    /**
     * 访客用户，可能是临时的
     */
    public static final int FLAG_GUEST   = 0x00000004;

    /**
     * 限制性用户，较普通用户具有更多限制，例如禁止安装app或者管理wifi等
     */
    public static final int FLAG_RESTRICTED = 0x00000008;

    /**
     * 表明用户已初始化
     */
    public static final int FLAG_INITIALIZED = 0x00000010;

    /**
     * 标志该UserInfo是否是另外一个用户的一份profile，Android中允许一个用户拥有另一份profile
     * 比如现在好多定制系统开发的应用分身，就是基于这个开发的，比如可以在同一个手机上启动两个微信帐号
	https://developer.android.com/reference/android/app/admin/DevicePolicyManager.html#ACTION_PROVISION_MANAGED_PROFILE
     */
    public static final int FLAG_MANAGED_PROFILE = 0x00000020;

    /**
     * 表明该用户处于禁用状态
     */
    public static final int FLAG_DISABLED = 0x00000040;

	 // 无效值定义
    public static final int NO_PROFILE_GROUP_ID = -1;

	public int id;               //用户id
    public int serialNumber;     //用户序列号，唯一的，不会重复
    public String name;          //用户名称
    public String iconPath;      //用户头像的路径
    public int flags;            //用户的标记信息
    public long creationTime;    //用户创建时间
    public long lastLoggedInTime;//用户上次登陆时间
    public int profileGroupId;   //用户的profile group id

	// 用来标记没有创建完成的用户
    public boolean partial;
    public boolean guestToRemove;

需要注意的是，用户的Id用来表示用户，如果用户被删除了它的Id会分配给下一个新建的用户，用来保持Id的连续性；
但是serialNumber是一个不会重复的数字，是不会被重复利用的，用来唯一标识一个用户。

1.4 UserState类简介

public final class UserState {
    // 用户正在启动状态
    public final static int STATE_BOOTING = 0;
    // 用户正在运行状态
    public final static int STATE_RUNNING = 1;
    // 用户正在关闭中
    public final static int STATE_STOPPING = 2;
    // 用户已经被关闭, sending Intent.ACTION_SHUTDOWN.
    public final static int STATE_SHUTDOWN = 3;

生命周期线：STATE_BOOTING -> STATE_RUNNING -> STATE_STOPPING -> STATE_SHUTDOWN

2. UMS 的启动和初始化过程

2.1 交互简介

从源码来分析：
AMS通过 UserManagerService getUserManagerLocked() 得到UMS
PMS通过sUserManager得到UMS
UMS通过mPm得到PMS

2.2. UMS 初始化流程

===>创建UMS的过程和AMS，PMS一样位于startBootstrapServices中，它由PMS构造函数初始化。
启动代码位于frameworks/base/services/java/com/android/server/SystemServer.java中，代码如下:

  private void startBootstrapServices() {
  		 ...
  	   mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
         ... 
  }
  -->PackageManagerService构造函数如下:
   public PackageManagerService(Context context, Installer installer,
            boolean factoryTest, boolean onlyCore) {
            ....
             sUserManager = new UserManagerService(context, this,
                    mInstallLock, mPackages);
  }

===>接着看UMS的构造过程，可以看到PMS保存UMS（sUserManager 成员），而UMS也保存PMS（mPm 成员), 这个方法部分功能为：

保存了PMS对象到mPm 成员
创建第一个用户的目录/data/system/users/0
创建/data/system/users/userlist.xml，这个文件保存了系统中所有用户的id信息
读取userlist.xml文件，将用户的信息解析成UserInfo，并保存在mUsers列表中

代码如下:

UserManagerService(Context context, PackageManagerService pm,
            Object installLock, Object packagesLock) {
        this(context, pm, installLock, packagesLock,
                Environment.getDataDirectory(),
                new File(Environment.getDataDirectory(), "user"));
    }
 --->跳转到如下私有构造函数：
private UserManagerService(Context context, PackageManagerService pm,
            Object installLock, Object packagesLock,
            File dataDir,// dataDir = /data
             File baseUserPath) {// baseUserPath = /data/user
            mContext = context;
        	mPm = pm;
        	 mInstallLock = installLock;
    mPackagesLock = packagesLock;
    mHandler = new MainHandler();
    synchronized (mInstallLock) {
        synchronized (mPackagesLock) {
            // mUsersDir是/data/system/users目录
            mUsersDir = new File(dataDir, USER_INFO_DIR);
            mUsersDir.mkdirs();
            // 创建第一个用户的目录/data/system/users/0
            File userZeroDir = new File(mUsersDir, "0");
            userZeroDir.mkdirs();
            // 设置目录的权限
            FileUtils.setPermissions(mUsersDir.toString(),
                    FileUtils.S_IRWXU|FileUtils.S_IRWXG
                    |FileUtils.S_IROTH|FileUtils.S_IXOTH,
                    -1, -1);
            // 创建代表/data/system/users/userlist.xml文件的对象
            mUserListFile = new File(mUsersDir, USER_LIST_FILENAME);
            // 添加一些对访客用户的默认限制，DISALLOW_OUTGOING_CALLS和DISALLOW_SMS，不允许打电话和发信息
            initDefaultGuestRestrictions();
            // 读取userlist.xml文件，将用户的信息保存在mUsers列表中
            // 如果该文件不存在则创建该文件
            readUserListLocked();
            sInstance = this;
        }
    }
    --->mUsers的定义如下：
    private final SparseArray<UserInfo> mUsers = new SparseArray<UserInfo>();

userlist.xml示例：

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

nextSerialNumber指的是创建下一个用户时它的serialNumber，version指的是当前多用户的版本, userlist.xml 文件是可以升级的。
guestRestrictions标签指的是为访客用户设置的权限，可以通过UserManager.setDefaultGuestRestrictions()来设置。

前面userlist.xml示例里面有两个用户的信息，分别为 id 为 0 和 10 的用户，分别对应/data/system/users目录下0.xml和10.xml（和userlist.xml同目录）以0.xml 为示例：

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<user id="0" serialNumber="0" flags="19" created="0" lastLoggedIn="1493886997408">
    <name>机主</name>
    <restrictions />
</user>

标签的属性值对应了前面UserInfo里面的成员变量, readUserListLocked会根据文件的内容来创建和初始化一个UserInfo来保存到mUsers列表中去。

==>接着再看一下systemReady()函数，这里面也有一些初始化的工作，它的调用是在PackageManagerService.systemReady()中进行的。

--->PMS中的systemReady如下:
 public void systemReady() {
 	...
 	  sUserManager.systemReady();
 }
--->UMS中的systemReady如下:
void systemReady() {
    synchronized (mInstallLock) {
        synchronized (mPackagesLock) {
            // 寻找那些在userlist.xml文件中partially或者partial为true的用户
            ArrayList<UserInfo> partials = new ArrayList<UserInfo>();
            for (int i = 0; i < mUsers.size(); i++) {
                UserInfo ui = mUsers.valueAt(i);
                if ((ui.partial || ui.guestToRemove) && i != 0) {
                    partials.add(ui);
                }
            }
            // 将这些未创建完成的用户从系统中移除掉
            for (int i = 0; i < partials.size(); i++) {
                UserInfo ui = partials.get(i);
                removeUserStateLocked(ui.id);
            }
        }
    }
    // 更新一下OWNER用户的登陆时间
    onUserForeground(UserHandle.USER_OWNER);
    // 调用AppOpsManager（权限管理器）设置每个用户的权限
    mAppOpsService = IAppOpsService.Stub.asInterface(
            ServiceManager.getService(Context.APP_OPS_SERVICE));
    for (int i = 0; i < mUserIds.length; ++i) {
        try {
            mAppOpsService.setUserRestrictions(mUserRestrictions.get(mUserIds[i]), mUserIds[i]);
        } catch (RemoteException e) {
            Log.w(LOG_TAG, "Unable to notify AppOpsService of UserRestrictions");
        }
    }
}

简单的说UMS 的初始化工作主要就是分析userlist.xml文件、创建用户列表mUsers以及设置用户权限。

2.3 创建用户

2.3.1 UMS

UMS 中创建用户是在createUser()方法中实现的：

    @Override
    public UserInfo createUser(String name, int flags) {
        checkManageOrCreateUsersPermission(flags);
        return createUserInternal(name, flags, UserHandle.USER_NULL);
    }
    --->
    // UID 是 system UID 或 root's UID 或APP有permission.MANAGE_USERS权限
    private static final void checkManageOrCreateUsersPermission(String message) {
        if (!hasManageOrCreateUsersPermission()) {
            throw new SecurityException(
                    "You either need MANAGE_USERS or CREATE_USERS permission to: " + message);
        }
    }

首先检查调用者的权限，UID 是 system UID 或 root’s UID 或APP有permission.MANAGE_USERS权限才有权限，否则抛出异常。然后就调用createUserInternal来执行真正的创建工作。

===>createUserInternal 这个方法部分功能为：

检查调用进程所属用户是否被限制添加用户、当前设备是否是低内存设备、当前用户数是否已达上限，如是则停止创建新用户
为新用户设置用户信息，比如Id，序列号创建时间等
将用户信息写入userlist.xml，注意，此时的userInfo.partial = true，表示正在创建
创建用户目录/data/user/或者/mnt/expand/user/
调用PMS的createNewUserLILPw方法，这个函数会在新建用户的目录下面为所有应用创建数据目录
创建用户完成，将userInfo.partial设置为false，创建用户的信息文件，比如0.xml
发送用户创建完成的广播Intent.ACTION_USER_ADDE

代码如下:

private UserInfo createUserInternal(String name, int flags, int parentId) {
    // 检查一下该用户是否被限制创建用户
    if (getUserRestrictions(UserHandle.getCallingUserId()).getBoolean(
            UserManager.DISALLOW_ADD_USER, false)) {
        return null;
    }
    // 检查是否是低内存设备
    if (ActivityManager.isLowRamDeviceStatic()) {
        return null;
    }
    final boolean isGuest = (flags & UserInfo.FLAG_GUEST) != 0;
    final boolean isManagedProfile = (flags & UserInfo.FLAG_MANAGED_PROFILE) != 0;
    final long ident = Binder.clearCallingIdentity();
    UserInfo userInfo = null;
    final int userId;
    try {
        synchronized (mInstallLock) {
            synchronized (mPackagesLock) {
                UserInfo parent = null;
                if (parentId != UserHandle.USER_NULL) {
                    parent = getUserInfoLocked(parentId);
                    if (parent == null) return null;
                }
                if (isManagedProfile && !canAddMoreManagedProfiles()) {
                    return null;
                }
                // 如果添加的不是Guest用户，也不是用户的profile，而且已经到达用户的上限，则不允许再添加
                if (!isGuest && !isManagedProfile && isUserLimitReachedLocked()) {
                    return null;
                }
                // 如果添加的是Guest用户，但是系统中已经存在一个，则不允许再添加
                if (isGuest && findCurrentGuestUserLocked() != null) {
                    return null;
                }
                // 得到新用户的Id
                userId = getNextAvailableIdLocked();
                // 为该新用户创建UserInfo
                userInfo = new UserInfo(userId, name, null, flags);
                // 设置序列号
                userInfo.serialNumber = mNextSerialNumber++;
                // 设置创建时间
                long now = System.currentTimeMillis();
                userInfo.creationTime = (now > EPOCH_PLUS_30_YEARS) ? now : 0;
                // 设置partial，表示正在创建
                userInfo.partial = true;
                Environment.getUserSystemDirectory(userInfo.id).mkdirs();
                // 放入mUsers列表
                mUsers.put(userId, userInfo);
                // 把用户信息写入userlist.xml
                writeUserListLocked();
                if (parent != null) {
                    if (parent.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID) {
                        parent.profileGroupId = parent.id;
                        scheduleWriteUserLocked(parent);
                    }
                    userInfo.profileGroupId = parent.profileGroupId;
                }
                // 创建用户目录
                final StorageManager storage = mContext.getSystemService(StorageManager.class);
                for (VolumeInfo vol : storage.getWritablePrivateVolumes()) {
                    final String volumeUuid = vol.getFsUuid();
                    try {
                        final File userDir = Environment.getDataUserDirectory(volumeUuid,
                                userId);
                        // 创建userDir，如果volumeUuid为空，创建/data/user/<userId>/，不为空，创建/mnt/expand/<volumeUuid>/user/<userId>/
                        prepareUserDirectory(userDir);
                        enforceSerialNumber(userDir, userInfo.serialNumber);
                    } catch (IOException e) {
                        Log.wtf(LOG_TAG, "Failed to create user directory on " + volumeUuid, e);
                    }
                }
                // 调用PackageManagerService的createNewUserLILPw方法，此方法很重要，后面会单独分析
                // 这个函数会在新建用户的userDir目录下面为所有应用创建数据
                // 此方法将新用户可以使用的App在/data/user/<用户Id>文件夹下创建数据目录，目录名称为包名
                mPm.createNewUserLILPw(userId);
                // 创建成功，将partial改为false
                userInfo.partial = false;
                // 会调用writeUserLocked()创建xxx.xml，类似0.xml，xxx是用户Id
                scheduleWriteUserLocked(userInfo);
                // 更新mUserIds数组
                updateUserIdsLocked();
                Bundle restrictions = new Bundle();
                // 添加为该用户设置的限制条件
                mUserRestrictions.append(userId, restrictions);
            }
        }
        // 发送用户创建完成的广播，广播附带用户的id
        if (userInfo != null) {
            Intent addedIntent = new Intent(Intent.ACTION_USER_ADDED);
            addedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userInfo.id);
            mContext.sendBroadcastAsUser(addedIntent, UserHandle.ALL,
                    android.Manifest.permission.MANAGE_USERS);
        }
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
    return userInfo;
}

2.3.2 PMS

===>前面函数调用了 mPm.createNewUserLILPw(userId)， PMS中createNewUserLILPw用于创建用户数据，由UMS调用，代码如下：

    /** Called by UserManagerService */
    void createNewUserLILPw(int userHandle) {
        if (mInstaller != null) {
        //通过mInstaller调用守护进程installd执行mkuserconfig，创建用户配置文件。
        mInstaller.createUserConfig(userHandle);
        // 调用mSettings.createNewUserLILP为新用户中的应用创建应用数据目录
        mSettings.createNewUserLILPw(this, mInstaller, userHandle);
        // 设置默认的Browser
        applyFactoryDefaultBrowserLPw(userHandle);
        primeDomainVerificationsLPw(userHandle);
    }
    }
    ===> mSettings.createNewUserLILPw实现如下：
    void createNewUserLILPw(PackageManagerService service, Installer installer, int userHandle) {
    // 为每一个应用创建数据目录
    for (PackageSetting ps : mPackages.values()) {
        if (ps.pkg == null || ps.pkg.applicationInfo == null) {
            continue;
        }
        // Only system apps are initially installed.
        //为系统应用修改PackageUserState的installed标志
        ps.setInstalled((ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) != 0, userHandle);
        // 通过mInstaller调用守护进程installd执行mkuserdata，为用户创建用户目录。
        installer.createUserData(ps.volumeUuid, ps.name,
                UserHandle.getUid(userHandle, ps.appId), userHandle,
                ps.pkg.applicationInfo.seinfo);
    }
    // TODO
    applyDefaultPreferredAppsLPw(service, userHandle);
    writePackageRestrictionsLPr(userHandle);
    writePackageListLPr(userHandle);
}

这个函数会在新建用户的目录下面为所有应用创建数据目录

2.4 切换用户

用户切换流程：ActivityManager.switchUser--> ActivityManagerNative.getDefault().switchUser-->ActivityManagerService.switchUser,代码如下：

--->ActivityManager.java:
    public boolean switchUser(int userid) {
        try {
            return ActivityManagerNative.getDefault().switchUser(userid);
        } catch (RemoteException e) {
            return false;
        }
    }
 --->ActivityManagerProxy.switchUser
 public boolean switchUser(int userid) throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeInt(userid);
        mRemote.transact(SWITCH_USER_TRANSACTION, data, reply, 0);
        reply.readException();
        boolean result = reply.readInt() != 0;
        reply.recycle();
        data.recycle();
        return result;
    }
-->AMS中的switchUser：
  public boolean switchUser(final int userId) {
        enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, userId);
        String userName;
        synchronized (this) {
            UserInfo userInfo = getUserManagerLocked().getUserInfo(userId);
            if (userInfo == null) {
                Slog.w(TAG, "No user info for user #" + userId);
                return false;
            }
            // 该user只是一个user的profile，无法切换
            if (userInfo.isManagedProfile()) {
                Slog.w(TAG, "Cannot switch to User #" + userId + ": not a full user");
                return false;
            }
            userName = userInfo.name;
             // 把该用户Id记录到mTargetUserId变量
            mTargetUserId = userId;
        }
        // 发送切换用户的消息
        mUiHandler.removeMessages(START_USER_SWITCH_MSG);
        mUiHandler.sendMessage(mUiHandler.obtainMessage(START_USER_SWITCH_MSG, userId, 0, userName));
        return true;
    }

===>Handler收到START_USER_SWITCH_MSG消息后，会调用showUserSwitchDialog()来弹出一个确认的对话框, 代码如下：

  case START_USER_SWITCH_MSG: {
        showUserSwitchDialog(msg.arg1, (String) msg.obj);
        break;
                
   ---> showUserSwitchDialog代码如下:
   private void showUserSwitchDialog(int userId, String userName) {
    // The dialog will show and then initiate the user switch by calling startUserInForeground
    Dialog d = new UserSwitchingDialog(this, mContext, userId, userName,
            true /* above system */);
    d.show();
}

===>点击确定后最终会调用到startUser()来执行切换用户的动作

--->UserSwitchingDialog.java
    public void onWindowShown() {
        // Slog.v(TAG, "onWindowShown called");
        startUser();
    }
--->
private boolean startUser(final int userId, final boolean foreground) {
    //切换用话需要INTERACT_ACROSS_USERS_FULL权限
    if (checkCallingPermission(INTERACT_ACROSS_USERS_FULL)
            != PackageManager.PERMISSION_GRANTED) {
        throw new SecurityException(msg);
    }
    final long ident = Binder.clearCallingIdentity();
    try {
        synchronized (this) {
            // 如果当前用户已经是需要切换的用户，退出当前流程
            final int oldUserId = mCurrentUserId;
            if (oldUserId == userId) {
                return true;
            }
            mStackSupervisor.setLockTaskModeLocked(null, ActivityManager.LOCK_TASK_MODE_NONE,
                    "startUser", false);
            // 如果没有需要启动的用户的信息，则直接退出
            final UserInfo userInfo = getUserManagerLocked().getUserInfo(userId);
            if (userInfo == null) {
                return false;
            }
            // 如果是前台启动且是一份profile的话，则直接退出
            if (foreground && userInfo.isManagedProfile()) {
                return false;
            }
            // 如果是前台启动，则需要将屏幕冻结
            if (foreground) {
                mWindowManager.startFreezingScreen(R.anim.screen_user_exit,
                        R.anim.screen_user_enter);
            }
            boolean needStart = false;
            // 如果当前已经启动过的用户列表中没有该用户，则需要先启动该用户
            if (mStartedUsers.get(userId) == null) {
                mStartedUsers.put(userId, new UserState(new UserHandle(userId), false));
                updateStartedUserArrayLocked();
                needStart = true;
            }
            // 调整该用户在mUserLru列表中的位置，当前用户放到最后位置
            final Integer userIdInt = Integer.valueOf(userId);
            mUserLru.remove(userIdInt);
            mUserLru.add(userIdInt);
            if (foreground) {
                // 如果是前台切换，直接切换到需要启动的用户
                mCurrentUserId = userId;
                // 重置mTargetUserId，因为userId已经赋值给mCurrentUserId了
                mTargetUserId = UserHandle.USER_NULL; // reset, mCurrentUserId has caught up
                // 更新与该用户相关的profile列表
                updateCurrentProfileIdsLocked();
                // 在WindowManagerService中设置要启动的用户为当前用户
                mWindowManager.setCurrentUser(userId, mCurrentProfileIds);
                // 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.
                // 执行锁屏操作
                mWindowManager.lockNow(null);
                }
            } else {
                // 如果是后台启动
                final Integer currentUserIdInt = Integer.valueOf(mCurrentUserId);
                // 更新与该用户相关的profile列表
                updateCurrentProfileIdsLocked();
                mWindowManager.setCurrentProfileIds(mCurrentProfileIds);
                // 重新调整mUserLru
                mUserLru.remove(currentUserIdInt);
                mUserLru.add(currentUserIdInt);
            }
            final UserState uss = mStartedUsers.get(userId);
            if (uss.mState == UserState.STATE_STOPPING) {
                // 如果该用户是正在停止，这个时候还没有发送ACTION_SHUTDOWN广播，则切换为正在运行
                uss.mState = UserState.STATE_RUNNING;
                // 更新mStartedUserArray列表
                updateStartedUserArrayLocked();
                needStart = true;
            } else if (uss.mState == UserState.STATE_SHUTDOWN) {
                // 如果该用户是正在停止，这个时候已经发送ACTION_SHUTDOWN广播，则切换为正在启动状态
                uss.mState = UserState.STATE_BOOTING;
                updateStartedUserArrayLocked();
                needStart = true;
            }
            if (uss.mState == UserState.STATE_BOOTING) {
                // 如果用户的状态是正在启动，则发送一个SYSTEM_USER_START_MSG消息，该消息的处理下面会介绍
                mHandler.sendMessage(mHandler.obtainMessage(SYSTEM_USER_START_MSG, userId, 0));
            }
            if (foreground) {
                // 发送SYSTEM_USER_CURRENT_MSG消息
                mHandler.sendMessage(mHandler.obtainMessage(SYSTEM_USER_CURRENT_MSG, userId,
                        oldUserId));
                // 分别发送REPORT_USER_SWITCH_MSG和USER_SWITCH_TIMEOUT_MSG，防止切换时间过长，后面会介绍
                mHandler.removeMessages(REPORT_USER_SWITCH_MSG);
                mHandler.removeMessages(USER_SWITCH_TIMEOUT_MSG);
                mHandler.sendMessage(mHandler.obtainMessage(REPORT_USER_SWITCH_MSG,
                        oldUserId, userId, uss));
                mHandler.sendMessageDelayed(mHandler.obtainMessage(USER_SWITCH_TIMEOUT_MSG,
                        oldUserId, userId, uss), USER_SWITCH_TIMEOUT);
            }
            if (needStart) {
                // 发送一个 USER_STARTED 广播
                Intent intent = new Intent(Intent.ACTION_USER_STARTED);
                intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
                        | Intent.FLAG_RECEIVER_FOREGROUND);
                intent.putExtra(Intent.EXTRA_USER_HANDLE, userId);
                broadcastIntentLocked(null, null, intent,
                        null, null, 0, null, null, null, AppOpsManager.OP_NONE,
                        null, false, false, MY_PID, Process.SYSTEM_UID, userId);
            }
            if ((userInfo.flags&UserInfo.FLAG_INITIALIZED) == 0) {
                // 当该用户还没有初始化，如果是普通用户则会发送ACTION_USER_INITIALIZE广播，如果是机主用户，则直接标记为已初始化
                if (userId != UserHandle.USER_OWNER) {
                    Intent intent = new Intent(Intent.ACTION_USER_INITIALIZE);
                    intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
                    broadcastIntentLocked(null, null, intent, null,
                            new IIntentReceiver.Stub() {
                                public void performReceive(Intent intent, int resultCode,
                                        String data, Bundle extras, boolean ordered,
                                        boolean sticky, int sendingUser) {
                                    onUserInitialized(uss, foreground, oldUserId, userId);
                                }
                            }, 0, null, null, null, AppOpsManager.OP_NONE,
                            null, true, false, MY_PID, Process.SYSTEM_UID, userId);
                    // 标记为正在初始化，该变量会在completeSwitchAndInitialize()重置
                    uss.initializing = true;
                } else {
                    getUserManagerLocked().makeInitialized(userInfo.id);
                }
            }
            if (foreground) {
                // 如果用户已经初始化过了，则设置为前台用户，后面会介绍这一部分
                if (!uss.initializing) {
                    moveUserToForeground(uss, oldUserId, userId);
                }
            } else {
                // 如果是后台启动用户，先加入到mStartingBackgroundUsers列表中去
                mStackSupervisor.startBackgroundUserLocked(userId, uss);
            }
            if (needStart) {
                Intent intent = new Intent(Intent.ACTION_USER_STARTING);
                intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
                intent.putExtra(Intent.EXTRA_USER_HANDLE, userId);
                broadcastIntentLocked(null, null, intent,
                        null, new IIntentReceiver.Stub() {
                            @Override
                            public void performReceive(Intent intent, int resultCode,
                                    String data, Bundle extras, boolean ordered, boolean sticky,
                                    int sendingUser) throws RemoteException {
                            }
                        }, 0, null, null,
                        new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE,
                        null, true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL);
            }
        }
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
    return true;
}

===>下面来分析一下moveUserToForeground()函数

void moveUserToForeground(UserState uss, int oldUserId, int newUserId) {
    //从mStackSupervisor获取newUserId用户在切换之前的stack状态，以便将原来在前台的应用推到前台
    boolean homeInFront = mStackSupervisor.switchUserLocked(newUserId, uss);
    if (homeInFront) {
        // 如果原来是从桌面切换的用户，则启动桌面
        startHomeActivityLocked(newUserId, "moveUserToFroreground");
    } else {
        // 如果是其他应用，则将此应用推到前台
        mStackSupervisor.resumeTopActivitiesLocked();
    }
    EventLogTags.writeAmSwitchUser(newUserId);
    getUserManagerLocked().onUserForeground(newUserId);
    // 发送ACTION_USER_BACKGROUND广播，通知和oldUserId相关的用户(包括profile)进入后台的消息
    // 发送ACTION_USER_FOREGROUND广播，通知和newUserId相关的用户(包括profile)进入前台的消息
    // 发送ACTION_USER_SWITCHED广播，通知用户切换
    sendUserSwitchBroadcastsLocked(oldUserId, newUserId);
}

2.4 删除用户

2.4.1 UMS

UserManagerService中删除用户是在removeUser()方法中实现的：

public boolean removeUser(int userHandle) {
    // 检查该进程是否具有删除用户的权限
    checkManageUsersPermission("Only the system can remove users");
    // 检查一下该用户是否被限制删除用户
    if (getUserRestrictions(UserHandle.getCallingUserId()).getBoolean(
            UserManager.DISALLOW_REMOVE_USER, false)) {
        return false;
    }
    long ident = Binder.clearCallingIdentity();
    try {
        final UserInfo user;
        synchronized (mPackagesLock) {
            user = mUsers.get(userHandle);
            // 检查被删除的用户是不是管理员用户userHandle=0，检查用户列表中是否有该用户，以及该用户是否是正在被删除的用户
            if (userHandle == 0 || user == null || mRemovingUserIds.get(userHandle)) {
                return false;
            }
            // 将该用户放入mRemovingUserIds列表中，防止重复删除
            // mRemovingUserIds中的数据会一直保存直到系统重启，防止Id被重复使用
            mRemovingUserIds.put(userHandle, true);
            try {
                mAppOpsService.removeUser(userHandle);
            } catch (RemoteException e) {
                Log.w(LOG_TAG, "Unable to notify AppOpsService of removing user", e);
            }
            // 将partial设置为true，这样如果后面的过程意外终止导致此次删除失败，系统重启后还是会继续删除工作的
            user.partial = true;
            // 设置FLAG_DISABLED，禁止该用户
            user.flags |= UserInfo.FLAG_DISABLED;
            // 将上面更新的用户文件信息写入到xml文件中去
            writeUserLocked(user);
        }
        // 如果该user是一个user的一份profile，则发出一个ACTION_MANAGED_PROFILE_REMOVED广播
        if (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID
                && user.isManagedProfile()) {
            sendProfileRemovedBroadcast(user.profileGroupId, user.id);
        }
        // 调用AMS停止当前的用户，这部分后面会详细介绍
        int res;
        try {
            res = ActivityManagerNative.getDefault().stopUser(userHandle,
                    // 设置回调函数，调用finishRemoveUser继续后面的删除工作
                    new IStopUserCallback.Stub() {
                        @Override
                        public void userStopped(int userId) {
                            finishRemoveUser(userId);
                        }
                        @Override
                        public void userStopAborted(int userId) {
                        }
                    });
        } catch (RemoteException e) {
            return false;
        }
        return res == ActivityManager.USER_OP_SUCCESS;
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}

ActivityManagerNative.getDefault().stopUser执行完后 UMS 会继续执行删除工作。

void finishRemoveUser(final int userHandle) {
    // Let other services shutdown any activity and clean up their state before completely
    // wiping the user's system directory and removing from the user list
    long ident = Binder.clearCallingIdentity();
    try {
        Intent addedIntent = new Intent(Intent.ACTION_USER_REMOVED);
        addedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userHandle);
        mContext.sendOrderedBroadcastAsUser(addedIntent, UserHandle.ALL,
                android.Manifest.permission.MANAGE_USERS,
                new BroadcastReceiver() {
                    @Override
                    public void onReceive(Context context, Intent intent) {
                        new Thread() {
                            public void run() {
                                synchronized (mInstallLock) {
                                    synchronized (mPackagesLock) {
                                        removeUserStateLocked(userHandle);
                                    }
                                }
                            }
                        }.start();
                    }
                },
                null, Activity.RESULT_OK, null, null);
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}

根据代码可以看到finishRemoveUser方法只是发送了一个有序广播ACTION_USER_REMOVED，同时注册了一个广播接收器，这个广播接收器是最后一个接收到该广播的接收器，这样做的目的是让关心该广播的其他接收器处理完之后， UMS 才会进行删除用户的收尾工作，即调用removeUserStateLocked来删除用户的相关文件。

private void removeUserStateLocked(final int userHandle) {
    // 调用mPm.cleanUpUserLILPw来删除用户目录/data/user/<用户id>/下面的应用数据，后面会详细介绍
    mPm.cleanUpUserLILPw(this, userHandle);
    // 从mUsers列表中移除该用户信息
    mUsers.remove(userHandle);
    AtomicFile userFile = new AtomicFile(new File(mUsersDir, userHandle + XML_SUFFIX));
    // 删除用户信息文件 <用户id>.xml
    userFile.delete();
    // 更新userlist.xml文件，将删除调用的用户从中移除
    writeUserListLocked();
    // 更新mUserIds列表
    updateUserIdsLocked();
    // 删除用户目录以及该用户的所有文件
    removeDirectoryRecursive(Environment.getUserSystemDirectory(userHandle));
}

2.4.2 AMS

UMS的removeUser()会调用AMS的stopUser()来处理停止用户的一些工作，在AMS内部也会调用stopUser()。该方法在进行了权限检查之后，主要的工作都是由stopUserLocked()来完成的。

void finishUserStop(UserState uss) {
    final int userId = uss.mHandle.getIdentifier();
    boolean stopped;
    ArrayList<IStopUserCallback> callbacks;
    synchronized (this) {
        callbacks = new ArrayList<IStopUserCallback>(uss.mStopCallbacks);
        if (mStartedUsers.get(userId) != uss) {
            stopped = false;
        } else if (uss.mState != UserState.STATE_SHUTDOWN) {
            stopped = false;
        } else {
            stopped = true;
            // User can no longer run.
            mStartedUsers.remove(userId);
            mUserLru.remove(Integer.valueOf(userId));
            updateStartedUserArrayLocked();
            // 杀掉和该用户相关的所有进程
            forceStopUserLocked(userId, "finish user");
        }
        // 清除用户相关的Recent Task列表
        mRecentTasks.removeTasksForUserLocked(userId);
    }
    //调用在stopUserLocked中添加的回调函数
    for (int i=0; i<callbacks.size(); i++) {
        try {
            if (stopped) callbacks.get(i).userStopped(userId);
            else callbacks.get(i).userStopAborted(userId);
        } catch (RemoteException e) {
        }
    }
    if (stopped) {
        // 回调各个SystemServer的onCleanupUser方法
        mSystemServiceManager.cleanupUser(userId);
        synchronized (this) {
            mStackSupervisor.removeUserLocked(userId);
        }
    }
}

finishUserStop()方法从mStartedUsers和mUserLru列表中删除该用户，更新mStartedUserArray列表，清理和该用户有关的进程，发送Intent.ACTION_USER_STOPPED广播来通知该用户已经停止，接下来清除用户相关的Recent Task列表以及从mStackSupervisor中删除用户的信息。

private void forceStopUserLocked(int userId, String reason) {
    // 杀掉该用户相关的所有进程，具体流程会在ActivityManager相关文章中介绍
    forceStopPackageLocked(null, -1, false, false, true, false, false, userId, reason);
    // 发出Intent.ACTION_USER_STOPPED广播
    Intent intent = new Intent(Intent.ACTION_USER_STOPPED);
    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
            | Intent.FLAG_RECEIVER_FOREGROUND);
    intent.putExtra(Intent.EXTRA_USER_HANDLE, userId);
    broadcastIntentLocked(null, null, intent,
            null, null, 0, null, null, null, AppOpsManager.OP_NONE,
            null, false, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL);
}

2.4.3 PMS

删除用户数据cleanUpUserLILPw()

void cleanUpUserLILPw(UserManagerService userManager, int userHandle) {
    mDirtyUsers.remove(userHandle);
    mSettings.removeUserLPw(userHandle);
    mPendingBroadcasts.remove(userHandle);
    if (mInstaller != null) {
        // Technically, we shouldn't be doing this with the package lock
        // held.  However, this is very rare, and there is already so much
        // other disk I/O going on, that we'll let it slide for now.
        final StorageManager storage = mContext.getSystemService(StorageManager.class);
        for (VolumeInfo vol : storage.getWritablePrivateVolumes()) {
            final String volumeUuid = vol.getFsUuid();
            mInstaller.removeUserDataDirs(volumeUuid, userHandle);
        }
    }
    mUserNeedsBadging.delete(userHandle);
    removeUnusedPackagesLILPw(userManager, userHandle);
}

删除用户的工作比较简单，删除用户的数据。同时调用mSettings.removeUserLPw(userHandle)来删除和 PMS 中和用户相关的信息。

void removeUserLPw(int userId) {
    // 删除每个应用中的该用户的信息
    Set<Entry<String, PackageSetting>> entries = mPackages.entrySet();
    for (Entry<String, PackageSetting> entry : entries) {
        entry.getValue().removeUser(userId);
    }
    mPreferredActivities.remove(userId);
    File file = getUserPackagesStateFile(userId);
    file.delete();
    file = getUserPackagesStateBackupFile(userId);
    file.delete();
    removeCrossProfileIntentFiltersLPw(userId);
    mRuntimePermissionsPersistence.onUserRemoved(userId);
    // 更新/data/system/packages.list文件
    writePackageListLPr();
}

3.VirtualApp中USM的实现

3.1 VUserHandle类简介

VUserHandle基本全参考了UserHandle，相同的方法接口

3.2 UidSystem类简介

    // packageName<-->uid映射
    private final HashMap<String, Integer> mSharedUserIdMap = new HashMap<>();
    private int mFreeUid = FIRST_APPLICATION_UID; // 10000

uid的管理类

mSharedUserIdMap 记录了包名---uid的映射
uid从10001(FIRST_APPLICATION_UID+1)开始依次递增，
每次创建一个新uid后，都把mSharedUserIdMap + mFreeUid 写入到/data/data/packageName/virtual/data/app/system/uid-list.ini中，同时把先前的uid-list.ini保存在/data/data/packageName/virtual/data/app/system/uid-list.ini.bak，关键方法如下：

    public int getOrCreateUid(VPackage pkg) {
        synchronized (mSharedUserIdMap) {
            String sharedUserId = pkg.mSharedUserId;
            if (sharedUserId == null) {
                sharedUserId = pkg.packageName; // eg: com.hgy.ndk
            }
            Integer uid = mSharedUserIdMap.get(sharedUserId);
            if (uid != null) {
                return uid;// 此包名对应的uid已创建
            }
            int newUid = ++mFreeUid;
            mSharedUserIdMap.put(sharedUserId, newUid);
            save();
            return newUid;
        }
    }

3.3. VUserInfo类简介

类似于系统的UserInfo，

3.4 VUserManagerService类简介

类似于系统的UMS，基于IUserManager.aidl，IUserManager.aidl只提供了部分接口，如setUserRestrictions等限制权限的函数是没有的。
它的构造流程基本抄了系统的UMS，可以参考前面的流程

==>同样在PMS的systemReady初始化，但它没有作为成员变量保存到PMS中

    public static void systemReady() {
        new VUserManagerService(VirtualCore.get().getContext(), get(), new char[0], get().mPackages);
    }

==>构造函数和系统的UMS基本一样，这个方法部分功能为：

保存了PMS对象到mPm 成员
创建第一个用户的目录/data/data/ xxx /virtual/data/system/users/0
创建/data/data/ xxx /virtual/data/system/users/userlist.xml，这个文件保存了系统中所有用户的id信息
读取userlist.xml文件，将用户的信息解析成UserInfo，并保存在mUsers列表中
在userlist.xml文件移除所有部分创建或部分删除的用户记录

代码如下：

 private VUserManagerService(Context context, VPackageManagerService pm,
                                Object installLock, Object packagesLock,
                                File dataDir, File baseUserPath) { // 109
        // dataDir=/data/data/io.busniess.vatools/virtual/data
        // baseUserPath=/data/data/io.busniess.vatools/virtual/data/user
        mContext = context;
        mPm = pm;
        mInstallLock = installLock;
        mPackagesLock = packagesLock;
        synchronized (mInstallLock) {
            synchronized (mPackagesLock) {
                // mUsersDir=/data/data/io.busniess.vatools/virtual/data/system/users
                mUsersDir = new File(dataDir, USER_INFO_DIR);
                mUsersDir.mkdirs();
                // 创建第一个用户的目录/data/data/io.busniess.vatools/virtual/data/system/users/0
                File userZeroDir = new File(mUsersDir, "0");
                userZeroDir.mkdirs();
                mBaseUserPath = baseUserPath;
//                FileUtils.setPermissions(mUsersDir.toString(),
//                        FileUtils.S_IRWXU|FileUtils.S_IRWXG
//                        |FileUtils.S_IROTH|FileUtils.S_IXOTH,
//                        -1, -1);
                mUserListFile = new File(mUsersDir, USER_LIST_FILENAME);
                // 读取userlist.xml文件，将用户的信息保存在mUsers列表中
                readUserListLocked();

                // 去掉任何部分创建/部分删除的用户。
                ArrayList<VUserInfo> partials = new ArrayList<VUserInfo>();
                for (int i = 0; i < mUsers.size(); i++) {
                    VUserInfo ui = mUsers.valueAt(i);
                    if (ui.partial & i != 0) {
                        partials.add(ui);
                    }
                }
                for (int i = 0; i < partials.size(); i++) {
                    VUserInfo ui = partials.get(i);
                    VLog.w(LOG_TAG, "Removing partially created user #" + i
                            + " (name=" + ui.name + ")");
                    removeUserStateLocked(ui.id);
                }
                sInstance = this;
            }
        }
    }

===>writeUserListLocked写入/data/data/ xxx/virtual/data/system/users/userlist.xml
===>writeUserLocked把VUserInfo写入到data/data/io.busniess.vatools/virtual/data/system/users目录下
===>fallbackToSingleUserLocked创建第一个user并调用writeUserListLocked写入userlist.xml，并调用writeUserLocked写入

3.5 UMS的hook

参考UserManagerStub.java, 主要实现：
1.将 setApplicationRestrictions，getApplicationRestrictions，getApplicationRestrictionsForUser的包名换成io.busniess.va
2.将 getProfileParent，getUserIcon，getDefaultGuestRestrictions，setDefaultGuestRestrictions，removeRestrictions，createUser，等都返回null