IPluginManagerImpl.java 源代码
package com.x8zs.morgoo.droidplugin.pm;
import android.app.ActivityManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PermissionGroupInfo;
import android.content.pm.PermissionInfo;
import android.content.pm.ProviderInfo;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.content.pm.Signature;
import android.net.Uri;
import android.os.Binder;
import android.os.Process;
import android.os.RemoteException;
import android.text.TextUtils;
import com.x8zs.morgoo.droidplugin.am.BaseActivityManagerService;
import com.x8zs.morgoo.droidplugin.am.MyActivityManagerService;
import com.x8zs.morgoo.droidplugin.core.PluginClassLoader;
import com.x8zs.morgoo.droidplugin.core.PluginDirHelper;
import com.x8zs.morgoo.droidplugin.pm.IPluginManager;
import com.x8zs.morgoo.droidplugin.pm.parser.IntentMatcher;
import com.x8zs.morgoo.droidplugin.pm.parser.PluginPackageParser;
import com.x8zs.morgoo.helper.Log;
import com.x8zs.morgoo.helper.Utils;
import com.x8zs.morgoo.helper.compat.BuildCompat;
import com.x8zs.morgoo.helper.compat.PackageManagerCompat;
import com.x8zs.morgoo.helper.compat.VMRuntimeCompat;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
public class IPluginManagerImpl extends IPluginManager.Stub {
private static final String TAG = "IPluginManagerImpl";
private BaseActivityManagerService mActivityManagerService;
private Context mContext;
private Map<String, PluginPackageParser> mPluginCache = Collections.synchronizedMap(new HashMap(20));
private AtomicBoolean mHasLoadedOk = new AtomicBoolean(false);
private final Object mLock = new Object();
private Set<String> mHostRequestedPermission = new HashSet(10);
private Map<String, Signature[]> mSignatureCache = new HashMap();
public IPluginManagerImpl(Context context) {
this.mContext = context;
this.mActivityManagerService = new MyActivityManagerService(this.mContext);
}
private void copyNativeLibs(Context context, String str, ApplicationInfo applicationInfo) {
ZipFile zipFile;
InputStream inputStream;
FileOutputStream fileOutputStream;
InputStream inputStream2;
String pluginNativeLibraryDir = PluginDirHelper.getPluginNativeLibraryDir(context, applicationInfo.packageName);
try {
ZipFile zipFile2 = new ZipFile(str);
try {
Enumeration<? extends ZipEntry> entries = zipFile2.entries();
HashMap hashMap = new HashMap();
HashMap hashMap2 = new HashMap(1);
while (entries.hasMoreElements()) {
ZipEntry nextElement = entries.nextElement();
String name = nextElement.getName();
if (name.contains("../")) {
Log.d(TAG, "Path traversal attack prevented", new Object[0]);
} else if (name.startsWith("lib/") && !nextElement.isDirectory()) {
hashMap.put(name, nextElement);
String name2 = new File(name).getName();
Set set = (Set) hashMap2.get(name2);
if (set == null) {
set = new TreeSet();
hashMap2.put(name2, set);
}
set.add(name);
}
}
for (String str2 : hashMap2.keySet()) {
Log.e(TAG, "try so =" + str2, new Object[0]);
try {
String findSoPath = findSoPath((Set) hashMap2.get(str2), str2);
if (findSoPath != null) {
File file = new File(pluginNativeLibraryDir, str2);
if (file.exists()) {
file.delete();
}
try {
inputStream2 = zipFile2.getInputStream((ZipEntry) hashMap.get(findSoPath));
} catch (Exception e6) {
e = e6;
inputStream = null;
} catch (Throwable th) {
th = th;
inputStream = null;
}
try {
fileOutputStream = new FileOutputStream(file);
} catch (Exception e7) {
e = e7;
inputStream = inputStream2;
fileOutputStream = null;
try {
if (file.exists()) {
file.delete();
}
throw e;
} catch (Throwable th2) {
th = th2;
if (inputStream != null) {
try {
inputStream.close();
} catch (Exception unused) {
}
}
if (fileOutputStream != null) {
try {
fileOutputStream.close();
throw th;
} catch (Exception unused2) {
throw th;
}
}
throw th;
}
} catch (Throwable th3) {
th = th3;
inputStream = inputStream2;
fileOutputStream = null;
if (inputStream != null) {
}
if (fileOutputStream != null) {
}
}
try {
byte[] bArr = new byte[8192];
while (true) {
int read = inputStream2.read(bArr);
if (read == -1) {
break;
} else {
fileOutputStream.write(bArr, 0, read);
}
}
fileOutputStream.flush();
fileOutputStream.getFD().sync();
Log.i(TAG, "copy so(%s) for %s to %s ok!", str2, findSoPath, file.getPath());
try {
inputStream2.close();
} catch (Exception unused3) {
}
try {
fileOutputStream.close();
} catch (Exception unused4) {
}
} catch (Exception e8) {
e = e8;
inputStream = inputStream2;
if (file.exists()) {
}
throw e;
} catch (Throwable th4) {
th = th4;
inputStream = inputStream2;
if (inputStream != null) {
}
if (fileOutputStream != null) {
}
}
}
} catch (Throwable th5) {
th = th5;
zipFile = zipFile2;
if (zipFile != null) {
try {
zipFile.close();
} catch (Exception unused5) {
}
}
throw th;
}
}
try {
zipFile2.close();
} catch (Exception unused6) {
}
} catch (Throwable th6) {
th = th6;
}
} catch (Throwable th7) {
th = th7;
zipFile = null;
}
}
private void dexOpt(Context context, String str, PluginPackageParser pluginPackageParser) {
String packageName = pluginPackageParser.getPackageName();
new PluginClassLoader(str, PluginDirHelper.getPluginDalvikCacheDir(context, packageName), PluginDirHelper.getPluginNativeLibraryDir(context, packageName), ClassLoader.getSystemClassLoader());
}
private void enforcePluginFileExists() {
ArrayList arrayList = new ArrayList();
for (String str : this.mPluginCache.keySet()) {
File pluginFile = this.mPluginCache.get(str).getPluginFile();
if (pluginFile == null || !pluginFile.exists()) {
arrayList.add(str);
}
}
Iterator it = arrayList.iterator();
while (it.hasNext()) {
deletePackage((String) it.next(), 0);
}
}
private String findSoPath(Set<String> set, String str) {
if (set != null && set.size() > 0) {
if (VMRuntimeCompat.is64Bit()) {
String[] strArr = BuildCompat.SUPPORTED_64_BIT_ABIS;
Arrays.sort(strArr);
for (String str2 : set) {
String replace = str2.replaceFirst("lib/", "").replace("/" + str, "");
if (!TextUtils.isEmpty(replace) && Arrays.binarySearch(strArr, replace) >= 0) {
return str2;
}
}
return null;
}
String[] strArr2 = BuildCompat.SUPPORTED_32_BIT_ABIS;
Arrays.sort(strArr2);
for (String str3 : set) {
String replace2 = str3.replaceFirst("lib/", "").replace("/" + str, "");
if (!TextUtils.isEmpty(replace2) && Arrays.binarySearch(strArr2, replace2) >= 0) {
return str3;
}
}
return null;
}
return null;
}
private String getAndCheckCallingPkg(String str) {
return str;
}
private Signature[] getSignature(String str, PackageManager packageManager) {
PackageInfo packageInfo = getPackageInfo(str, 64);
if (packageInfo == null) {
packageInfo = packageManager.getPackageInfo(str, 64);
}
if (packageInfo != null) {
return packageInfo.signatures;
}
throw new PackageManager.NameNotFoundException();
}
private void handleException(Exception exc) {
RemoteException remoteException = new RemoteException(exc.getMessage());
remoteException.initCause(exc);
remoteException.setStackTrace(exc.getStackTrace());
throw remoteException;
}
private void loadAllPlugin(Context context) {
ArrayList arrayList;
Iterator it;
PluginPackageParser pluginPackageParser;
Signature[] readSignatures;
long currentTimeMillis = System.currentTimeMillis();
ArrayList arrayList2 = null;
try {
arrayList = new ArrayList();
} catch (Exception e6) {
e = e6;
}
try {
for (File file : new File(PluginDirHelper.getBaseDir(context)).listFiles()) {
if (file.isDirectory()) {
File file2 = new File(file, "apk/base-1.apk");
if (file2.exists()) {
arrayList.add(file2);
}
}
}
} catch (Exception e7) {
e = e7;
arrayList2 = arrayList;
Log.e(TAG, "scan a apk file error", e, new Object[0]);
arrayList = arrayList2;
Log.i(TAG, "Search apk cost %s ms", Long.valueOf(System.currentTimeMillis() - currentTimeMillis));
long currentTimeMillis2 = System.currentTimeMillis();
if (arrayList != null) {
it = arrayList.iterator();
while (it.hasNext()) {
}
}
Log.i(TAG, "Parse all apk cost %s ms", Long.valueOf(System.currentTimeMillis() - currentTimeMillis2));
long currentTimeMillis3 = System.currentTimeMillis();
this.mActivityManagerService.onCreate(this);
Log.i(TAG, "ActivityManagerService.onCreate %s ms", Long.valueOf(System.currentTimeMillis() - currentTimeMillis3));
}
Log.i(TAG, "Search apk cost %s ms", Long.valueOf(System.currentTimeMillis() - currentTimeMillis));
long currentTimeMillis22 = System.currentTimeMillis();
if (arrayList != null && arrayList.size() > 0) {
it = arrayList.iterator();
while (it.hasNext()) {
File file3 = (File) it.next();
long currentTimeMillis4 = System.currentTimeMillis();
try {
pluginPackageParser = new PluginPackageParser(this.mContext, file3);
readSignatures = readSignatures(pluginPackageParser.getPackageName());
} finally {
try {
} catch (Throwable th) {
}
}
if (readSignatures != null && readSignatures.length > 0) {
this.mSignatureCache.put(pluginPackageParser.getPackageName(), readSignatures);
pluginPackageParser.writeSignature(readSignatures);
if (!this.mPluginCache.containsKey(pluginPackageParser.getPackageName())) {
this.mPluginCache.put(pluginPackageParser.getPackageName(), pluginPackageParser);
}
Log.i(TAG, "Parse %s apk cost %s ms", file3.getPath(), Long.valueOf(System.currentTimeMillis() - currentTimeMillis4));
}
pluginPackageParser.collectCertificates(0);
saveSignatures(pluginPackageParser.getPackageInfo(64));
if (!this.mPluginCache.containsKey(pluginPackageParser.getPackageName())) {
}
Log.i(TAG, "Parse %s apk cost %s ms", file3.getPath(), Long.valueOf(System.currentTimeMillis() - currentTimeMillis4));
}
}
Log.i(TAG, "Parse all apk cost %s ms", Long.valueOf(System.currentTimeMillis() - currentTimeMillis22));
long currentTimeMillis32 = System.currentTimeMillis();
try {
this.mActivityManagerService.onCreate(this);
} catch (Throwable th2) {
Log.e(TAG, "mActivityManagerService.onCreate", th2, new Object[0]);
}
Log.i(TAG, "ActivityManagerService.onCreate %s ms", Long.valueOf(System.currentTimeMillis() - currentTimeMillis32));
}
private void loadHostRequestedPermission() {
String[] strArr;
try {
this.mHostRequestedPermission.clear();
PackageInfo packageInfo = this.mContext.getPackageManager().getPackageInfo(this.mContext.getPackageName(), 4096);
if (packageInfo != null && (strArr = packageInfo.requestedPermissions) != null && strArr.length > 0) {
for (String str : strArr) {
this.mHostRequestedPermission.add(str);
}
}
} catch (Exception unused) {
}
}
public void onCreateInner() {
loadAllPlugin(this.mContext);
loadHostRequestedPermission();
try {
this.mHasLoadedOk.set(true);
synchronized (this.mLock) {
this.mLock.notifyAll();
}
} catch (Exception unused) {
}
}
private boolean pkgInPid(int i6, String str) {
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(i6);
if (packageNamesByPid != null && packageNamesByPid.size() > 0) {
return packageNamesByPid.contains(str);
}
return true;
}
private Signature[] readSignatures(String str) {
List<String> pluginSignatureFiles = PluginDirHelper.getPluginSignatureFiles(this.mContext, str);
ArrayList arrayList = new ArrayList(pluginSignatureFiles.size());
Iterator<String> it = pluginSignatureFiles.iterator();
int i6 = 0;
while (it.hasNext()) {
try {
byte[] readFromFile = Utils.readFromFile(new File(it.next()));
if (readFromFile != null) {
Signature signature = new Signature(readFromFile);
arrayList.add(signature);
Log.i(TAG, "Read %s signature of %s,md5=%s", str, Integer.valueOf(i6), Utils.md5(signature.toByteArray()));
i6++;
} else {
Log.i(TAG, "Read %s signature of %s FAIL", str, Integer.valueOf(i6));
return null;
}
} catch (Exception e6) {
Log.i(TAG, "Read %s signature of %s FAIL", e6, str, Integer.valueOf(i6));
return null;
}
}
return (Signature[]) arrayList.toArray(new Signature[arrayList.size()]);
}
private void saveSignatures(PackageInfo packageInfo) {
Signature[] signatureArr;
if (packageInfo != null && (signatureArr = packageInfo.signatures) != null) {
int i6 = 0;
for (Signature signature : signatureArr) {
File file = new File(PluginDirHelper.getPluginSignatureFile(this.mContext, packageInfo.packageName, i6));
try {
Utils.writeToFile(file, signature.toByteArray());
Log.i(TAG, "Save %s signature of %s,md5=%s", packageInfo.packageName, Integer.valueOf(i6), Utils.md5(signature.toByteArray()));
i6++;
} catch (Exception e6) {
e6.printStackTrace();
Log.w(TAG, "Save signatures fail", e6, new Object[0]);
file.delete();
Utils.deleteDir(PluginDirHelper.getPluginSignatureDir(this.mContext, packageInfo.packageName));
return;
}
}
}
}
private void sendInstalledBroadcast(String str) {
Intent intent = new Intent(PluginManager.ACTION_PACKAGE_ADDED);
intent.setData(Uri.parse("package://" + str));
this.mContext.sendBroadcast(intent);
}
private void sendUninstalledBroadcast(String str) {
Intent intent = new Intent(PluginManager.ACTION_PACKAGE_REMOVED);
intent.setData(Uri.parse("package://" + str));
this.mContext.sendBroadcast(intent);
}
private boolean shouldNotBlockOtherInfo() {
return true;
}
private void waitForReadyInner() {
if (!this.mHasLoadedOk.get()) {
synchronized (this.mLock) {
try {
this.mLock.wait();
} catch (InterruptedException unused) {
}
}
}
}
@Override
public int checkSignatures(String str, String str2) {
boolean z6;
boolean z7;
PackageManager packageManager = this.mContext.getPackageManager();
try {
Signature[] signature = getSignature(str, packageManager);
Signature[] signature2 = getSignature(str2, packageManager);
if (signature != null && signature.length > 0) {
z6 = true;
} else {
z6 = false;
}
if (signature2 != null && signature2.length > 0) {
z7 = true;
} else {
z7 = false;
}
if (!z6 && !z7) {
return 1;
}
if (!z6 && z7) {
return -1;
}
if (z6 && !z7) {
return -2;
}
if (signature.length != signature2.length) {
return -3;
}
for (int i6 = 0; i6 < signature.length; i6++) {
if (!Arrays.equals(signature[i6].toByteArray(), signature2[i6].toByteArray())) {
return -3;
}
}
return 0;
} catch (PackageManager.NameNotFoundException unused) {
return -4;
}
}
@Override
public void clearApplicationUserData(String str, IPackageDataObserver iPackageDataObserver) {
boolean z6 = false;
try {
try {
} catch (Exception e6) {
handleException(e6);
if (iPackageDataObserver == null) {
return;
}
}
if (TextUtils.isEmpty(str)) {
if (iPackageDataObserver != null) {
iPackageDataObserver.onRemoveCompleted(str, false);
return;
}
return;
}
PluginPackageParser pluginPackageParser = this.mPluginCache.get(str);
if (pluginPackageParser == null) {
if (iPackageDataObserver != null) {
iPackageDataObserver.onRemoveCompleted(str, false);
}
} else {
Utils.deleteDir(pluginPackageParser.getApplicationInfo(0).dataDir);
if (iPackageDataObserver != null) {
z6 = true;
iPackageDataObserver.onRemoveCompleted(str, z6);
}
}
} catch (Throwable th) {
if (iPackageDataObserver != null) {
iPackageDataObserver.onRemoveCompleted(str, false);
}
throw th;
}
}
@Override
public void deleteApplicationCacheFiles(String str, IPackageDataObserver iPackageDataObserver) {
boolean z6 = false;
try {
try {
} catch (Exception e6) {
handleException(e6);
if (iPackageDataObserver == null) {
return;
}
}
if (TextUtils.isEmpty(str)) {
if (iPackageDataObserver != null) {
iPackageDataObserver.onRemoveCompleted(str, false);
return;
}
return;
}
PluginPackageParser pluginPackageParser = this.mPluginCache.get(str);
if (pluginPackageParser == null) {
if (iPackageDataObserver != null) {
iPackageDataObserver.onRemoveCompleted(str, false);
}
} else {
Utils.deleteDir(new File(pluginPackageParser.getApplicationInfo(0).dataDir, "caches").getName());
if (iPackageDataObserver != null) {
z6 = true;
iPackageDataObserver.onRemoveCompleted(str, z6);
}
}
} catch (Throwable th) {
if (iPackageDataObserver != null) {
iPackageDataObserver.onRemoveCompleted(str, false);
}
throw th;
}
}
@Override
public int deletePackage(String str, int i6) {
PluginPackageParser remove;
try {
if (this.mPluginCache.containsKey(str)) {
forceStopPackage(str);
synchronized (this.mPluginCache) {
remove = this.mPluginCache.remove(str);
}
Utils.deleteDir(PluginDirHelper.makePluginBaseDir(this.mContext, str));
this.mActivityManagerService.onPkgDeleted(this.mPluginCache, remove, str);
this.mSignatureCache.remove(str);
sendUninstalledBroadcast(str);
return 1;
}
return -1;
} catch (Exception e6) {
handleException(e6);
return -1;
}
}
@Override
public boolean forceStopPackage(String str) {
return killBackgroundProcesses(str);
}
@Override
public ActivityInfo getActivityInfo(ComponentName componentName, int i6) {
waitForReadyInner();
try {
if (getAndCheckCallingPkg(componentName.getPackageName()) != null) {
enforcePluginFileExists();
PluginPackageParser pluginPackageParser = this.mPluginCache.get(componentName.getPackageName());
if (pluginPackageParser != null) {
return pluginPackageParser.getActivityInfo(componentName, i6);
}
return null;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<PermissionGroupInfo> getAllPermissionGroups(int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
ArrayList arrayList = new ArrayList();
if (shouldNotBlockOtherInfo()) {
Iterator<PluginPackageParser> it = this.mPluginCache.values().iterator();
while (it.hasNext()) {
for (PermissionGroupInfo permissionGroupInfo : it.next().getPermissionGroups()) {
if (!arrayList.contains(permissionGroupInfo)) {
arrayList.add(permissionGroupInfo);
}
}
}
} else {
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
Iterator<PluginPackageParser> it2 = this.mPluginCache.values().iterator();
while (it2.hasNext()) {
for (PermissionGroupInfo permissionGroupInfo2 : it2.next().getPermissionGroups()) {
if (!arrayList.contains(permissionGroupInfo2) && packageNamesByPid.contains(permissionGroupInfo2.packageName)) {
arrayList.add(permissionGroupInfo2);
}
}
}
}
return arrayList;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public ApplicationInfo getApplicationInfo(String str, int i6) {
PluginPackageParser pluginPackageParser;
waitForReadyInner();
try {
if (!TextUtils.equals(str, this.mContext.getPackageName()) && (pluginPackageParser = this.mPluginCache.get(str)) != null) {
return pluginPackageParser.getApplicationInfo(i6);
}
} catch (Exception e6) {
handleException(e6);
}
return null;
}
@Override
public List<ApplicationInfo> getInstalledApplications(int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
ArrayList arrayList = new ArrayList(this.mPluginCache.size());
if (shouldNotBlockOtherInfo()) {
Iterator<PluginPackageParser> it = this.mPluginCache.values().iterator();
while (it.hasNext()) {
arrayList.add(it.next().getApplicationInfo(i6));
}
} else {
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
for (PluginPackageParser pluginPackageParser : this.mPluginCache.values()) {
if (packageNamesByPid.contains(pluginPackageParser.getPackageName())) {
arrayList.add(pluginPackageParser.getApplicationInfo(i6));
}
}
}
return arrayList;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<PackageInfo> getInstalledPackages(int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
ArrayList arrayList = new ArrayList(this.mPluginCache.size());
if (shouldNotBlockOtherInfo()) {
Iterator<PluginPackageParser> it = this.mPluginCache.values().iterator();
while (it.hasNext()) {
arrayList.add(it.next().getPackageInfo(i6));
}
} else {
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
for (PluginPackageParser pluginPackageParser : this.mPluginCache.values()) {
if (packageNamesByPid.contains(pluginPackageParser.getPackageName())) {
arrayList.add(pluginPackageParser.getPackageInfo(i6));
}
}
}
return arrayList;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public int getMyPid() {
return Process.myPid();
}
@Override
public PackageInfo getPackageInfo(String str, int i6) {
waitForReadyInner();
try {
String andCheckCallingPkg = getAndCheckCallingPkg(str);
if (andCheckCallingPkg != null && !TextUtils.equals(str, this.mContext.getPackageName())) {
enforcePluginFileExists();
PluginPackageParser pluginPackageParser = this.mPluginCache.get(andCheckCallingPkg);
if (pluginPackageParser != null) {
PackageInfo packageInfo = pluginPackageParser.getPackageInfo(i6);
if (packageInfo != null && (i6 & 64) != 0 && packageInfo.signatures == null) {
packageInfo.signatures = this.mSignatureCache.get(str);
}
return packageInfo;
}
return null;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<String> getPackageNameByPid(int i6) {
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(i6);
if (packageNamesByPid != null) {
return new ArrayList(packageNamesByPid);
}
return null;
}
@Override
public PermissionGroupInfo getPermissionGroupInfo(String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
Iterator<PluginPackageParser> it = this.mPluginCache.values().iterator();
while (it.hasNext()) {
for (PermissionGroupInfo permissionGroupInfo : it.next().getPermissionGroups()) {
if (TextUtils.equals(permissionGroupInfo.name, str)) {
return permissionGroupInfo;
}
}
}
return null;
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
Iterator<PluginPackageParser> it2 = this.mPluginCache.values().iterator();
while (it2.hasNext()) {
for (PermissionGroupInfo permissionGroupInfo2 : it2.next().getPermissionGroups()) {
if (TextUtils.equals(permissionGroupInfo2.name, str) && packageNamesByPid.contains(permissionGroupInfo2.packageName)) {
return permissionGroupInfo2;
}
}
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public PermissionInfo getPermissionInfo(String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
Iterator<PluginPackageParser> it = this.mPluginCache.values().iterator();
while (it.hasNext()) {
for (PermissionInfo permissionInfo : it.next().getPermissions()) {
if (TextUtils.equals(permissionInfo.name, str)) {
return permissionInfo;
}
}
}
return null;
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
Iterator<PluginPackageParser> it2 = this.mPluginCache.values().iterator();
while (it2.hasNext()) {
for (PermissionInfo permissionInfo2 : it2.next().getPermissions()) {
if (TextUtils.equals(permissionInfo2.name, str) && packageNamesByPid.contains(permissionInfo2.packageName)) {
return permissionInfo2;
}
}
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public String getProcessNameByPid(int i6) {
return this.mActivityManagerService.getProcessNameByPid(i6);
}
@Override
public ProviderInfo getProviderInfo(ComponentName componentName, int i6) {
waitForReadyInner();
try {
if (getAndCheckCallingPkg(componentName.getPackageName()) != null) {
enforcePluginFileExists();
PluginPackageParser pluginPackageParser = this.mPluginCache.get(componentName.getPackageName());
if (pluginPackageParser != null) {
return pluginPackageParser.getProviderInfo(componentName, i6);
}
return null;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public ActivityInfo getReceiverInfo(ComponentName componentName, int i6) {
waitForReadyInner();
try {
if (getAndCheckCallingPkg(componentName.getPackageName()) != null) {
enforcePluginFileExists();
PluginPackageParser pluginPackageParser = this.mPluginCache.get(componentName.getPackageName());
if (pluginPackageParser != null) {
return pluginPackageParser.getReceiverInfo(componentName, i6);
}
return null;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<IntentFilter> getReceiverIntentFilter(ActivityInfo activityInfo) {
PluginPackageParser pluginPackageParser;
List<IntentFilter> receiverIntentFilter;
try {
if (getAndCheckCallingPkg(activityInfo.packageName) != null && (pluginPackageParser = this.mPluginCache.get(activityInfo.packageName)) != null && (receiverIntentFilter = pluginPackageParser.getReceiverIntentFilter(activityInfo)) != null && receiverIntentFilter.size() > 0) {
return new ArrayList(receiverIntentFilter);
}
return new ArrayList(0);
} catch (Exception e6) {
RemoteException remoteException = new RemoteException();
remoteException.setStackTrace(e6.getStackTrace());
throw remoteException;
}
}
@Override
public List<ActivityInfo> getReceivers(String str, int i6) {
PluginPackageParser pluginPackageParser;
try {
if (getAndCheckCallingPkg(str) != null && (pluginPackageParser = this.mPluginCache.get(str)) != null) {
return new ArrayList(pluginPackageParser.getReceivers());
}
return new ArrayList(0);
} catch (Exception e6) {
RemoteException remoteException = new RemoteException();
remoteException.setStackTrace(e6.getStackTrace());
throw remoteException;
}
}
@Override
public ServiceInfo getServiceInfo(ComponentName componentName, int i6) {
waitForReadyInner();
try {
if (getAndCheckCallingPkg(componentName.getPackageName()) != null) {
enforcePluginFileExists();
PluginPackageParser pluginPackageParser = this.mPluginCache.get(componentName.getPackageName());
if (pluginPackageParser != null) {
return pluginPackageParser.getServiceInfo(componentName, i6);
}
return null;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public ServiceInfo getTargetServiceInfo(ServiceInfo serviceInfo) {
return this.mActivityManagerService.getTargetServiceInfo(Binder.getCallingPid(), Binder.getCallingUid(), serviceInfo);
}
@Override
public int installPackage(String str, int i6) {
String[] strArr;
boolean z6;
String[] strArr2;
boolean z7;
String str2 = null;
try {
PackageManager packageManager = this.mContext.getPackageManager();
PackageInfo packageArchiveInfo = packageManager.getPackageArchiveInfo(str, 0);
if (packageArchiveInfo == null) {
return -2;
}
String pluginApkFile = PluginDirHelper.getPluginApkFile(this.mContext, packageArchiveInfo.packageName);
try {
if ((i6 & 2) != 0) {
forceStopPackage(packageArchiveInfo.packageName);
if (this.mPluginCache.containsKey(packageArchiveInfo.packageName)) {
deleteApplicationCacheFiles(packageArchiveInfo.packageName, null);
}
new File(pluginApkFile).delete();
Utils.copyFile(str, pluginApkFile);
PluginPackageParser pluginPackageParser = new PluginPackageParser(this.mContext, new File(pluginApkFile));
pluginPackageParser.collectCertificates(0);
PackageInfo packageInfo = pluginPackageParser.getPackageInfo(4160);
if (packageInfo != null && (strArr2 = packageInfo.requestedPermissions) != null && strArr2.length > 0) {
for (String str3 : strArr2) {
if (packageManager.getPermissionInfo(str3, 0) != null) {
z7 = true;
if (this.mHostRequestedPermission.contains(str3) && z7) {
Log.e(TAG, "No Permission %s", str3);
new File(pluginApkFile).delete();
return PluginManager.INSTALL_FAILED_NO_REQUESTEDPERMISSION;
}
}
z7 = false;
if (this.mHostRequestedPermission.contains(str3)) {
}
}
}
saveSignatures(packageInfo);
copyNativeLibs(this.mContext, pluginApkFile, pluginPackageParser.getApplicationInfo(0));
dexOpt(this.mContext, pluginApkFile, pluginPackageParser);
this.mPluginCache.put(pluginPackageParser.getPackageName(), pluginPackageParser);
this.mActivityManagerService.onPkgInstalled(this.mPluginCache, pluginPackageParser, pluginPackageParser.getPackageName());
sendInstalledBroadcast(packageArchiveInfo.packageName);
return 1;
}
if (this.mPluginCache.containsKey(packageArchiveInfo.packageName)) {
return -1;
}
forceStopPackage(packageArchiveInfo.packageName);
new File(pluginApkFile).delete();
Utils.copyFile(str, pluginApkFile);
PluginPackageParser pluginPackageParser2 = new PluginPackageParser(this.mContext, new File(pluginApkFile));
pluginPackageParser2.collectCertificates(0);
PackageInfo packageInfo2 = pluginPackageParser2.getPackageInfo(4160);
if (packageInfo2 != null && (strArr = packageInfo2.requestedPermissions) != null && strArr.length > 0) {
for (String str4 : strArr) {
if (packageManager.getPermissionInfo(str4, 0) != null) {
z6 = true;
if (this.mHostRequestedPermission.contains(str4) && z6) {
Log.e(TAG, "No Permission %s", str4);
new File(pluginApkFile).delete();
return PluginManager.INSTALL_FAILED_NO_REQUESTEDPERMISSION;
}
}
z6 = false;
if (this.mHostRequestedPermission.contains(str4)) {
}
}
}
saveSignatures(packageInfo2);
copyNativeLibs(this.mContext, pluginApkFile, pluginPackageParser2.getApplicationInfo(0));
dexOpt(this.mContext, pluginApkFile, pluginPackageParser2);
this.mPluginCache.put(pluginPackageParser2.getPackageName(), pluginPackageParser2);
this.mActivityManagerService.onPkgInstalled(this.mPluginCache, pluginPackageParser2, pluginPackageParser2.getPackageName());
sendInstalledBroadcast(packageArchiveInfo.packageName);
return 1;
} catch (Exception e6) {
e = e6;
str2 = pluginApkFile;
if (str2 != null) {
new File(str2).delete();
}
handleException(e);
return PackageManagerCompat.INSTALL_FAILED_INTERNAL_ERROR;
}
} catch (Exception e7) {
e = e7;
}
}
@Override
public boolean isPluginPackage(String str) {
waitForReadyInner();
enforcePluginFileExists();
return this.mPluginCache.containsKey(str);
}
@Override
public boolean killApplicationProcess(String str) {
return killBackgroundProcesses(str);
}
@Override
public boolean killBackgroundProcesses(String str) {
boolean z6 = false;
for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : ((ActivityManager) this.mContext.getSystemService("activity")).getRunningAppProcesses()) {
String[] strArr = runningAppProcessInfo.pkgList;
if (strArr != null) {
String[] strArr2 = (String[]) Arrays.copyOf(strArr, strArr.length);
Arrays.sort(strArr2);
if (Arrays.binarySearch(strArr2, str) >= 0 && runningAppProcessInfo.pid != Process.myPid()) {
Log.i(TAG, "killBackgroundProcesses(%s),pkgList=%s,pid=%s", str, Arrays.toString(runningAppProcessInfo.pkgList), Integer.valueOf(runningAppProcessInfo.pid));
Process.killProcess(runningAppProcessInfo.pid);
z6 = true;
}
}
}
return z6;
}
@Override
public void onActivityCreated(ActivityInfo activityInfo, ActivityInfo activityInfo2) {
this.mActivityManagerService.onActivityCreated(Binder.getCallingPid(), Binder.getCallingUid(), activityInfo, activityInfo2);
}
@Override
public void onActivityDestory(ActivityInfo activityInfo, ActivityInfo activityInfo2) {
this.mActivityManagerService.onActivityDestory(Binder.getCallingPid(), Binder.getCallingUid(), activityInfo, activityInfo2);
}
@Override
public void onActivtyOnNewIntent(ActivityInfo activityInfo, ActivityInfo activityInfo2, Intent intent) {
this.mActivityManagerService.onActivtyOnNewIntent(Binder.getCallingPid(), Binder.getCallingUid(), activityInfo, activityInfo2, intent);
}
public void onCreate() {
new Thread() {
@Override
public void run() {
IPluginManagerImpl.this.onCreateInner();
}
}.start();
}
public void onDestroy() {
this.mActivityManagerService.onDestory();
}
@Override
public void onProviderCreated(ProviderInfo providerInfo, ProviderInfo providerInfo2) {
this.mActivityManagerService.onProviderCreated(Binder.getCallingPid(), Binder.getCallingUid(), providerInfo, providerInfo2);
}
@Override
public void onServiceCreated(ServiceInfo serviceInfo, ServiceInfo serviceInfo2) {
this.mActivityManagerService.onServiceCreated(Binder.getCallingPid(), Binder.getCallingUid(), serviceInfo, serviceInfo2);
}
@Override
public void onServiceDestory(ServiceInfo serviceInfo, ServiceInfo serviceInfo2) {
this.mActivityManagerService.onServiceDestory(Binder.getCallingPid(), Binder.getCallingUid(), serviceInfo, serviceInfo2);
}
@Override
public List<ResolveInfo> queryIntentActivities(Intent intent, String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
return IntentMatcher.resolveActivityIntent(this.mContext, this.mPluginCache, intent, str, i6);
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
ArrayList arrayList = new ArrayList();
Iterator<String> it = packageNamesByPid.iterator();
while (it.hasNext()) {
intent.setPackage(it.next());
arrayList.addAll(IntentMatcher.resolveActivityIntent(this.mContext, this.mPluginCache, intent, str, i6));
}
if (arrayList.size() > 0) {
return arrayList;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<ResolveInfo> queryIntentContentProviders(Intent intent, String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
return IntentMatcher.resolveProviderIntent(this.mContext, this.mPluginCache, intent, str, i6);
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
ArrayList arrayList = new ArrayList();
Iterator<String> it = packageNamesByPid.iterator();
while (it.hasNext()) {
intent.setPackage(it.next());
arrayList.addAll(IntentMatcher.resolveProviderIntent(this.mContext, this.mPluginCache, intent, str, i6));
}
if (arrayList.size() > 0) {
return arrayList;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<ResolveInfo> queryIntentReceivers(Intent intent, String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
return IntentMatcher.resolveReceiverIntent(this.mContext, this.mPluginCache, intent, str, i6);
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
ArrayList arrayList = new ArrayList();
Iterator<String> it = packageNamesByPid.iterator();
while (it.hasNext()) {
intent.setPackage(it.next());
arrayList.addAll(IntentMatcher.resolveReceiverIntent(this.mContext, this.mPluginCache, intent, str, i6));
}
if (arrayList.size() > 0) {
return arrayList;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<ResolveInfo> queryIntentServices(Intent intent, String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
return IntentMatcher.resolveServiceIntent(this.mContext, this.mPluginCache, intent, str, i6);
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
ArrayList arrayList = new ArrayList();
Iterator<String> it = packageNamesByPid.iterator();
while (it.hasNext()) {
intent.setPackage(it.next());
arrayList.addAll(IntentMatcher.resolveServiceIntent(this.mContext, this.mPluginCache, intent, str, i6));
}
if (arrayList.size() > 0) {
return arrayList;
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public List<PermissionInfo> queryPermissionsByGroup(String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
ArrayList arrayList = new ArrayList();
if (shouldNotBlockOtherInfo()) {
Iterator<PluginPackageParser> it = this.mPluginCache.values().iterator();
while (it.hasNext()) {
for (PermissionInfo permissionInfo : it.next().getPermissions()) {
if (TextUtils.equals(permissionInfo.group, str) && !arrayList.contains(permissionInfo)) {
arrayList.add(permissionInfo);
}
}
}
} else {
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
Iterator<PluginPackageParser> it2 = this.mPluginCache.values().iterator();
while (it2.hasNext()) {
for (PermissionInfo permissionInfo2 : it2.next().getPermissions()) {
if (packageNamesByPid.contains(permissionInfo2.packageName) && TextUtils.equals(permissionInfo2.group, str) && !arrayList.contains(permissionInfo2)) {
arrayList.add(permissionInfo2);
}
}
}
}
return arrayList;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public boolean registerApplicationCallback(IApplicationCallback iApplicationCallback) {
return this.mActivityManagerService.registerApplicationCallback(Binder.getCallingPid(), Binder.getCallingUid(), iApplicationCallback);
}
@Override
public void reportMyProcessName(String str, String str2, String str3) {
this.mActivityManagerService.onReportMyProcessName(Binder.getCallingPid(), Binder.getCallingUid(), str, str2, str3);
}
@Override
public ProviderInfo resolveContentProvider(String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
Iterator<PluginPackageParser> it = this.mPluginCache.values().iterator();
while (it.hasNext()) {
for (ProviderInfo providerInfo : it.next().getProviders()) {
if (TextUtils.equals(providerInfo.authority, str)) {
return providerInfo;
}
}
}
return null;
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
Iterator<PluginPackageParser> it2 = this.mPluginCache.values().iterator();
while (it2.hasNext()) {
for (ProviderInfo providerInfo2 : it2.next().getProviders()) {
if (TextUtils.equals(providerInfo2.authority, str) && packageNamesByPid.contains(providerInfo2.packageName)) {
return providerInfo2;
}
}
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public ResolveInfo resolveIntent(Intent intent, String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
List<ResolveInfo> resolveIntent = IntentMatcher.resolveIntent(this.mContext, this.mPluginCache, intent, str, i6);
if (resolveIntent != null && resolveIntent.size() > 0) {
return IntentMatcher.findBest(resolveIntent);
}
return null;
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
ArrayList arrayList = new ArrayList();
Iterator<String> it = packageNamesByPid.iterator();
while (it.hasNext()) {
intent.setPackage(it.next());
arrayList.addAll(IntentMatcher.resolveIntent(this.mContext, this.mPluginCache, intent, str, i6));
}
if (arrayList.size() > 0) {
return IntentMatcher.findBest(arrayList);
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public ResolveInfo resolveService(Intent intent, String str, int i6) {
waitForReadyInner();
try {
enforcePluginFileExists();
if (shouldNotBlockOtherInfo()) {
List<ResolveInfo> resolveServiceIntent = IntentMatcher.resolveServiceIntent(this.mContext, this.mPluginCache, intent, str, i6);
if (resolveServiceIntent != null && resolveServiceIntent.size() > 0) {
return IntentMatcher.findBest(resolveServiceIntent);
}
return null;
}
List<String> packageNamesByPid = this.mActivityManagerService.getPackageNamesByPid(Binder.getCallingPid());
ArrayList arrayList = new ArrayList();
Iterator<String> it = packageNamesByPid.iterator();
while (it.hasNext()) {
intent.setPackage(it.next());
arrayList.addAll(IntentMatcher.resolveServiceIntent(this.mContext, this.mPluginCache, intent, str, i6));
}
if (arrayList.size() > 0) {
return IntentMatcher.findBest(arrayList);
}
return null;
} catch (Exception e6) {
handleException(e6);
return null;
}
}
@Override
public ActivityInfo selectStubActivityInfo(ActivityInfo activityInfo) {
return this.mActivityManagerService.selectStubActivityInfo(Binder.getCallingPid(), Binder.getCallingUid(), activityInfo);
}
@Override
public ActivityInfo selectStubActivityInfoByIntent(Intent intent) {
ActivityInfo activityInfo;
if (intent.getComponent() != null) {
activityInfo = getActivityInfo(intent.getComponent(), 0);
} else {
ResolveInfo resolveIntent = resolveIntent(intent, intent.resolveTypeIfNeeded(this.mContext.getContentResolver()), 0);
if (resolveIntent == null || (activityInfo = resolveIntent.activityInfo) == null) {
activityInfo = null;
}
}
if (activityInfo == null) {
return null;
}
return selectStubActivityInfo(activityInfo);
}
@Override
public ProviderInfo selectStubProviderInfo(String str) {
return this.mActivityManagerService.selectStubProviderInfo(Binder.getCallingPid(), Binder.getCallingUid(), resolveContentProvider(str, 0));
}
@Override
public ServiceInfo selectStubServiceInfo(ServiceInfo serviceInfo) {
return this.mActivityManagerService.selectStubServiceInfo(Binder.getCallingPid(), Binder.getCallingUid(), serviceInfo);
}
@Override
public ServiceInfo selectStubServiceInfoByIntent(Intent intent) {
ServiceInfo serviceInfo;
if (intent.getComponent() != null) {
serviceInfo = getServiceInfo(intent.getComponent(), 0);
} else {
serviceInfo = resolveIntent(intent, intent.resolveTypeIfNeeded(this.mContext.getContentResolver()), 0).serviceInfo;
if (serviceInfo == null) {
serviceInfo = null;
}
}
if (serviceInfo == null) {
return null;
}
return selectStubServiceInfo(serviceInfo);
}
@Override
public boolean unregisterApplicationCallback(IApplicationCallback iApplicationCallback) {
return this.mActivityManagerService.unregisterApplicationCallback(Binder.getCallingPid(), Binder.getCallingUid(), iApplicationCallback);
}
@Override
public boolean waitForReady() {
waitForReadyInner();
return true;
}
}