How to use

VUserManagerService

in

com.lody.virtual.server.pm

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

@Override
public VUserInfo createUser(String name, int flags) {
  checkManageUsersPermission("Only the system can create users");
    synchronized (mInstallLock) {
      synchronized (mPackagesLock) {
        if (isUserLimitReachedLocked()) return null;
        int userId = getNextAvailableIdLocked();
        userInfo = new VUserInfo(userId, name, null, flags);
        File userPath = new File(mBaseUserPath, Integer.toString(userId));
        VEnvironment.getUserSystemDirectory(userInfo.id).mkdirs();
        mUsers.put(userId, userInfo);
        writeUserListLocked();
        writeUserLocked(userInfo);
        mPm.createNewUser(userId, userPath);
        userInfo.partial = false;
        writeUserLocked(userInfo);
        updateUserIdsLocked();

@Override
public void setGuestEnabled(boolean enable) {
  checkManageUsersPermission("enable guest users");
  synchronized (mPackagesLock) {
    if (mGuestEnabled != enable) {
      mGuestEnabled = enable;
      // Erase any guest user that currently exists
      for (int i = 0; i < mUsers.size(); i++) {
        VUserInfo user = mUsers.valueAt(i);
        if (!user.partial && user.isGuest()) {
          if (!enable) {
            removeUser(user.id);
          }
          return;
        }
      }
      // No guest was found
      if (enable) {
        createUser("Guest", VUserInfo.FLAG_GUEST);
      }
    }
  }
}

@Override
public int getUserSerialNumber(int userHandle) {
  synchronized (mPackagesLock) {
    if (!exists(userHandle)) return -1;
    return getUserInfoLocked(userHandle).serialNumber;
  }
}

private void checkUserId(int userId) {
  if (!VUserManagerService.get().exists(userId)) {
    throw new SecurityException("Invalid userId " + userId);
  }
}

@Override
public void setUserIcon(int userId, Bitmap bitmap) {
  checkManageUsersPermission("update users");
  synchronized (mPackagesLock) {
    VUserInfo info = mUsers.get(userId);
    if (info == null || info.partial) {
      VLog.w(LOG_TAG, "setUserIcon: unknown user #" + userId);
      return;
    }
    writeBitmapLocked(info, bitmap);
    writeUserLocked(info);
  }
  sendUserInfoChangedBroadcast(userId);
}

@Override
public int[] getPackageInstalledUsers(String packageName) {
  PackageSetting ps = PackageCacheManager.getSetting(packageName);
  if (ps != null) {
    IntArray installedUsers = new IntArray(5);
    int[] userIds = VUserManagerService.get().getUserIds();
    for (int userId : userIds) {
      if (ps.readUserState(userId).installed) {
        installedUsers.add(userId);
      }
    }
    return installedUsers.getAll();
  }
  return new int[0];
}

private void readUserListLocked() {
  mGuestEnabled = false;
  if (!mUserListFile.exists()) {
    fallbackToSingleUserLocked();
    return;
      fallbackToSingleUserLocked();
      return;
      if (type == XmlPullParser.START_TAG && parser.getName().equals(TAG_USER)) {
        String id = parser.getAttributeValue(null, ATTR_ID);
        VUserInfo user = readUser(Integer.parseInt(id));
    updateUserIdsLocked();
    upgradeIfNecessary();
  } catch (IOException ioe) {
    fallbackToSingleUserLocked();
  } catch (XmlPullParserException pe) {
    fallbackToSingleUserLocked();
  } finally {
    if (fis != null) {

@Override
public void setUserName(int userId, String name) {
  checkManageUsersPermission("rename users");
  boolean changed = false;
  synchronized (mPackagesLock) {
    VUserInfo info = mUsers.get(userId);
    if (info == null || info.partial) {
      VLog.w(LOG_TAG, "setUserName: unknown user #" + userId);
      return;
    }
    if (name != null && !name.equals(info.name)) {
      info.name = name;
      writeUserLocked(info);
      changed = true;
    }
  }
  if (changed) {
    sendUserInfoChangedBroadcast(userId);
  }
}

public void makeInitialized(int userId) {
  checkManageUsersPermission("makeInitialized");
  synchronized (mPackagesLock) {
    VUserInfo info = mUsers.get(userId);
    if (info == null || info.partial) {
      VLog.w(LOG_TAG, "makeInitialized: unknown user #" + userId);
    }
    if ((info.flags& VUserInfo.FLAG_INITIALIZED) == 0) {
      info.flags |= VUserInfo.FLAG_INITIALIZED;
      writeUserLocked(info);
    }
  }
}

@Override
public int getUserHandle(int userSerialNumber) {
  synchronized (mPackagesLock) {
    for (int userId : mUserIds) {
      if (getUserInfoLocked(userId).serialNumber == userSerialNumber) return userId;
    }
    // Not found
    return -1;
  }
}

@Override
public void userStopped(int userId) {
  finishRemoveUser(userId);
}
@Override

@Override
public void wipeUser(int userHandle) {
  checkManageUsersPermission("wipe user");
  // TODO:
}

@Override
public boolean onCreate() {
  Context context = getContext();
  DaemonService.startup(context);
  if (!VirtualCore.get().isStartup()) {
    return true;
  }
  VPackageManagerService.systemReady();
  addService(ServiceManagerNative.PACKAGE, VPackageManagerService.get());
  VActivityManagerService.systemReady(context);
  addService(ServiceManagerNative.ACTIVITY, VActivityManagerService.get());
  addService(ServiceManagerNative.USER, VUserManagerService.get());
  VAppManagerService.systemReady();
  addService(ServiceManagerNative.APP, VAppManagerService.get());
  BroadcastSystem.attach(VActivityManagerService.get(), VAppManagerService.get());
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    addService(ServiceManagerNative.JOB, VJobSchedulerService.get());
  }
  VNotificationManagerService.systemReady(context);
  addService(ServiceManagerNative.NOTIFICATION, VNotificationManagerService.get());
  VAppManagerService.get().scanApps();
  VAccountManagerService.systemReady();
  addService(ServiceManagerNative.ACCOUNT, VAccountManagerService.get());
  addService(ServiceManagerNative.VS, VirtualStorageService.get());
  addService(ServiceManagerNative.DEVICE, VDeviceManagerService.get());
  addService(ServiceManagerNative.VIRTUAL_LOC, VirtualLocationService.get());
  return true;
}

  private void checkUserId(int userId) {
    if (!VUserManagerService.get().exists(userId)) {
      throw new IllegalStateException("Invalid userId " + userId);
    }
  }
}

@Override
public boolean clearPackage(String packageName) throws RemoteException {
  try {
    BroadcastSystem.get().stopApp(packageName);
    VActivityManagerService.get().killAppByPkg(packageName, VUserHandle.USER_ALL);
    for (int id : VUserManagerService.get().getUserIds()) {
      FileUtils.deleteDir(VEnvironment.getDataUserPackageDirectory(id, packageName));
      FileUtils.deleteDir(VEnvironment.getVirtualPrivateStorageDir(id, packageName));
    }
    return true;
  } catch (Exception e) {
    return false;
  }
}

@Override
public void setUserIcon(int userId, Bitmap bitmap) {
  checkManageUsersPermission("update users");
  synchronized (mPackagesLock) {
    VUserInfo info = mUsers.get(userId);
    if (info == null || info.partial) {
      VLog.w(LOG_TAG, "setUserIcon: unknown user #" + userId);
      return;
    }
    writeBitmapLocked(info, bitmap);
    writeUserLocked(info);
  }
  sendUserInfoChangedBroadcast(userId);
}

private void readUserListLocked() {
  mGuestEnabled = false;
  if (!mUserListFile.exists()) {
    fallbackToSingleUserLocked();
    return;
      fallbackToSingleUserLocked();
      return;
      if (type == XmlPullParser.START_TAG && parser.getName().equals(TAG_USER)) {
        String id = parser.getAttributeValue(null, ATTR_ID);
        VUserInfo user = readUser(Integer.parseInt(id));
    updateUserIdsLocked();
    upgradeIfNecessary();
  } catch (IOException ioe) {
    fallbackToSingleUserLocked();
  } catch (XmlPullParserException pe) {
    fallbackToSingleUserLocked();
  } finally {
    if (fis != null) {

@Override
public void setUserName(int userId, String name) {
  checkManageUsersPermission("rename users");
  boolean changed = false;
  synchronized (mPackagesLock) {
    VUserInfo info = mUsers.get(userId);
    if (info == null || info.partial) {
      VLog.w(LOG_TAG, "setUserName: unknown user #" + userId);
      return;
    }
    if (name != null && !name.equals(info.name)) {
      info.name = name;
      writeUserLocked(info);
      changed = true;
    }
  }
  if (changed) {
    sendUserInfoChangedBroadcast(userId);
  }
}

checkManageUsersPermission("Only the system can remove users");
final VUserInfo user;
synchronized (mPackagesLock) {
  writeUserLocked(user);