How to use

PackageCacheManager

in

com.lody.virtual.server.pm

res.packageName = pkg.packageName;
VPackage existOne = PackageCacheManager.get(pkg.packageName);
PackageSetting existSetting = existOne != null ? (PackageSetting) existOne.mExtras : null;
if (existOne != null) {
  PackageCacheManager.remove(pkg.packageName);
PackageCacheManager.put(pkg, ps);
mPersistenceLayer.save();
if (!dependSystem) {

public int getAppId(String packageName) {
  PackageSetting setting = PackageCacheManager.getSetting(packageName);
  return setting != null ? setting.appId : -1;
}

private void uninstallPackageFully(PackageSetting ps) {
  String packageName = ps.packageName;
  try {
    BroadcastSystem.get().stopApp(packageName);
    VActivityManagerService.get().killAppByPkg(packageName, VUserHandle.USER_ALL);
    VEnvironment.getPackageResourcePath(packageName).delete();
    FileUtils.deleteDir(VEnvironment.getDataAppPackageDirectory(packageName));
    VEnvironment.getOdexFile(packageName).delete();
    for (int id : VUserManagerService.get().getUserIds()) {
      FileUtils.deleteDir(VEnvironment.getDataUserPackageDirectory(id, packageName));
      FileUtils.deleteDir(VEnvironment.getVirtualPrivateStorageDir(id, packageName));
    }
    PackageCacheManager.remove(packageName);
  } catch (Exception e) {
    e.printStackTrace();
  } finally {
    notifyAppUninstalled(ps, -1);
  }
}

private boolean loadPackageInnerLocked(PackageSetting ps) {
  if (ps.dependSystem) {
    if (!VirtualCore.get().isOutsideInstalled(ps.packageName)) {
      return false;
    }
  }
  File cacheFile = VEnvironment.getPackageCacheFile(ps.packageName);
  VPackage pkg = null;
  try {
    pkg = PackageParserEx.readPackageCache(ps.packageName);
  } catch (Throwable e) {
    e.printStackTrace();
  }
  if (pkg == null || pkg.packageName == null) {
    return false;
  }
  chmodPackageDictionary(cacheFile);
  PackageCacheManager.put(pkg, ps);
  BroadcastSystem.get().startApp(pkg);
  return true;
}

private void uninstallPackageFully(PackageSetting ps) {
  String packageName = ps.packageName;
  try {
    BroadcastSystem.get().stopApp(packageName);
    VActivityManagerService.get().killAppByPkg(packageName, VUserHandle.USER_ALL);
    VEnvironment.getPackageResourcePath(packageName).delete();
    FileUtils.deleteDir(VEnvironment.getDataAppPackageDirectory(packageName));
    VEnvironment.getOdexFile(packageName).delete();
    for (int id : VUserManagerService.get().getUserIds()) {
      FileUtils.deleteDir(VEnvironment.getDataUserPackageDirectory(id, packageName));
    }
    PackageCacheManager.remove(packageName);
  } catch (Exception e) {
    e.printStackTrace();
  } finally {
    notifyAppUninstalled(ps, -1);
  }
}

private boolean loadPackageInnerLocked(PackageSetting ps) {
  if (ps.dependSystem) {
    if (!VirtualCore.get().isOutsideInstalled(ps.packageName)) {
      return false;
    }
  }
  File cacheFile = VEnvironment.getPackageCacheFile(ps.packageName);
  VPackage pkg = null;
  try {
    pkg = PackageParserEx.readPackageCache(ps.packageName);
  } catch (Throwable e) {
    e.printStackTrace();
  }
  if (pkg == null || pkg.packageName == null) {
    return false;
  }
  chmodPackageDictionary(cacheFile);
  PackageCacheManager.put(pkg, ps);
  BroadcastSystem.get().startApp(pkg);
  return true;
}

@Override
public InstalledAppInfo getInstalledAppInfo(String packageName, int flags) {
  synchronized (PackageCacheManager.class) {
    if (packageName != null) {
      PackageSetting setting = PackageCacheManager.getSetting(packageName);
      if (setting != null) {
        return setting.getAppInfo();
      }
    }
    return null;
  }
}

res.packageName = pkg.packageName;
VPackage existOne = PackageCacheManager.get(pkg.packageName);
PackageSetting existSetting = existOne != null ? (PackageSetting) existOne.mExtras : null;
if (existOne != null) {
  PackageCacheManager.remove(pkg.packageName);
PackageCacheManager.put(pkg, ps);
mPersistenceLayer.save();
if (!dependSystem) {

private void uninstallPackageFully(PackageSetting ps) {
  String packageName = ps.packageName;
  try {
    BroadcastSystem.get().stopApp(packageName);
    VActivityManagerService.get().killAppByPkg(packageName, VUserHandle.USER_ALL);
    VEnvironment.getPackageResourcePath(packageName).delete();
    FileUtils.deleteDir(VEnvironment.getDataAppPackageDirectory(packageName));
    VEnvironment.getOdexFile(packageName).delete();
    for (int id : VUserManagerService.get().getUserIds()) {
      FileUtils.deleteDir(VEnvironment.getDataUserPackageDirectory(id, packageName));
      FileUtils.deleteDir(VEnvironment.getVirtualPrivateStorageDir(id, packageName));
    }
    PackageCacheManager.remove(packageName);
  } catch (Exception e) {
    e.printStackTrace();
  } finally {
    notifyAppUninstalled(ps, -1);
  }
}

private boolean loadPackageInnerLocked(PackageSetting ps) {
  if (ps.dependSystem) {
    if (!VirtualCore.get().isOutsideInstalled(ps.packageName)) {
      return false;
    }
  }
  File cacheFile = VEnvironment.getPackageCacheFile(ps.packageName);
  VPackage pkg = null;
  try {
    pkg = PackageParserEx.readPackageCache(ps.packageName);
  } catch (Throwable e) {
    e.printStackTrace();
  }
  if (pkg == null || pkg.packageName == null) {
    return false;
  }
  chmodPackageDictionary(cacheFile);
  PackageCacheManager.put(pkg, ps);
  BroadcastSystem.get().startApp(pkg);
  return true;
}

@Override
public synchronized boolean uninstallPackage(String packageName) {
  PackageSetting ps = PackageCacheManager.getSetting(packageName);
  if (ps != null) {
    uninstallPackageFully(ps);
    return true;
  }
  return false;
}

res.packageName = pkg.packageName;
VPackage existOne = PackageCacheManager.get(pkg.packageName);
PackageSetting existSetting = existOne != null ? (PackageSetting) existOne.mExtras : null;
if (existOne != null) {
  PackageCacheManager.remove(pkg.packageName);
PackageCacheManager.put(pkg, ps);
mPersistenceLayer.save();
if (!dependSystem) {

public boolean isPackageLaunched(int userId, String packageName) {
  PackageSetting ps = PackageCacheManager.getSetting(packageName);
  return ps != null && ps.isLaunched(userId);
}

  public Resources getResources(Context context, ApplicationInfo appInfo) throws Exception {
    PackageSetting ps = PackageCacheManager.getSetting(appInfo.packageName);
    if (ps != null) {
      AssetManager assets = mirror.android.content.res.AssetManager.ctor.newInstance();
      mirror.android.content.res.AssetManager.addAssetPath.call(assets, ps.apkPath);
      Resources hostRes = context.getResources();
      return new Resources(assets, hostRes.getDisplayMetrics(), hostRes.getConfiguration());
    }
    return null;
  }
}

@Override
public boolean isAppInstalledAsUser(int userId, String packageName) {
  if (packageName == null || !VUserManagerService.get().exists(userId)) {
    return false;
  }
  PackageSetting setting = PackageCacheManager.getSetting(packageName);
  if (setting == null) {
    return false;
  }
  return setting.isInstalled(userId);
}

public void setPackageHidden(int userId, String packageName, boolean hidden) {
  PackageSetting ps = PackageCacheManager.getSetting(packageName);
  if (ps != null && VUserManagerService.get().exists(userId)) {
    ps.setHidden(userId, hidden);
    mPersistenceLayer.save();
  }
}

@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];
}

@Override
public synchronized boolean installPackageAsUser(int userId, String packageName) {
  if (VUserManagerService.get().exists(userId)) {
    PackageSetting ps = PackageCacheManager.getSetting(packageName);
    if (ps != null) {
      if (!ps.isInstalled(userId)) {
        ps.setInstalled(userId, true);
        notifyAppInstalled(ps, userId);
        mPersistenceLayer.save();
        return true;
      }
    }
  }
  return false;
}

ProcessRecord startProcessIfNeedLocked(String processName, int userId, String packageName) {
  if (VActivityManagerService.get().getFreeStubCount() < 3) {
    // run GC
    killAllApps();
  }
  PackageSetting ps = PackageCacheManager.getSetting(packageName);
  ApplicationInfo info = VPackageManagerService.get().getApplicationInfo(packageName, 0, userId);
  if (ps == null || info == null) {
    return null;
  }
  if (!ps.isLaunched(userId)) {
    sendFirstLaunchBroadcast(ps, userId);
    ps.setLaunched(userId, true);
    VAppManagerService.get().savePersistenceData();
  }
  int uid = VUserHandle.getUid(userId, ps.appId);
  ProcessRecord app = mProcessNames.get(processName, uid);
  if (app != null && app.client.asBinder().pingBinder()) {
    return app;
  }
  int vpid = queryFreeStubProcessLocked();
  if (vpid == -1) {
    return null;
  }
  app = performStartProcessLocked(uid, vpid, info, processName);
  if (app != null) {
    app.pkgList.add(info.packageName);
  }
  return app;
}

@Override
public boolean clearPackageAsUser(int userId, String packageName) throws RemoteException {
  if (!VUserManagerService.get().exists(userId)) {
    return false;
  }
  PackageSetting ps = PackageCacheManager.getSetting(packageName);
  if (ps != null) {
    int[] userIds = getPackageInstalledUsers(packageName);
    if (!ArrayUtils.contains(userIds, userId)) {
      return false;
    }
    if (userIds.length == 1) {
      clearPackage(packageName);
    } else {
      // Just hidden it
      VActivityManagerService.get().killAppByPkg(packageName, userId);
      ps.setInstalled(userId, false);
      mPersistenceLayer.save();
      FileUtils.deleteDir(VEnvironment.getDataUserPackageDirectory(userId, packageName));
      FileUtils.deleteDir(VEnvironment.getVirtualPrivateStorageDir(userId, packageName));
    }
    return true;
  }
  return false;
}