插件化原理(三)宿主中启动插件的四大组件原理、宿主与插件资源的共享实现原理
插件化原理
一、启动插件Activity原理
1、Activity启动过程
1) ●ActivityManagerProxy是AMS在app进程的Binder代理，ActivityManagerNative是对该Binder代理的操作工具类
●IApplicationThread是应用启动时调用AMS.attachApplication(IApplicationThread thread)传到AMS进程的app进程的Binder代理。
ApplicationThreadNative是IApplicationThread的实现，ApplicationThread是对ApplicationThreadNative的封装
2) 启动activity会先把要启动的activity信息通过ActivityManagerProxy传给AMS
3) AMS会对要启动的activity检查，包括检查activity是否在Manifest中注册
4) AMS检查完后会通过app进程的Binder代理ApplicationThreadNative把activity传回到app进程
5) ApplicationThread中会通过ActivityThread.mH这个Handler把要启动的activity传到app进程的主线程
6) Handler.dispatchMessage(msg)中如果mCallback非空，会走mCallback.handleMessage(msg)
7) app主线程中通过 Instrumentation来真正启动activity
2、启动插件Activity要做的事
1)绕过AMS对启动activity是否在Manifest中注册的检查
Hook掉ActivityManagerProxy，修改内部一些方法，startActivity()，把启动的activity替换成提前在Manifest中注册的代理activity
这样AMS检查的实际上就是这个代理activity；
2)AMS检查完后，把启动的activity还原回目标activity
方法一：Hook掉ActivityThread.mH，给mH这个handler的mCallback传值，这样会走mCallback中逻辑，在mCallback中把代理activity替换回要启动的activity
方法二：Hook掉ActivityThread.mInstrumentation，替换成自定义的代理Instrumentation，代理Instrumentation.newActivity()中把代理activity替换成要启动的activity
二、启动插件Service原理
1、在宿主中注册两个代理Service，一个LocalService，一个RemoteService(跨进程服务)
2、反射调用PackageParser解析插件apk，获取注册的所有Service
3、Hook掉ActivityManagerProxy，由于Service启动与Activity类似，都要通过AMS启动，所以修改ActivityManagerProxy的startService（）、bindService()等启动服务的方法，实际启动的是宿主中注册的代理Service，然后把插件Service信息作为intent参数传入，启动代理Service后，取出intent中的插件Service信息，通过代理Service的生命周期驱动插件Service调用对应的方法，从而实现插件Service的功能。
三、启动插件BroadcastReceiver原理
反射调用PackageParser解析插件apk，获取到静态注册的广播，然后通过宿主的context对象动态注册这些receiver
四、启动插件ContentProvider原理
1、在宿主中注册一个跨进程代理ContentProvider，authorities为固定值
2、Hook获取ActivityThread.mProviderMap，mProviderMap中key保存了authority，value保存了authority对应的ContentProvider
3、反射调用PackageParser解析插件apk，获取注册的所有ContentProvider
4、通过代理ContentProvider的生命周期驱动插件的ContentProvider对应的方法
五、插件与宿主资源的处理【这是我认为插件化真正难的地方】
1、所有Resources对象的替换
1)保存宿主已经加载的资源路径，hook AssetManager.destroy()删除已加载的资源，再把宿主资源、插件资源全部添加到宿主的AssetManager.addAssetPath()
hook AssetManager.init()重新初始化宿主的assetManager、重新构造assetManager.mStringBlocks、把宿主和插件资源添加到assetManager、重新构造ensureStringBlocks
hostResources.updateConfiguration(…)
这样插件与宿主就共用了同一个AssetManager，该AssetManager可以访问宿主与插件的所有资源
2、宿主工程gradle脚本
1)获取宿主编译生成的R.txt文件，备份，插件编译时要用
3、插件工程gradle脚本
1)获取宿主编译后输出的R.txt
2)插件打包时通过gradle脚本遍历宿主R.txt与插件资源，插件与宿主重名的同类型资源用插件资源替换宿主资源
3)把插件资源id放到public.xml中，使插件再次编译时id保持不变，这样插件升级时不会出现id找不到的问题
4)插件编译过程中，获取该插件的所有资源，包括插件使用的aar引用的资源
5)读取插件的resource.arsc文件，根据该文件的结构读取，然后把前面四步处理过的资源信息按该文件规则写入
六、插件源码加入宿主
1、反射通过PackageParser.parsePackage()解析插件apk
2、创建DexClassLoader加载插件apk，获取插件的dex文件
3、反射获取宿主dalvik.system.BaseDexClassLoader的pathList、dexElements
4、把插件dexClassLoader加载的dex跟宿主进程的ClassLoader加载的dex合并在一起，都放入宿主进程的ClassLoader.pathList.dexElements中
5、合并宿主与插件的nativeLib：PathClassLoader.pathList.nativeLibraryDirectories、nativeLibraryPathElements
插件管理，AMS hook欺上瞒下的实现
public class PluginManager {
public static final String TAG = "PluginManager";
private static volatile PluginManager sInstance = null;
// Context of host app
private Context mContext;
private ComponentsHandler mComponentsHandler;
private Map<String, LoadedPlugin> mPlugins = new ConcurrentHashMap<>();
private final List<Callback> mCallbacks = new ArrayList<>();
//VAInstrumentation，宿主ActivityThread.mInstrument的静态代理
private Instrumentation mInstrumentation; // Hooked instrumentation
//把AMS在宿主进程的代理ActivityManagerProxy替换成动态代理生成的假体，mActivityManager就是假体的引用，从此宿主进程通过AMS代理做的事情都由假体执行了
private IActivityManager mActivityManager; // Hooked IActivityManager binder
private IContentProvider mIContentProvider; // Hooked IContentProvider binder
public static PluginManager getInstance(Context base) {
if (sInstance == null) {
synchronized (PluginManager.class) {
if (sInstance == null)
sInstance = new PluginManager(base);
}
}
return sInstance;
}
private PluginManager(Context context) {//传入宿主进程的Context对象
Context app = context.getApplicationContext();
if (app == null) {
this.mContext = context;
} else {
this.mContext = ((Application)app).getBaseContext();
}
prepare();
}
private void prepare() {
Systems.sHostContext = getHostContext();//保存宿主Context引用
//这一步就完成了欺骗AMS，欺上和瞒下
this.hookInstrumentationAndHandler();//hook ActivityThread.mInstrument、ActivityThread.mH.mCallback
//hook AMS在宿主进程的代理ActivityManagerProxy，替换成动态代理生成的假体
this.hookSystemServices();
//hook掉官方提供的数据绑定框架DataBinding的sMapper，替换为自己实现的 DataBinderMapperProxy
hookDataBindingUtil();
}
public void init() {
mComponentsHandler = new ComponentsHandler(this);
RunUtil.getThreadPool().execute(new Runnable() {
@Override
public void run() {
doInWorkThread();
}
});
}
private void doInWorkThread() {
}
private void hookDataBindingUtil() {
try {
Class cls = Class.forName("android.databinding.DataBindingUtil");
Object old = ReflectUtil.getField(cls, null, "sMapper");
Callback callback = new DataBinderMapperProxy(old);
ReflectUtil.setField(cls, null, "sMapper", callback);
addCallback(callback);
} catch (Exception e) {
e.printStackTrace();
}
}
public void addCallback(Callback callback) {
if (callback == null) {
return;
}
synchronized (mCallbacks) {
mCallbacks.add(callback);
}
}
/**
* hook的是AMS在宿主进程的代理，在PluginManager中保存该代理的引用
* hookSystemServices, but need to compatible with Android O in future.
*/
private void hookSystemServices() {
try {
Singleton<IActivityManager> defaultSingleton;
//拿到AMS在宿主进程的代理
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManager.class, null, "IActivityManagerSingleton");
} else {
defaultSingleton = (Singleton<IActivityManager>) ReflectUtil.getField(ActivityManagerNative.class, null, "gDefault");
}
//activityManagerProxy实际类型是 ActivityManagerProxy
//根据宿主进程的ActivityManagerProxy对象生成动态代理，返回的是代理对象
IActivityManager activityManagerProxy = ActivityManagerProxy.newInstance(this, defaultSingleton.get());
//把宿主进程的ActivityManagerProxy替换成上面生成的代理对象，此后宿主进程通过AMS对四大组件的操作，都由上面生成的这个代理来真正执行了
// Hook IActivityManager from ActivityManagerNative
ReflectUtil.setField(defaultSingleton.getClass().getSuperclass(), defaultSingleton, "mInstance", activityManagerProxy);
if (defaultSingleton.get() == activityManagerProxy) {//表示hook成功了
this.mActivityManager = activityManagerProxy;
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* hook ActivityThread.mInstrumentation和ActivityThread.mH.mCallback
* 有代理来执行，实现欺上瞒下
* 原理：在AMS中会对启动的activity做检查，包括在Manifest中是否注册等信息；
* 这里是在AMS检查之前，用一个正常的代理StubActivity代替要启动的TargetActivity接受AMS的检查过程；
* 等检查完成后在ActivityThread中启动Activity之前又用TargetActivity把检查通过的StubActivity替换，
* 这样AMS检查的是StubActivity，而最终启动的是TargetActivity
*/
private void hookInstrumentationAndHandler() {
try {//获取宿主进程ActivityThread.mInstrumentation
Instrumentation baseInstrumentation = ReflectUtil.getInstrumentation(this.mContext);
if (baseInstrumentation.getClass().getName().contains("lbe")) {
// reject executing in paralell space, for example, lbe.
System.exit(0);
}
/* VAInstrumentation继承自系统的Instrumentation类，包装了宿主进程的mInstrumentation和PluginManager，
* 算是Instrumentation的静态代理类
* VAInstrumentation同时实现了Handler.Callback接口，用来替换ActivityThread.mH的mCallback
*/
final VAInstrumentation instrumentation = new VAInstrumentation(this, baseInstrumentation);
Object activityThread = ReflectUtil.getActivityThread(this.mContext);//获取宿主进程ActivityThread
ReflectUtil.setInstrumentation(activityThread, instrumentation);//替换宿主进程ActivityThread.mInstrumentation对象为代理VAInstrumentation
ReflectUtil.setHandlerCallback(this.mContext, instrumentation);//替换宿主进程ActivityThread.mH 该Handler的mCallback为VAInstrumentation
this.mInstrumentation = instrumentation;
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 首先定义了个RemoteContentProvider作为所有ContentProvider的代理，在该Provider中会根据传入的Uri创建对应的真正要调用的
* ContentProvider并缓存到Map，方便下次用从缓存取；所有ContentProvider都通过RemoteContentProvider来调用；
* 这里遍历ActivityThread.mProviderMap，把找到 RemoteContentProvider，...
*/
private void hookIContentProviderAsNeeded() {
Uri uri = Uri.parse(PluginContentResolver.getUri(mContext));
mContext.getContentResolver().call(uri, "wakeup", null, null);
try {
Field authority = null;
Field mProvider = null;
ActivityThread activityThread = (ActivityThread) ReflectUtil.getActivityThread(mContext);
Map mProviderMap = (Map) ReflectUtil.getField(activityThread.getClass(), activityThread, "mProviderMap");
Iterator iter = mProviderMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = (Map.Entry) iter.next();
Object key = entry.getKey();
Object val = entry.getValue();
String auth;
if (key instanceof String) {
auth = (String) key;
} else {
if (authority == null) {
authority = key.getClass().getDeclaredField("authority");
authority.setAccessible(true);
}
auth = (String) authority.get(key);
}
if (auth.equals(PluginContentResolver.getAuthority(mContext))) {
if (mProvider == null) {
mProvider = val.getClass().getDeclaredField("mProvider");
mProvider.setAccessible(true);
}
IContentProvider rawProvider = (IContentProvider) mProvider.get(val);
IContentProvider proxy = IContentProviderProxy.newInstance(mContext, rawProvider);
mIContentProvider = proxy;
Log.d(TAG, "hookIContentProvider succeed : " + mIContentProvider);
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 插件的加载，具体逻辑在 LoadedPlugin 类中
* load a plugin into memory, then invoke it's Application.
* @param apk the file of plugin, should end with .apk
* @throws Exception
*/
public void loadPlugin(File apk) throws Exception {
if (null == apk) {
throw new IllegalArgumentException("error : apk is null.");
}
if (!apk.exists()) {
throw new FileNotFoundException(apk.getAbsolutePath());
}
LoadedPlugin plugin = LoadedPlugin.create(this, this.mContext, apk);
if (null != plugin) {
this.mPlugins.put(plugin.getPackageName(), plugin);
synchronized (mCallbacks) {
for (int i = 0; i < mCallbacks.size(); i++) {
mCallbacks.get(i).onAddedLoadedPlugin(plugin);
}
}
// try to invoke plugin's application
plugin.invokeApplication();
} else {
throw new RuntimeException("Can't load plugin which is invalid: " + apk.getAbsolutePath());
}
}
public LoadedPlugin getLoadedPlugin(Intent intent) {
ComponentName component = PluginUtil.getComponent(intent);
return getLoadedPlugin(component.getPackageName());
}
public LoadedPlugin getLoadedPlugin(ComponentName component) {
return this.getLoadedPlugin(component.getPackageName());
}
public LoadedPlugin getLoadedPlugin(String packageName) {
return this.mPlugins.get(packageName);
}
public List<LoadedPlugin> getAllLoadedPlugins() {
List<LoadedPlugin> list = new ArrayList<>();
list.addAll(mPlugins.values());
return list;
}
public Context getHostContext() {
return this.mContext;
}
public Instrumentation getInstrumentation() {
return this.mInstrumentation;
}
public IActivityManager getActivityManager() {
return this.mActivityManager;
}
public synchronized IContentProvider getIContentProvider() {
if (mIContentProvider == null) {
hookIContentProviderAsNeeded();
}
return mIContentProvider;
}
public ComponentsHandler getComponentsHandler() {
return mComponentsHandler;
}
public ResolveInfo resolveActivity(Intent intent) {
return this.resolveActivity(intent, 0);
}
public ResolveInfo resolveActivity(Intent intent, int flags) {
for (LoadedPlugin plugin : this.mPlugins.values()) {
ResolveInfo resolveInfo = plugin.resolveActivity(intent, flags);
if (null != resolveInfo) {
return resolveInfo;
}
}
return null;
}
public ResolveInfo resolveService(Intent intent, int flags) {
for (LoadedPlugin plugin : this.mPlugins.values()) {
ResolveInfo resolveInfo = plugin.resolveService(intent, flags);
if (null != resolveInfo) {
return resolveInfo;
}
}
return null;
}
public ProviderInfo resolveContentProvider(String name, int flags) {
for (LoadedPlugin plugin : this.mPlugins.values()) {
ProviderInfo providerInfo = plugin.resolveContentProvider(name, flags);
if (null != providerInfo) {
return providerInfo;
}
}
return null;
}
/**
* used in PluginPackageManager, do not invoke it from outside.
*/
@Deprecated
public List<ResolveInfo> queryIntentActivities(Intent intent, int flags) {
List<ResolveInfo> resolveInfos = new ArrayList<ResolveInfo>();
for (LoadedPlugin plugin : this.mPlugins.values()) {
List<ResolveInfo> result = plugin.queryIntentActivities(intent, flags);
if (null != result && result.size() > 0) {
resolveInfos.addAll(result);
}
}
return resolveInfos;
}
/**
* used in PluginPackageManager, do not invoke it from outside.
*/
@Deprecated
public List<ResolveInfo> queryIntentServices(Intent intent, int flags) {
List<ResolveInfo> resolveInfos = new ArrayList<ResolveInfo>();
for (LoadedPlugin plugin : this.mPlugins.values()) {
List<ResolveInfo> result = plugin.queryIntentServices(intent, flags);
if (null != result && result.size() > 0) {
resolveInfos.addAll(result);
}
}
return resolveInfos;
}
/**
* used in PluginPackageManager, do not invoke it from outside.
*/
@Deprecated
public List<ResolveInfo> queryBroadcastReceivers(Intent intent, int flags) {
List<ResolveInfo> resolveInfos = new ArrayList<ResolveInfo>();
for (LoadedPlugin plugin : this.mPlugins.values()) {
List<ResolveInfo> result = plugin.queryBroadcastReceivers(intent, flags);
if (null != result && result.size() > 0) {
resolveInfos.addAll(result);
}
}
return resolveInfos;
}
public interface Callback {
void onAddedLoadedPlugin(LoadedPlugin plugin);
}
}插件加载
/**
* 1、AndroidStub中定义的那些跟系统api相同的方法，是为了避免编译报错而添加的，实际上并不会调用
* 由于那些系统类都是public的，其实是可以调用的，只是因为加了@hide 而无法被引用到而已，编译通过后，运行时可以调用到。
* Created by renyugang on 16/8/9.
*/
public final class LoadedPlugin {
public static final String TAG = "LoadedPlugin";
public static LoadedPlugin create(PluginManager pluginManager, Context host, File apk) throws Exception {
return new LoadedPlugin(pluginManager, host, apk);
}
/**
*
* @param context
* @param apk
* @param libsDir 插件apk解析后存放nativeLib的目录
* @param parent
* @return
*/
private static ClassLoader createClassLoader(Context context, File apk, File libsDir, ClassLoader parent) {
File dexOutputDir = context.getDir(Constants.OPTIMIZE_DIR, Context.MODE_PRIVATE);//插件dex解析后输出目录
String dexOutputPath = dexOutputDir.getAbsolutePath();
/*
* DexClassLoader构造器的参数
* 参数一： jar/apk中包含的类或资源，多个有/分隔
* 参数二： apk解析后，dex文件输出目录
* 参数三： 包含本地库的目录，多个用/分隔，可为空
* 参数四： 加载器的父类
*/
DexClassLoader loader = new DexClassLoader(apk.getAbsolutePath(), dexOutputPath, libsDir.getAbsolutePath(), parent);
if (Constants.COMBINE_CLASSLOADER) {//如果宿主与插件共用一个classloader（默认）
try {
DexUtil.insertDex(loader);
} catch (Exception e) {
e.printStackTrace();
}
}
return loader;
}
private static AssetManager createAssetManager(Context context, File apk) {
try {
AssetManager am = AssetManager.class.newInstance();//通过class创建AssetManager实例
//调用实例的 addAssetPath 方法，把apk路径添加；addAssetPath 方法该方法内部调用了native方法
ReflectUtil.invoke(AssetManager.class, am, "addAssetPath", apk.getAbsolutePath());
return am;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@WorkerThread
private static Resources createResources(Context context, File apk) {
if (Constants.COMBINE_RESOURCES) {//合并资源，VirtualApp默认是合并资源
//创建一个新的resources，宿主与插件共用，内部包含了宿主和插件的apk/资源路径
// Resources resources = ResourcesManager.createResources(context, apk.getAbsolutePath());
Resources resources = ResourcesManager.createResources2(context, apk.getAbsolutePath());
//把宿主进程所有用到resources的地方，全部替换成上面新建的resources
ResourcesManager.hookResources(context, resources);
return resources;
} else {//不合并资源
Resources hostResources = context.getResources();
//反射创建一个AssetManager对象，反射调用 addAssetPath 方法该方法内部调用了native方法，把apk文件目录添加
AssetManager assetManager = createAssetManager(context, apk);
//通过传入新创建的AssetManager和宿主hostResources的一些参数，创建一个新的Resources对象，该Resources对象是该插件专用的
return new Resources(assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration());
}
}
private static ResolveInfo chooseBestActivity(Intent intent, String s, int flags, List<ResolveInfo> query) {
return query.get(0);
}
private final String mLocation;
private PluginManager mPluginManager;
private Context mHostContext;
private Context mPluginContext;
private final File mNativeLibDir;//插件apk解析后存放nativeLib的目录
private final PackageParser.Package mPackage;
private final PackageInfo mPackageInfo;
private Resources mResources;
private ClassLoader mClassLoader;
private PluginPackageManager mPackageManager;
private Map<ComponentName, ActivityInfo> mActivityInfos;
private Map<ComponentName, ServiceInfo> mServiceInfos;
private Map<ComponentName, ActivityInfo> mReceiverInfos;
private Map<ComponentName, ProviderInfo> mProviderInfos;
private Map<String, ProviderInfo> mProviders; // key is authorities of provider
private Map<ComponentName, InstrumentationInfo> mInstrumentationInfos;
private Application mApplication;
LoadedPlugin(PluginManager pluginManager, Context context, File apk) throws Exception {
this.mPluginManager = pluginManager;
this.mHostContext = context;
this.mLocation = apk.getAbsolutePath();
this.mPackage = PackageParserCompat.parsePackage(context, apk, PackageParser.PARSE_MUST_BE_APK);
this.mPackage.applicationInfo.metaData = this.mPackage.mAppMetaData;
this.mPackageInfo = new PackageInfo();
this.mPackageInfo.applicationInfo = this.mPackage.applicationInfo;
this.mPackageInfo.applicationInfo.sourceDir = apk.getAbsolutePath();
if (Build.VERSION.SDK_INT == 27 && Build.VERSION.PREVIEW_SDK_INT != 0) { // Android P Preview
this.mPackageInfo.signatures = this.mPackage.mSigningDetails.signatures;
} else {
this.mPackageInfo.signatures = this.mPackage.mSignatures;
}
this.mPackageInfo.packageName = this.mPackage.packageName;
if (pluginManager.getLoadedPlugin(mPackageInfo.packageName) != null) {
throw new RuntimeException("plugin has already been loaded : " + mPackageInfo.packageName);
}
this.mPackageInfo.versionCode = this.mPackage.mVersionCode;
this.mPackageInfo.versionName = this.mPackage.mVersionName;
this.mPackageInfo.permissions = new PermissionInfo[0];
this.mPackageManager = new PluginPackageManager();
this.mPluginContext = new PluginContext(this);
//插件apk解析后存放nativeLib的目录
this.mNativeLibDir = context.getDir(Constants.NATIVE_DIR, Context.MODE_PRIVATE);
//合并宿主资源，共用一个Resources，这样插件与宿主之间资源可以互相调用
//创建新的resources，两种模式，一种是宿主与所有插件共用一个resources（默认），然后把宿主进程用到的resources全部替换为新建的resources、另一种是宿主与插件各自用各自的resources
this.mResources = createResources(context, apk);
//宿主与插件共用classloader，也方便宿主与插件之间代码能互相调用到
//创建classloader，两种模式，一种是宿主与所有插件共用一个classloader（默认），把插件和宿主的dex/nativeLib合并到一个classloader中、另一种是宿主与各个插件分别用自己的classloader
this.mClassLoader = createClassLoader(context, apk, this.mNativeLibDir, context.getClassLoader());
//把插件apk的所有so拷贝到mNativeLibDir中
tryToCopyNativeLib(apk);
// Cache instrumentations
Map<ComponentName, InstrumentationInfo> instrumentations = new HashMap<ComponentName, InstrumentationInfo>();
for (PackageParser.Instrumentation instrumentation : this.mPackage.instrumentation) {
instrumentations.put(instrumentation.getComponentName(), instrumentation.info);
}
//把该插件apk用到的所有instrumentation缓存到LoadedPlugin.mInstrumentationInfos中
this.mInstrumentationInfos = Collections.unmodifiableMap(instrumentations);
//把LoadedPlugin.mPackageInfo.instrumentation也指向 instrumentations
this.mPackageInfo.instrumentation = instrumentations.values().toArray(new InstrumentationInfo[instrumentations.size()]);
//缓存插件的四大组件
// Cache activities
Map<ComponentName, ActivityInfo> activityInfos = new HashMap<ComponentName, ActivityInfo>();
for (PackageParser.Activity activity : this.mPackage.activities) {
activityInfos.put(activity.getComponentName(), activity.info);
}
this.mActivityInfos = Collections.unmodifiableMap(activityInfos);
this.mPackageInfo.activities = activityInfos.values().toArray(new ActivityInfo[activityInfos.size()]);
// Cache services
Map<ComponentName, ServiceInfo> serviceInfos = new HashMap<ComponentName, ServiceInfo>();
for (PackageParser.Service service : this.mPackage.services) {
serviceInfos.put(service.getComponentName(), service.info);
}
this.mServiceInfos = Collections.unmodifiableMap(serviceInfos);
this.mPackageInfo.services = serviceInfos.values().toArray(new ServiceInfo[serviceInfos.size()]);
// Cache providers
Map<String, ProviderInfo> providers = new HashMap<String, ProviderInfo>();
Map<ComponentName, ProviderInfo> providerInfos = new HashMap<ComponentName, ProviderInfo>();
for (PackageParser.Provider provider : this.mPackage.providers) {
providers.put(provider.info.authority, provider.info);
providerInfos.put(provider.getComponentName(), provider.info);
}
this.mProviders = Collections.unmodifiableMap(providers);
this.mProviderInfos = Collections.unmodifiableMap(providerInfos);
this.mPackageInfo.providers = providerInfos.values().toArray(new ProviderInfo[providerInfos.size()]);
// Register broadcast receivers dynamically
Map<ComponentName, ActivityInfo> receivers = new HashMap<ComponentName, ActivityInfo>();
for (PackageParser.Activity receiver : this.mPackage.receivers) {
receivers.put(receiver.getComponentName(), receiver.info);
//把解析到的插件静态广播通过宿主进程的context动态注册广播
BroadcastReceiver br = BroadcastReceiver.class.cast(getClassLoader().loadClass(receiver.getComponentName().getClassName()).newInstance());
for (PackageParser.ActivityIntentInfo aii : receiver.intents) {
this.mHostContext.registerReceiver(br, aii);
}
}
this.mReceiverInfos = Collections.unmodifiableMap(receivers);
this.mPackageInfo.receivers = receivers.values().toArray(new ActivityInfo[receivers.size()]);
}
private void tryToCopyNativeLib(File apk) throws Exception {
PluginUtil.copyNativeLib(apk, mHostContext, mPackageInfo, mNativeLibDir);
}
public String getLocation() {
return this.mLocation;
}
public String getPackageName() {
return this.mPackage.packageName;
}
public PackageManager getPackageManager() {
return this.mPackageManager;
}
public AssetManager getAssets() {
return getResources().getAssets();
}
public Resources getResources() {
return this.mResources;
}
public void updateResources(Resources newResources) {
this.mResources = newResources;
}
public ClassLoader getClassLoader() {
return this.mClassLoader;
}
public PluginManager getPluginManager() {
return this.mPluginManager;
}
public Context getHostContext() {
return this.mHostContext;
}
public Context getPluginContext() {
return this.mPluginContext;
}
public Application getApplication() {
return mApplication;
}
public void invokeApplication() {
if (mApplication != null) {
return;
}
// make sure application's callback is run on ui thread.
RunUtil.runOnUiThread(new Runnable() {
@Override
public void run() {
mApplication = makeApplication(false, mPluginManager.getInstrumentation());
}
}, true);
}
public String getPackageResourcePath() {
int myUid = Process.myUid();
ApplicationInfo appInfo = this.mPackage.applicationInfo;
return appInfo.uid == myUid ? appInfo.sourceDir : appInfo.publicSourceDir;
}
public String getCodePath() {
return this.mPackage.applicationInfo.sourceDir;
}
public Intent getLaunchIntent() {
ContentResolver resolver = this.mPluginContext.getContentResolver();
Intent launcher = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER);
for (PackageParser.Activity activity : this.mPackage.activities) {
for (PackageParser.ActivityIntentInfo intentInfo : activity.intents) {
if (intentInfo.match(resolver, launcher, false, TAG) > 0) {
return Intent.makeMainActivity(activity.getComponentName());
}
}
}
return null;
}
public Intent getLeanbackLaunchIntent() {
ContentResolver resolver = this.mPluginContext.getContentResolver();
Intent launcher = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LEANBACK_LAUNCHER);
for (PackageParser.Activity activity : this.mPackage.activities) {
for (PackageParser.ActivityIntentInfo intentInfo : activity.intents) {
if (intentInfo.match(resolver, launcher, false, TAG) > 0) {
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.setComponent(activity.getComponentName());
intent.addCategory(Intent.CATEGORY_LEANBACK_LAUNCHER);
return intent;
}
}
}
return null;
}
public ApplicationInfo getApplicationInfo() {
return this.mPackage.applicationInfo;
}
public PackageInfo getPackageInfo() {
return this.mPackageInfo;
}
public ActivityInfo getActivityInfo(ComponentName componentName) {
return this.mActivityInfos.get(componentName);
}
public ServiceInfo getServiceInfo(ComponentName componentName) {
return this.mServiceInfos.get(componentName);
}
public ActivityInfo getReceiverInfo(ComponentName componentName) {
return this.mReceiverInfos.get(componentName);
}
public ProviderInfo getProviderInfo(ComponentName componentName) {
return this.mProviderInfos.get(componentName);
}
public Resources.Theme getTheme() {
Resources.Theme theme = this.mResources.newTheme();
theme.applyStyle(PluginUtil.selectDefaultTheme(this.mPackage.applicationInfo.theme, Build.VERSION.SDK_INT), false);
return theme;
}
public void setTheme(int resid) {
try {
ReflectUtil.setField(Resources.class, this.mResources, "mThemeResId", resid);
} catch (Exception e) {
e.printStackTrace();
}
}
private Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) {
if (null != this.mApplication) {
return this.mApplication;
}
String appClass = this.mPackage.applicationInfo.className;
if (forceDefaultAppClass || null == appClass) {
appClass = "android.app.Application";
}
try {
this.mApplication = instrumentation.newApplication(this.mClassLoader, appClass, this.getPluginContext());
instrumentation.callApplicationOnCreate(this.mApplication);
return this.mApplication;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public ResolveInfo resolveActivity(Intent intent, int flags) {
List<ResolveInfo> query = this.queryIntentActivities(intent, flags);
if (null == query || query.isEmpty()) {
return null;
}
ContentResolver resolver = this.mPluginContext.getContentResolver();
return chooseBestActivity(intent, intent.resolveTypeIfNeeded(resolver), flags, query);
}
public List<ResolveInfo> queryIntentActivities(Intent intent, int flags) {
ComponentName component = intent.getComponent();
List<ResolveInfo> resolveInfos = new ArrayList<ResolveInfo>();
ContentResolver resolver = this.mPluginContext.getContentResolver();
for (PackageParser.Activity activity : this.mPackage.activities) {
if (match(activity, component)) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.activityInfo = activity.info;
resolveInfos.add(resolveInfo);
} else if (component == null) {
// only match implicit intent
for (PackageParser.ActivityIntentInfo intentInfo : activity.intents) {
if (intentInfo.match(resolver, intent, true, TAG) >= 0) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.activityInfo = activity.info;
resolveInfos.add(resolveInfo);
break;
}
}
}
}
return resolveInfos;
}
public ResolveInfo resolveService(Intent intent, int flags) {
List<ResolveInfo> query = this.queryIntentServices(intent, flags);
if (null == query || query.isEmpty()) {
return null;
}
ContentResolver resolver = this.mPluginContext.getContentResolver();
return chooseBestActivity(intent, intent.resolveTypeIfNeeded(resolver), flags, query);
}
public List<ResolveInfo> queryIntentServices(Intent intent, int flags) {
ComponentName component = intent.getComponent();
List<ResolveInfo> resolveInfos = new ArrayList<ResolveInfo>();
ContentResolver resolver = this.mPluginContext.getContentResolver();
for (PackageParser.Service service : this.mPackage.services) {
if (match(service, component)) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.serviceInfo = service.info;
resolveInfos.add(resolveInfo);
} else if (component == null) {
// only match implicit intent
for (PackageParser.ServiceIntentInfo intentInfo : service.intents) {
if (intentInfo.match(resolver, intent, true, TAG) >= 0) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.serviceInfo = service.info;
resolveInfos.add(resolveInfo);
break;
}
}
}
}
return resolveInfos;
}
public List<ResolveInfo> queryBroadcastReceivers(Intent intent, int flags) {
ComponentName component = intent.getComponent();
List<ResolveInfo> resolveInfos = new ArrayList<ResolveInfo>();
ContentResolver resolver = this.mPluginContext.getContentResolver();
for (PackageParser.Activity receiver : this.mPackage.receivers) {
if (receiver.getComponentName().equals(component)) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.activityInfo = receiver.info;
resolveInfos.add(resolveInfo);
} else if (component == null) {
// only match implicit intent
for (PackageParser.ActivityIntentInfo intentInfo : receiver.intents) {
if (intentInfo.match(resolver, intent, true, TAG) >= 0) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.activityInfo = receiver.info;
resolveInfos.add(resolveInfo);
break;
}
}
}
}
return resolveInfos;
}
public ProviderInfo resolveContentProvider(String name, int flags) {
return this.mProviders.get(name);
}
private boolean match(PackageParser.Component component, ComponentName target) {
ComponentName source = component.getComponentName();
if (source == target) return true;
if (source != null && target != null
&& source.getClassName().equals(target.getClassName())
&& (source.getPackageName().equals(target.getPackageName())
|| mHostContext.getPackageName().equals(target.getPackageName()))) {
return true;
}
return false;
}
/**
* @author johnsonlee
*/
private class PluginPackageManager extends PackageManager {
private PackageManager mHostPackageManager = mHostContext.getPackageManager();
@Override
public PackageInfo getPackageInfo(String packageName, int flags) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.mPackageInfo;
}
return this.mHostPackageManager.getPackageInfo(packageName, flags);
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public PackageInfo getPackageInfo(VersionedPackage versionedPackage, int i) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(versionedPackage.getPackageName());
if (null != plugin) {
return plugin.mPackageInfo;
}
return this.mHostPackageManager.getPackageInfo(versionedPackage, i);
}
@Override
public String[] currentToCanonicalPackageNames(String[] names) {
return this.mHostPackageManager.currentToCanonicalPackageNames(names);
}
@Override
public String[] canonicalToCurrentPackageNames(String[] names) {
return this.mHostPackageManager.canonicalToCurrentPackageNames(names);
}
@Override
public Intent getLaunchIntentForPackage(String packageName) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.getLaunchIntent();
}
return this.mHostPackageManager.getLaunchIntentForPackage(packageName);
}
@Override
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public Intent getLeanbackLaunchIntentForPackage(String packageName) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.getLeanbackLaunchIntent();
}
return this.mHostPackageManager.getLeanbackLaunchIntentForPackage(packageName);
}
@Override
public int[] getPackageGids(String packageName) throws NameNotFoundException {
return this.mHostPackageManager.getPackageGids(packageName);
}
@Override
public PermissionInfo getPermissionInfo(String name, int flags) throws NameNotFoundException {
return this.mHostPackageManager.getPermissionInfo(name, flags);
}
@Override
public List<PermissionInfo> queryPermissionsByGroup(String group, int flags) throws NameNotFoundException {
return this.mHostPackageManager.queryPermissionsByGroup(group, flags);
}
@Override
public PermissionGroupInfo getPermissionGroupInfo(String name, int flags) throws NameNotFoundException {
return this.mHostPackageManager.getPermissionGroupInfo(name, flags);
}
@Override
public List<PermissionGroupInfo> getAllPermissionGroups(int flags) {
return this.mHostPackageManager.getAllPermissionGroups(flags);
}
@Override
public ApplicationInfo getApplicationInfo(String packageName, int flags) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.getApplicationInfo();
}
return this.mHostPackageManager.getApplicationInfo(packageName, flags);
}
@Override
public ActivityInfo getActivityInfo(ComponentName component, int flags) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mActivityInfos.get(component);
}
return this.mHostPackageManager.getActivityInfo(component, flags);
}
@Override
public ActivityInfo getReceiverInfo(ComponentName component, int flags) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mReceiverInfos.get(component);
}
return this.mHostPackageManager.getReceiverInfo(component, flags);
}
@Override
public ServiceInfo getServiceInfo(ComponentName component, int flags) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mServiceInfos.get(component);
}
return this.mHostPackageManager.getServiceInfo(component, flags);
}
@Override
public ProviderInfo getProviderInfo(ComponentName component, int flags) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mProviderInfos.get(component);
}
return this.mHostPackageManager.getProviderInfo(component, flags);
}
@Override
public List<PackageInfo> getInstalledPackages(int flags) {
return this.mHostPackageManager.getInstalledPackages(flags);
}
@Override
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
public List<PackageInfo> getPackagesHoldingPermissions(String[] permissions, int flags) {
return this.mHostPackageManager.getPackagesHoldingPermissions(permissions, flags);
}
@Override
public int checkPermission(String permName, String pkgName) {
return this.mHostPackageManager.checkPermission(permName, pkgName);
}
@Override
public boolean addPermission(PermissionInfo info) {
return this.mHostPackageManager.addPermission(info);
}
@Override
public boolean addPermissionAsync(PermissionInfo info) {
return this.mHostPackageManager.addPermissionAsync(info);
}
@Override
public void removePermission(String name) {
this.mHostPackageManager.removePermission(name);
}
@Override
public int checkSignatures(String pkg1, String pkg2) {
return this.mHostPackageManager.checkSignatures(pkg1, pkg2);
}
@Override
public int checkSignatures(int uid1, int uid2) {
return this.mHostPackageManager.checkSignatures(uid1, uid2);
}
@Override
public String[] getPackagesForUid(int uid) {
return this.mHostPackageManager.getPackagesForUid(uid);
}
@Override
public String getNameForUid(int uid) {
return this.mHostPackageManager.getNameForUid(uid);
}
@Override
public List<ApplicationInfo> getInstalledApplications(int flags) {
return this.mHostPackageManager.getInstalledApplications(flags);
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public boolean isInstantApp() {
return this.mHostPackageManager.isInstantApp();
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public boolean isInstantApp(String s) {
return this.mHostPackageManager.isInstantApp(s);
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public int getInstantAppCookieMaxBytes() {
return this.mHostPackageManager.getInstantAppCookieMaxBytes();
}
@TargetApi(Build.VERSION_CODES.O)
@NonNull
@Override
public byte[] getInstantAppCookie() {
return this.mHostPackageManager.getInstantAppCookie();
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public void clearInstantAppCookie() {
this.mHostPackageManager.clearInstantAppCookie();
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public void updateInstantAppCookie(@Nullable byte[] bytes) {
this.mHostPackageManager.updateInstantAppCookie(bytes);
}
@Override
public String[] getSystemSharedLibraryNames() {
return this.mHostPackageManager.getSystemSharedLibraryNames();
}
@TargetApi(Build.VERSION_CODES.O)
@NonNull
@Override
public List<SharedLibraryInfo> getSharedLibraries(int i) {
return this.mHostPackageManager.getSharedLibraries(i);
}
@TargetApi(Build.VERSION_CODES.O)
@Nullable
@Override
public ChangedPackages getChangedPackages(int i) {
return this.mHostPackageManager.getChangedPackages(i);
}
@Override
public FeatureInfo[] getSystemAvailableFeatures() {
return this.mHostPackageManager.getSystemAvailableFeatures();
}
@Override
public boolean hasSystemFeature(String name) {
return this.mHostPackageManager.hasSystemFeature(name);
}
@Override
public ResolveInfo resolveActivity(Intent intent, int flags) {
ResolveInfo resolveInfo = mPluginManager.resolveActivity(intent, flags);
if (null != resolveInfo) {
return resolveInfo;
}
return this.mHostPackageManager.resolveActivity(intent, flags);
}
@Override
public List<ResolveInfo> queryIntentActivities(Intent intent, int flags) {
ComponentName component = intent.getComponent();
if (null == component) {
if (intent.getSelector() != null) {
intent = intent.getSelector();
component = intent.getComponent();
}
}
if (null != component) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
ActivityInfo activityInfo = plugin.getActivityInfo(component);
if (activityInfo != null) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.activityInfo = activityInfo;
return Arrays.asList(resolveInfo);
}
}
}
List<ResolveInfo> all = new ArrayList<ResolveInfo>();
List<ResolveInfo> pluginResolveInfos = mPluginManager.queryIntentActivities(intent, flags);
if (null != pluginResolveInfos && pluginResolveInfos.size() > 0) {
all.addAll(pluginResolveInfos);
}
List<ResolveInfo> hostResolveInfos = this.mHostPackageManager.queryIntentActivities(intent, flags);
if (null != hostResolveInfos && hostResolveInfos.size() > 0) {
all.addAll(hostResolveInfos);
}
return all;
}
@Override
public List<ResolveInfo> queryIntentActivityOptions(ComponentName caller, Intent[] specifics, Intent intent, int flags) {
return this.mHostPackageManager.queryIntentActivityOptions(caller, specifics, intent, flags);
}
@Override
public List<ResolveInfo> queryBroadcastReceivers(Intent intent, int flags) {
ComponentName component = intent.getComponent();
if (null == component) {
if (intent.getSelector() != null) {
intent = intent.getSelector();
component = intent.getComponent();
}
}
if (null != component) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
ActivityInfo activityInfo = plugin.getReceiverInfo(component);
if (activityInfo != null) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.activityInfo = activityInfo;
return Arrays.asList(resolveInfo);
}
}
}
List<ResolveInfo> all = new ArrayList<ResolveInfo>();
List<ResolveInfo> pluginResolveInfos = mPluginManager.queryBroadcastReceivers(intent, flags);
if (null != pluginResolveInfos && pluginResolveInfos.size() > 0) {
all.addAll(pluginResolveInfos);
}
List<ResolveInfo> hostResolveInfos = this.mHostPackageManager.queryBroadcastReceivers(intent, flags);
if (null != hostResolveInfos && hostResolveInfos.size() > 0) {
all.addAll(hostResolveInfos);
}
return all;
}
@Override
public ResolveInfo resolveService(Intent intent, int flags) {
ResolveInfo resolveInfo = mPluginManager.resolveService(intent, flags);
if (null != resolveInfo) {
return resolveInfo;
}
return this.mHostPackageManager.resolveService(intent, flags);
}
@Override
public List<ResolveInfo> queryIntentServices(Intent intent, int flags) {
ComponentName component = intent.getComponent();
if (null == component) {
if (intent.getSelector() != null) {
intent = intent.getSelector();
component = intent.getComponent();
}
}
if (null != component) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
ServiceInfo serviceInfo = plugin.getServiceInfo(component);
if (serviceInfo != null) {
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.serviceInfo = serviceInfo;
return Arrays.asList(resolveInfo);
}
}
}
List<ResolveInfo> all = new ArrayList<ResolveInfo>();
List<ResolveInfo> pluginResolveInfos = mPluginManager.queryIntentServices(intent, flags);
if (null != pluginResolveInfos && pluginResolveInfos.size() > 0) {
all.addAll(pluginResolveInfos);
}
List<ResolveInfo> hostResolveInfos = this.mHostPackageManager.queryIntentServices(intent, flags);
if (null != hostResolveInfos && hostResolveInfos.size() > 0) {
all.addAll(hostResolveInfos);
}
return all;
}
@Override
@TargetApi(Build.VERSION_CODES.KITKAT)
public List<ResolveInfo> queryIntentContentProviders(Intent intent, int flags) {
return this.mHostPackageManager.queryIntentContentProviders(intent, flags);
}
@Override
public ProviderInfo resolveContentProvider(String name, int flags) {
ProviderInfo providerInfo = mPluginManager.resolveContentProvider(name, flags);
if (null != providerInfo) {
return providerInfo;
}
return this.mHostPackageManager.resolveContentProvider(name, flags);
}
@Override
public List<ProviderInfo> queryContentProviders(String processName, int uid, int flags) {
return this.mHostPackageManager.queryContentProviders(processName, uid, flags);
}
@Override
public InstrumentationInfo getInstrumentationInfo(ComponentName component, int flags) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mInstrumentationInfos.get(component);
}
return this.mHostPackageManager.getInstrumentationInfo(component, flags);
}
@Override
public List<InstrumentationInfo> queryInstrumentation(String targetPackage, int flags) {
return this.mHostPackageManager.queryInstrumentation(targetPackage, flags);
}
@Override
public Drawable getDrawable(String packageName, int resid, ApplicationInfo appInfo) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.mResources.getDrawable(resid);
}
return this.mHostPackageManager.getDrawable(packageName, resid, appInfo);
}
@Override
public Drawable getActivityIcon(ComponentName component) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mResources.getDrawable(plugin.mActivityInfos.get(component).icon);
}
return this.mHostPackageManager.getActivityIcon(component);
}
@Override
public Drawable getActivityIcon(Intent intent) throws NameNotFoundException {
ResolveInfo ri = mPluginManager.resolveActivity(intent);
if (null != ri) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(ri.resolvePackageName);
return plugin.mResources.getDrawable(ri.activityInfo.icon);
}
return this.mHostPackageManager.getActivityIcon(intent);
}
@Override
@TargetApi(Build.VERSION_CODES.KITKAT_WATCH)
public Drawable getActivityBanner(ComponentName component) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mResources.getDrawable(plugin.mActivityInfos.get(component).banner);
}
return this.mHostPackageManager.getActivityBanner(component);
}
@Override
@TargetApi(Build.VERSION_CODES.KITKAT_WATCH)
public Drawable getActivityBanner(Intent intent) throws NameNotFoundException {
ResolveInfo ri = mPluginManager.resolveActivity(intent);
if (null != ri) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(ri.resolvePackageName);
return plugin.mResources.getDrawable(ri.activityInfo.banner);
}
return this.mHostPackageManager.getActivityBanner(intent);
}
@Override
public Drawable getDefaultActivityIcon() {
return this.mHostPackageManager.getDefaultActivityIcon();
}
@Override
public Drawable getApplicationIcon(ApplicationInfo info) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(info.packageName);
if (null != plugin) {
return plugin.mResources.getDrawable(info.icon);
}
return this.mHostPackageManager.getApplicationIcon(info);
}
@Override
public Drawable getApplicationIcon(String packageName) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.mResources.getDrawable(plugin.mPackage.applicationInfo.icon);
}
return this.mHostPackageManager.getApplicationIcon(packageName);
}
@Override
@TargetApi(Build.VERSION_CODES.KITKAT_WATCH)
public Drawable getApplicationBanner(ApplicationInfo info) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(info.packageName);
if (null != plugin) {
return plugin.mResources.getDrawable(info.banner);
}
return this.mHostPackageManager.getApplicationBanner(info);
}
@Override
@TargetApi(Build.VERSION_CODES.KITKAT_WATCH)
public Drawable getApplicationBanner(String packageName) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.mResources.getDrawable(plugin.mPackage.applicationInfo.banner);
}
return this.mHostPackageManager.getApplicationBanner(packageName);
}
@Override
public Drawable getActivityLogo(ComponentName component) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mResources.getDrawable(plugin.mActivityInfos.get(component).logo);
}
return this.mHostPackageManager.getActivityLogo(component);
}
@Override
public Drawable getActivityLogo(Intent intent) throws NameNotFoundException {
ResolveInfo ri = mPluginManager.resolveActivity(intent);
if (null != ri) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(ri.resolvePackageName);
return plugin.mResources.getDrawable(ri.activityInfo.logo);
}
return this.mHostPackageManager.getActivityLogo(intent);
}
@Override
public Drawable getApplicationLogo(ApplicationInfo info) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(info.packageName);
if (null != plugin) {
return plugin.mResources.getDrawable(0 != info.logo ? info.logo : android.R.drawable.sym_def_app_icon);
}
return this.mHostPackageManager.getApplicationLogo(info);
}
@Override
public Drawable getApplicationLogo(String packageName) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.mResources.getDrawable(0 != plugin.mPackage.applicationInfo.logo ? plugin.mPackage.applicationInfo.logo : android.R.drawable.sym_def_app_icon);
}
return this.mHostPackageManager.getApplicationLogo(packageName);
}
@Override
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public Drawable getUserBadgedIcon(Drawable icon, UserHandle user) {
return this.mHostPackageManager.getUserBadgedIcon(icon, user);
}
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
public Drawable getUserBadgeForDensity(UserHandle user, int density) {
try {
Method method = PackageManager.class.getMethod("getUserBadgeForDensity", UserHandle.class, int.class);
return (Drawable) method.invoke(this.mHostPackageManager, user, density);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public Drawable getUserBadgedDrawableForDensity(Drawable drawable, UserHandle user, Rect badgeLocation, int badgeDensity) {
return this.mHostPackageManager.getUserBadgedDrawableForDensity(drawable, user, badgeLocation, badgeDensity);
}
@Override
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public CharSequence getUserBadgedLabel(CharSequence label, UserHandle user) {
return this.mHostPackageManager.getUserBadgedLabel(label, user);
}
@Override
public CharSequence getText(String packageName, int resid, ApplicationInfo appInfo) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.mResources.getText(resid);
}
return this.mHostPackageManager.getText(packageName, resid, appInfo);
}
@Override
public XmlResourceParser getXml(String packageName, int resid, ApplicationInfo appInfo) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return plugin.mResources.getXml(resid);
}
return this.mHostPackageManager.getXml(packageName, resid, appInfo);
}
@Override
public CharSequence getApplicationLabel(ApplicationInfo info) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(info.packageName);
if (null != plugin) {
try {
return plugin.mResources.getText(info.labelRes);
} catch (Resources.NotFoundException e) {
// ignored.
}
}
return this.mHostPackageManager.getApplicationLabel(info);
}
@Override
public Resources getResourcesForActivity(ComponentName component) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
if (null != plugin) {
return plugin.mResources;
}
return this.mHostPackageManager.getResourcesForActivity(component);
}
@Override
public Resources getResourcesForApplication(ApplicationInfo app) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(app.packageName);
if (null != plugin) {
return plugin.mResources;
}
return this.mHostPackageManager.getResourcesForApplication(app);
}
@Override
public Resources getResourcesForApplication(String appPackageName) throws NameNotFoundException {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(appPackageName);
if (null != plugin) {
return plugin.mResources;
}
return this.mHostPackageManager.getResourcesForApplication(appPackageName);
}
@Override
public void verifyPendingInstall(int id, int verificationCode) {
this.mHostPackageManager.verifyPendingInstall(id, verificationCode);
}
@Override
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
public void extendVerificationTimeout(int id, int verificationCodeAtTimeout, long millisecondsToDelay) {
this.mHostPackageManager.extendVerificationTimeout(id, verificationCodeAtTimeout, millisecondsToDelay);
}
@Override
public void setInstallerPackageName(String targetPackage, String installerPackageName) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(targetPackage);
if (null != plugin) {
return;
}
this.mHostPackageManager.setInstallerPackageName(targetPackage, installerPackageName);
}
@Override
public String getInstallerPackageName(String packageName) {
LoadedPlugin plugin = mPluginManager.getLoadedPlugin(packageName);
if (null != plugin) {
return mHostContext.getPackageName();
}
return this.mHostPackageManager.getInstallerPackageName(packageName);
}
@Override
public void addPackageToPreferred(String packageName) {
this.mHostPackageManager.addPackageToPreferred(packageName);
}
@Override
public void removePackageFromPreferred(String packageName) {
this.mHostPackageManager.removePackageFromPreferred(packageName);
}
@Override
public List<PackageInfo> getPreferredPackages(int flags) {
return this.mHostPackageManager.getPreferredPackages(flags);
}
@Override
public void addPreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity) {
this.mHostPackageManager.addPreferredActivity(filter, match, set, activity);
}
@Override
public void clearPackagePreferredActivities(String packageName) {
this.mHostPackageManager.clearPackagePreferredActivities(packageName);
}
@Override
public int getPreferredActivities(List<IntentFilter> outFilters, List<ComponentName> outActivities, String packageName) {
return this.mHostPackageManager.getPreferredActivities(outFilters, outActivities, packageName);
}
@Override
public void setComponentEnabledSetting(ComponentName component, int newState, int flags) {
this.mHostPackageManager.setComponentEnabledSetting(component, newState, flags);
}
@Override
public int getComponentEnabledSetting(ComponentName component) {
return this.mHostPackageManager.getComponentEnabledSetting(component);
}
@Override
public void setApplicationEnabledSetting(String packageName, int newState, int flags) {
this.mHostPackageManager.setApplicationEnabledSetting(packageName, newState, flags);
}
@Override
public int getApplicationEnabledSetting(String packageName) {
return this.mHostPackageManager.getApplicationEnabledSetting(packageName);
}
@Override
public boolean isSafeMode() {
return this.mHostPackageManager.isSafeMode();
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public void setApplicationCategoryHint(@NonNull String s, int i) {
this.mHostPackageManager.setApplicationCategoryHint(s, i);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
@Override
public PackageInstaller getPackageInstaller() {
return this.mHostPackageManager.getPackageInstaller();
}
@TargetApi(Build.VERSION_CODES.O)
@Override
public boolean canRequestPackageInstalls() {
return this.mHostPackageManager.canRequestPackageInstalls();
}
@TargetApi(24)
public int[] getPackageGids(String s, int i) throws NameNotFoundException {
return mHostPackageManager.getPackageGids(s);
}
public int getPackageUid(String s, int i) throws NameNotFoundException {
Object uid = ReflectUtil.invokeNoException(PackageManager.class, mHostPackageManager, "getPackageUid",
new Class[]{String.class, int.class}, s, i);
if (uid != null) {
return (int) uid;
} else {
throw new NameNotFoundException(s);
}
}
@TargetApi(23)
public boolean isPermissionRevokedByPolicy(String s, String s1) {
return false;
}
@TargetApi(24)
public boolean hasSystemFeature(String s, int i) {
return mHostPackageManager.hasSystemFeature(s);
}
}
}资源管理类，ResourcesManager
class ResourcesManager {
/**
* 某大神对VirtualApk优化改动：https://www.notion.so/VirtualAPK-1fce1a910c424937acde9528d2acd537
* 这种方式在5.0以下系统，宿主与插件共用资源，避免了去兼容不同厂商定制Resources导致的兼容性问题
* 因为这种方式使用的还是宿主生成的assetManager、，只是把已加载的资源清除后，重新把宿主资源和插件资源加载一遍，不需要构造新的assetManager和resources对象
*/
public static synchronized Resources createResources2(Context hostContext, String apk) {
Resources hostResources = hostContext.getResources();
try {
AssetManager assetManager = hostResources.getAssets();
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
/* 在Android5.0之前，addAssetPath只是把补丁包加入到资源路径列表里，但是资源的解析其实是在很早的时候就已经执行完了，
* 所以直接addAssetPath添加插件的资源路径，并不会把插件资源解析。
* https://www.notion.so/VirtualAPK-1fce1a910c424937acde9528d2acd537
* VirtualApk方案：在 Android L 之前是需要想办法构造一个新的AssetManager里的 mResources 才行，这里有两种方案，VirtualAPK 用的是类似 InstantRun 的那种方案，
* 构造一个新的 AssetManager，将宿主和加载过的插件的所有 apk 全都添加一遍，然后再调用hookResources方法将新的 Resources 替换回原来的，
* 这样会引起两个问题，一个是每次加载新的插件都会重新构造一个 AssetManger 和 Resources，然后重新添加所有资源，这样涉及到很多机型的兼容(因为部分厂商自己修改了 Resources 的类名)，
* 一个是需要有一个替换原来Resources的过程，这样就需要涉及到很多地方，从hookResources的实现里看，替换了四处地方，在尽量少的 hook 原则下这样的情况还是尽量避免的。
* 淘宝方案：保存宿主已经加载的资源路径，hook AssetManager.destroy()删除已加载的资源，再把宿主资源、插件资源全部添加到宿主的AssetManager.addAssetPath()
* hook AssetManager.init()重新初始化宿主的assetManager、重新构造assetManager.mStringBlocks、把宿主和插件资源添加到assetManager、重新构造ensureStringBlocks
* hostResources.updateConfiguration(...)
*/
//我们需要将应用原来加载的地址取出来，详情见①
List<String> cookieNames = new ArrayList<>();
//宿主已加载的资源数量
int stringBlockCount = (int) ReflectUtil.invoke(AssetManager.class, assetManager, "getStringBlockCount");
//反射获取AssetManager.getCookieName(int)
Method getCookieNameMethod = AssetManager.class.getDeclaredMethod("getCookieName", Integer.TYPE);
getCookieNameMethod.setAccessible(true);
for (int i = 0; i < stringBlockCount; i++) {
//调用assetManager.getCookieName(int)把宿主已加载的资源路径全部取出，保存到cookieNames中
String cookieName = (String) getCookieNameMethod.invoke(assetManager, new Object[] {i + 1});
cookieNames.add(cookieName);
}
//调用assetManager.destroy() 这是一个native方法，删除已加载资源
ReflectUtil.invoke(AssetManager.class, assetManager, "destroy");
//调用assetManager.init() 这是一个native方法，重新初始化assetManager
ReflectUtil.invoke(AssetManager.class, assetManager, "init");
//mStringBlocks 记录了之前加载过的所有资源包中的String Pool，很多时候访问字符串是从此处来的，如果不重新构造就会导致崩溃
ReflectUtil.setField(AssetManager.class, assetManager, "mStringBlocks", null);//②
//将宿主原来加载的资源添加进去
for (String path : cookieNames) {
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", path);
}
//插入插件的资源地址
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", apk);
List<LoadedPlugin> pluginList = PluginManager.getInstance(hostContext).getAllLoadedPlugins();
for (LoadedPlugin plugin : pluginList) {
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", plugin.getLocation());
}
//ensureStringBlocks 记录了之前加载过的所有资源包中的String Pool，很多时候访问字符串是从此处来的，如果不重新构造就会导致崩溃
ReflectUtil.invoke(AssetManager.class, assetManager, "ensureStringBlocks");//③
//过程中很重要的一步，因为后面在资源查找的时候是需要通过一个ResTable_config来获取当前手机的一些配置从而获取到准确的资源，如果不进行初始化则会出现找不到资源的崩溃
hostResources.updateConfiguration(hostResources.getConfiguration(), hostResources.getDisplayMetrics());//此行代码非常重要④
} else {
//android5.0及以上系统，资源加载直接将插件包的apk地址addAssetPath 之后就可以了
//反射调用assetManager.addAssetPath(...)，把插件apk路径添加进去
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", apk);
//从PluginManager获取缓存的已加载的插件列表
List<LoadedPlugin> pluginList = PluginManager.getInstance(hostContext).getAllLoadedPlugins();
for (LoadedPlugin plugin : pluginList) {
//遍历所有已加载的插件，把所有插件apk路径添加到这个assetManager中，这样这个assetManager就拥有了包括宿主和插件的所有资源路径
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", plugin.getLocation());
}
}
//省去了兼容性的验证
} catch (Exception e) {
e.printStackTrace();
}
return hostResources;
}
/** 创建新的Resources对象，处理厂商适配问题 */
public static synchronized Resources createResources(Context hostContext, String apk) {
Resources hostResources = hostContext.getResources();//获取宿主进程的 Resources 对象
Resources newResources = null;
AssetManager assetManager;
try {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {//5.0以下
assetManager = AssetManager.class.newInstance();//通过class创建一个AssetManager对象
//反射调用 assetManager.addAssetPath(...)，传入宿主进程的sourceDir，（先装入宿主进程的sourceDir，再装插件的sourceDir，然后替换掉宿主进程的assetManager）
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", hostContext.getApplicationInfo().sourceDir);
} else {//5.0及以上，直接获取宿主进程的AssetManager
assetManager = hostResources.getAssets();
}
//反射调用assetManager.addAssetPath(...)，把插件apk路径添加进去
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", apk);
//从PluginManager获取缓存的已加载的插件列表
List<LoadedPlugin> pluginList = PluginManager.getInstance(hostContext).getAllLoadedPlugins();
for (LoadedPlugin plugin : pluginList) {
//遍历所有已加载的插件，把所有插件apk路径添加到这个assetManager中，这样这个assetManager就拥有了包括宿主和插件的所有资源路径
ReflectUtil.invoke(AssetManager.class, assetManager, "addAssetPath", plugin.getLocation());
}
//根据不同厂商系统，生成Resources对象，并把宿主resources的属性传入新的Resources对象中
if (isMiUi(hostResources)) {//MIUI
newResources = MiUiResourcesCompat.createResources(hostResources, assetManager);
} else if (isVivo(hostResources)) {//Vivo
newResources = VivoResourcesCompat.createResources(hostContext, hostResources, assetManager);
} else if (isNubia(hostResources)) {//Nubia
newResources = NubiaResourcesCompat.createResources(hostResources, assetManager);
} else if (isNotRawResources(hostResources)) {
newResources = AdaptationResourcesCompat.createResources(hostResources, assetManager);
} else {
//原生android系统 is raw android resources
//Resources对象可以通过AssetManager查找资源
newResources = new Resources(assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration());
}
// lastly, sync all LoadedPlugin to newResources
//所有插件更新resources对象为新建的resources
for (LoadedPlugin plugin : pluginList) {
plugin.updateResources(newResources);
}
} catch (Exception e) {
e.printStackTrace();
}
return newResources;
}
/**
* 反射把宿主进程使用的mResources对象，全部替换为上面方法生成的新的、宿主与插件共用的resources对象
*/
public static void hookResources(Context base, Resources resources) {
try {
//反射把宿主进程ContextImpl.mResources替换为新建的、宿主与插件共用的resources对象
ReflectUtil.setField(base.getClass(), base, "mResources", resources);
//反射获取宿主进程的ContextImpl.mPackageInfo
Object loadedApk = ReflectUtil.getPackageInfo(base);
//反射把宿主进程ContextImpl.mPackageInfo.mResources替换为新建的、宿主与插件共用的resources对象
ReflectUtil.setField(loadedApk.getClass(), loadedApk, "mResources", resources);
//获取宿主进程ActivityThread对象
Object activityThread = ReflectUtil.getActivityThread(base);
//获取宿主进程ActivityThread.mResourcesManager
Object resManager = ReflectUtil.getField(activityThread.getClass(), activityThread, "mResourcesManager");
if (Build.VERSION.SDK_INT < 24) {//7.0以下
//替换宿主进程 ActivityThread.mResourcesManager.mActiveResources中第一个元素的value，替换成新建的resources
Map<Object, WeakReference<Resources>> map = (Map<Object, WeakReference<Resources>>) ReflectUtil.getField(resManager.getClass(), resManager, "mActiveResources");
Object key = map.keySet().iterator().next();
map.put(key, new WeakReference<>(resources));
} else {//7.0及以上
// still hook Android N Resources, even though it's unnecessary, then nobody will be strange.
//获取宿主进程 ActivityThread.mResourcesManager.mResourceImpls
Map map = (Map) ReflectUtil.getFieldNoException(resManager.getClass(), resManager, "mResourceImpls");
//获取宿主进程 ActivityThread.mResourcesManager.mResourceImpls第一个元素的key
Object key = map.keySet().iterator().next();
//获取新建的resources.mResourcesImpl
Object resourcesImpl = ReflectUtil.getFieldNoException(Resources.class, resources, "mResourcesImpl");
//获取宿主进程 ActivityThread.mResourcesManager.mResourceImpls第一个元素的value替换为新建的resources.mResourcesImpl
map.put(key, new WeakReference<>(resourcesImpl));
}
} catch (Exception e) {
e.printStackTrace();
}
}
private static boolean isMiUi(Resources resources) {
return resources.getClass().getName().equals("android.content.res.MiuiResources");
}
private static boolean isVivo(Resources resources) {
return resources.getClass().getName().equals("android.content.res.VivoResources");
}
private static boolean isNubia(Resources resources) {
return resources.getClass().getName().equals("android.content.res.NubiaResources");
}
private static boolean isNotRawResources(Resources resources) {
return !resources.getClass().getName().equals("android.content.res.Resources");
}
private static final class MiUiResourcesCompat {
private static Resources createResources(Resources hostResources, AssetManager assetManager) throws Exception {
Class resourcesClazz = Class.forName("android.content.res.MiuiResources");
Resources newResources = (Resources) ReflectUtil.invokeConstructor(resourcesClazz,
new Class[]{AssetManager.class, DisplayMetrics.class, Configuration.class},
new Object[]{assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration()});
return newResources;
}
}
private static final class VivoResourcesCompat {
private static Resources createResources(Context hostContext, Resources hostResources, AssetManager assetManager) throws Exception {
Class resourcesClazz = Class.forName("android.content.res.VivoResources");
Resources newResources = (Resources) ReflectUtil.invokeConstructor(resourcesClazz,
new Class[]{AssetManager.class, DisplayMetrics.class, Configuration.class},
new Object[]{assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration()});
ReflectUtil.invokeNoException(resourcesClazz, newResources, "init",
new Class[]{String.class}, hostContext.getPackageName());
Object themeValues = ReflectUtil.getFieldNoException(resourcesClazz, hostResources, "mThemeValues");
ReflectUtil.setFieldNoException(resourcesClazz, newResources, "mThemeValues", themeValues);
return newResources;
}
}
private static final class NubiaResourcesCompat {
private static Resources createResources(Resources hostResources, AssetManager assetManager) throws Exception {
Class resourcesClazz = Class.forName("android.content.res.NubiaResources");
Resources newResources = (Resources) ReflectUtil.invokeConstructor(resourcesClazz,
new Class[]{AssetManager.class, DisplayMetrics.class, Configuration.class},
new Object[]{assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration()});
return newResources;
}
}
private static final class AdaptationResourcesCompat {
private static Resources createResources(Resources hostResources, AssetManager assetManager) throws Exception {
Resources newResources;
try {
Class resourcesClazz = hostResources.getClass();
newResources = (Resources) ReflectUtil.invokeConstructor(resourcesClazz,
new Class[]{AssetManager.class, DisplayMetrics.class, Configuration.class},
new Object[]{assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration()});
} catch (Exception e) {
newResources = new Resources(assetManager, hostResources.getDisplayMetrics(), hostResources.getConfiguration());
}
return newResources;
}
}
}
VAInstrumentation，对activity的启动做处理
/**
* 宿主进程的ActivityThread.mInstrumentation对象的静态代理，
* 在activity启动时，替换Activity的 mResources、application、Context对象，替换成处理过的resource、宿主application、宿主context
* 由此实现插件在宿主中启动，跟宿主启动自身activity达到相同的效果
*/
public class VAInstrumentation extends Instrumentation implements Handler.Callback {
public static final String TAG = "VAInstrumentation";
public static final int LAUNCH_ACTIVITY = 100;
private Instrumentation mBase;//这是宿主进程的ActivityThread.mInstrumentation对象的引用
PluginManager mPluginManager;
public VAInstrumentation(PluginManager pluginManager, Instrumentation base) {
this.mPluginManager = pluginManager;
this.mBase = base;
}
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
mPluginManager.getComponentsHandler().transformIntentToExplicitAsNeeded(intent);
// null component is an implicitly intent
if (intent.getComponent() != null) {
Log.i(TAG, String.format("execStartActivity[%s : %s]", intent.getComponent().getPackageName(),
intent.getComponent().getClassName()));
// resolve intent with Stub Activity if needed
this.mPluginManager.getComponentsHandler().markIntentIfNeeded(intent);
}
ActivityResult result = realExecStartActivity(who, contextThread, token, target,
intent, requestCode, options);
return result;
}
private ActivityResult realExecStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
ActivityResult result = null;
try {
Class[] parameterTypes = {Context.class, IBinder.class, IBinder.class, Activity.class, Intent.class,
int.class, Bundle.class};
result = (ActivityResult)ReflectUtil.invoke(Instrumentation.class, mBase,
"execStartActivity", parameterTypes,
who, contextThread, token, target, intent, requestCode, options);
} catch (Exception e) {
if (e.getCause() instanceof ActivityNotFoundException) {
throw (ActivityNotFoundException) e.getCause();
}
e.printStackTrace();
}
return result;
}
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Fragment target,
Intent intent, int requestCode, Bundle options) {
mPluginManager.getComponentsHandler().transformIntentToExplicitAsNeeded(intent);
// null component is an implicitly intent
if (intent.getComponent() != null) {
Log.i(TAG, String.format("execStartActivity[%s : %s]", intent.getComponent().getPackageName(),
intent.getComponent().getClassName()));
// resolve intent with Stub Activity if needed
this.mPluginManager.getComponentsHandler().markIntentIfNeeded(intent);
}
ActivityResult result = realExecStartActivity(who, contextThread, token, target,
intent, requestCode, options);
return result;
}
private ActivityResult realExecStartActivity(
Context who, IBinder contextThread, IBinder token, Fragment target,
Intent intent, int requestCode, Bundle options) {
ActivityResult result = null;
try {
Class[] parameterTypes = {Context.class, IBinder.class, IBinder.class, Fragment.class, Intent.class,
int.class, Bundle.class};
result = (ActivityResult)ReflectUtil.invoke(Instrumentation.class, mBase,
"execStartActivity", parameterTypes,
who, contextThread, token, target, intent, requestCode, options);
} catch (Exception e) {
if (e.getCause() instanceof ActivityNotFoundException) {
throw (ActivityNotFoundException) e.getCause();
}
e.printStackTrace();
}
return result;
}
private ActivityResult realExecStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
ActivityResult result = null;
try {
Class[] parameterTypes = {Context.class, IBinder.class, IBinder.class, String.class, Intent.class,
int.class, Bundle.class};
result = (ActivityResult)ReflectUtil.invoke(Instrumentation.class, mBase,
"execStartActivity", parameterTypes,
who, contextThread, token, target, intent, requestCode, options);
} catch (Exception e) {
if (e.getCause() instanceof ActivityNotFoundException) {
throw (ActivityNotFoundException) e.getCause();
}
e.printStackTrace();
}
return result;
}
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
mPluginManager.getComponentsHandler().transformIntentToExplicitAsNeeded(intent);
// null component is an implicitly intent
if (intent.getComponent() != null) {
Log.i(TAG, String.format("execStartActivity[%s : %s]", intent.getComponent().getPackageName(),
intent.getComponent().getClassName()));
// resolve intent with Stub Activity if needed
this.mPluginManager.getComponentsHandler().markIntentIfNeeded(intent);
}
ActivityResult result = realExecStartActivity(who, contextThread, token, target,
intent, requestCode, options);
return null;
}
/**
* 启动activity前，会先调用newActivity创建目标activity实例
* performLaunchActivity()中
* 1、newActivity创建目标activity实例
* 2、创建application
* 3、createBaseContextForActivity(r, activity);//出现问题的地点
* 在createBaseContextForActivity 方法中创建出来的ContextImpl appContext 使用的是宿主的Resources，
* 如果不进行处理紧接着Activity会走入onCreate的生命周期中，此时插件加载资源的时候还是使用的宿主的资源，
* 而不是我们特意为插件所创建出来的Resources对象，则会发生找不到资源的问题
* 如果使用淘宝的方案加载资源，则不需要在这里替换mResources，因为淘宝方案是让宿主assetManager对象重新初始化和加载宿主与插件资源
*/
@Override
public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
try {
cl.loadClass(className);
} catch (ClassNotFoundException e) {
ComponentName component = PluginUtil.getComponent(intent);
LoadedPlugin plugin = this.mPluginManager.getLoadedPlugin(component);
String targetClassName = component.getClassName();
Log.i(TAG, String.format("newActivity[%s : %s/%s]", className, component.getPackageName(), targetClassName));
if (plugin != null) {//通过宿主进程的mBase创建的activity
Activity activity = mBase.newActivity(plugin.getClassLoader(), targetClassName, intent);
activity.setIntent(intent);
try {
// for 4.1+ 把activity的mResources替换成插件的resources对象
ReflectUtil.setField(ContextThemeWrapper.class, activity, "mResources", plugin.getResources());
} catch (Exception ignored) {
// ignored.
}
return activity;
}
}
return mBase.newActivity(cl, className, intent);
}
@Override
public void callActivityOnCreate(Activity activity, Bundle icicle) {
final Intent intent = activity.getIntent();
if (PluginUtil.isIntentFromPlugin(intent)) {
Context base = activity.getBaseContext();
try {
LoadedPlugin plugin = this.mPluginManager.getLoadedPlugin(intent);
ReflectUtil.setField(base.getClass(), base, "mResources", plugin.getResources());
ReflectUtil.setField(ContextWrapper.class, activity, "mBase", plugin.getPluginContext());
ReflectUtil.setField(Activity.class, activity, "mApplication", plugin.getApplication());
ReflectUtil.setFieldNoException(ContextThemeWrapper.class, activity, "mBase", plugin.getPluginContext());
// set screenOrientation
ActivityInfo activityInfo = plugin.getActivityInfo(PluginUtil.getComponent(intent));
if (activityInfo.screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
activity.setRequestedOrientation(activityInfo.screenOrientation);
}
} catch (Exception e) {
e.printStackTrace();
}
}
mBase.callActivityOnCreate(activity, icicle);
}
@Override
public boolean handleMessage(Message msg) {
if (msg.what == LAUNCH_ACTIVITY) {
// ActivityClientRecord r
Object r = msg.obj;
try {
Intent intent = (Intent) ReflectUtil.getField(r.getClass(), r, "intent");
intent.setExtrasClassLoader(VAInstrumentation.class.getClassLoader());
ActivityInfo activityInfo = (ActivityInfo) ReflectUtil.getField(r.getClass(), r, "activityInfo");
if (PluginUtil.isIntentFromPlugin(intent)) {
int theme = PluginUtil.getTheme(mPluginManager.getHostContext(), intent);
if (theme != 0) {
Log.i(TAG, "resolve theme, current theme:" + activityInfo.theme + " after :0x" + Integer.toHexString(theme));
activityInfo.theme = theme;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
return false;
}
@Override
public Context getContext() {
return mBase.getContext();
}
@Override
public Context getTargetContext() {
return mBase.getTargetContext();
}
@Override
public ComponentName getComponentName() {
return mBase.getComponentName();
}
}
ComponentsHandler，通过动态代理Hook ActivityManageProxy，注入AMSProxy的操作
public class ComponentsHandler {
public static final String TAG = "PluginManager";
private Context mContext;//宿主进程全局上下文引用
private PluginManager mPluginManager;//插件管理器
private StubActivityInfo mStubActivityInfo = new StubActivityInfo();//用于欺上瞒下的代理Activity生成器
private ArrayMap<ComponentName, Service> mServices = new ArrayMap<ComponentName, Service>();
private ArrayMap<IBinder, Intent> mBoundServices = new ArrayMap<IBinder, Intent>();
private ArrayMap<Service, AtomicInteger> mServiceCounters = new ArrayMap<Service, AtomicInteger>();
public ComponentsHandler(PluginManager pluginManager) {
mPluginManager = pluginManager;
mContext = pluginManager.getHostContext();
}
/**
* transform intent from implicit to explicit
*/
public Intent transformIntentToExplicitAsNeeded(Intent intent) {
ComponentName component = intent.getComponent();
if (component == null
|| component.getPackageName().equals(mContext.getPackageName())) {
ResolveInfo info = mPluginManager.resolveActivity(intent);
if (info != null && info.activityInfo != null) {
component = new ComponentName(info.activityInfo.packageName, info.activityInfo.name);
intent.setComponent(component);
}
}
return intent;
}
public void markIntentIfNeeded(Intent intent) {
if (intent.getComponent() == null) {
return;
}
String targetPackageName = intent.getComponent().getPackageName();
String targetClassName = intent.getComponent().getClassName();
// search map and return specific launchmode stub activity
if (!targetPackageName.equals(mContext.getPackageName()) && mPluginManager.getLoadedPlugin(targetPackageName) != null) {
intent.putExtra(Constants.KEY_IS_PLUGIN, true);
intent.putExtra(Constants.KEY_TARGET_PACKAGE, targetPackageName);
intent.putExtra(Constants.KEY_TARGET_ACTIVITY, targetClassName);
dispatchStubActivity(intent);
}
}
private void dispatchStubActivity(Intent intent) {
ComponentName component = intent.getComponent();
String targetClassName = intent.getComponent().getClassName();
LoadedPlugin loadedPlugin = mPluginManager.getLoadedPlugin(intent);
ActivityInfo info = loadedPlugin.getActivityInfo(component);
if (info == null) {
throw new RuntimeException("can not find " + component);
}
int launchMode = info.launchMode;
Resources.Theme themeObj = loadedPlugin.getResources().newTheme();
themeObj.applyStyle(info.theme, true);
String stubActivity = mStubActivityInfo.getStubActivity(targetClassName, launchMode, themeObj);
Log.i(TAG, String.format("dispatchStubActivity,[%s -> %s]", targetClassName, stubActivity));
intent.setClassName(mContext, stubActivity);
}
public AtomicInteger getServiceCounter(Service service) {
return this.mServiceCounters.get(service);
}
/**
* Retrieve the started service by component name
*
* @param component
* @return
*/
public Service getService(ComponentName component) {
return this.mServices.get(component);
}
/**
* Put the started service into service registry, and then increase the counter associate with
* the service
*
* @param component
* @param service
*/
public void rememberService(ComponentName component, Service service) {
synchronized (this.mServices) {
this.mServices.put(component, service);
this.mServiceCounters.put(service, new AtomicInteger(0));
}
}
/**
* Remove the service from service registry
*
* @param component
* @return
*/
public Service forgetService(ComponentName component) {
synchronized (this.mServices) {
Service service = this.mServices.remove(component);
this.mServiceCounters.remove(service);
return service;
}
}
/**
* Remove the bound service from service registry
*
* @param iServiceConnection IServiceConnection binder when unbindService
* @return
*/
public Intent forgetIServiceConnection(IBinder iServiceConnection) {
synchronized (this.mBoundServices) {
Intent intent = this.mBoundServices.remove(iServiceConnection);
return intent;
}
}
/**
* save the bound service
* @param iServiceConnection IServiceConnection binder when bindService
* @return
*/
public void remberIServiceConnection(IBinder iServiceConnection, Intent intent) {
synchronized (this.mBoundServices) {
mBoundServices.put(iServiceConnection, intent);
}
}
/**
* Check if a started service with the specified component exists in the registry
* @param component
* @return
*/
public boolean isServiceAvailable(ComponentName component) {
return this.mServices.containsKey(component);
}
}StubActivityInfo生成欺骗AMS的代理Activity
/**
* 用于根据传入的参数生成欺骗AMS的代理Activity
* Created by renyugang on 16/8/15.
*/
class StubActivityInfo {
public static final int MAX_COUNT_STANDARD = 1;
public static final int MAX_COUNT_SINGLETOP = 8;
public static final int MAX_COUNT_SINGLETASK = 8;
public static final int MAX_COUNT_SINGLEINSTANCE = 8;
public static final String corePackage = "com.didi.virtualapk.core";
public static final String STUB_ACTIVITY_STANDARD = "%s.A$%d";
public static final String STUB_ACTIVITY_SINGLETOP = "%s.B$%d";
public static final String STUB_ACTIVITY_SINGLETASK = "%s.C$%d";
public static final String STUB_ACTIVITY_SINGLEINSTANCE = "%s.D$%d";
public final int usedStandardStubActivity = 1;
public int usedSingleTopStubActivity = 0;
public int usedSingleTaskStubActivity = 0;
public int usedSingleInstanceStubActivity = 0;
private HashMap<String, String> mCachedStubActivity = new HashMap<>();
public String getStubActivity(String className, int launchMode, Theme theme) {
String stubActivity= mCachedStubActivity.get(className);
if (stubActivity != null) {
return stubActivity;
}
TypedArray array = theme.obtainStyledAttributes(new int[]{
android.R.attr.windowIsTranslucent,
android.R.attr.windowBackground
});
boolean windowIsTranslucent = array.getBoolean(0, false);
array.recycle();
if (Constants.DEBUG) {
Log.d("StubActivityInfo", "getStubActivity, is transparent theme ? " + windowIsTranslucent);
}
stubActivity = String.format(STUB_ACTIVITY_STANDARD, corePackage, usedStandardStubActivity);
switch (launchMode) {
case ActivityInfo.LAUNCH_MULTIPLE: {
stubActivity = String.format(STUB_ACTIVITY_STANDARD, corePackage, usedStandardStubActivity);
if (windowIsTranslucent) {
stubActivity = String.format(STUB_ACTIVITY_STANDARD, corePackage, 2);
}
break;
}
case ActivityInfo.LAUNCH_SINGLE_TOP: {
usedSingleTopStubActivity = usedSingleTopStubActivity % MAX_COUNT_SINGLETOP + 1;
stubActivity = String.format(STUB_ACTIVITY_SINGLETOP, corePackage, usedSingleTopStubActivity);
break;
}
case ActivityInfo.LAUNCH_SINGLE_TASK: {
usedSingleTaskStubActivity = usedSingleTaskStubActivity % MAX_COUNT_SINGLETASK + 1;
stubActivity = String.format(STUB_ACTIVITY_SINGLETASK, corePackage, usedSingleTaskStubActivity);
break;
}
case ActivityInfo.LAUNCH_SINGLE_INSTANCE: {
usedSingleInstanceStubActivity = usedSingleInstanceStubActivity % MAX_COUNT_SINGLEINSTANCE + 1;
stubActivity = String.format(STUB_ACTIVITY_SINGLEINSTANCE, corePackage, usedSingleInstanceStubActivity);
break;
}
default:break;
}
mCachedStubActivity.put(className, stubActivity);
return stubActivity;
}
}Dex、so的合并
public class DexUtil {
private static boolean sHasInsertedNativeLibrary = false;
/** 把dexClassLoader加载的dex跟宿主进程的ClassLoader加载的dex合并在一起，都放入宿主进程的ClassLoader.pathList.dexElements中*/
public static void insertDex(DexClassLoader dexClassLoader) throws Exception {
Object baseDexElements = getDexElements(getPathList(getPathClassLoader()));
Object newDexElements = getDexElements(getPathList(dexClassLoader));
Object allDexElements = combineArray(baseDexElements, newDexElements);
Object pathList = getPathList(getPathClassLoader());
ReflectUtil.setField(pathList.getClass(), pathList, "dexElements", allDexElements);
//合并宿主与插件的nativeLib
insertNativeLibrary(dexClassLoader);
}
private static PathClassLoader getPathClassLoader() {
PathClassLoader pathClassLoader = (PathClassLoader) DexUtil.class.getClassLoader();
return pathClassLoader;
}
private static Object getDexElements(Object pathList) throws Exception {
return ReflectUtil.getField(pathList.getClass(), pathList, "dexElements");
}
private static Object getPathList(Object baseDexClassLoader) throws Exception {
return ReflectUtil.getField(Class.forName("dalvik.system.BaseDexClassLoader"), baseDexClassLoader, "pathList");
}
private static Object combineArray(Object firstArray, Object secondArray) {
Class<?> localClass = firstArray.getClass().getComponentType();
int firstArrayLength = Array.getLength(firstArray);
int allLength = firstArrayLength + Array.getLength(secondArray);
Object result = Array.newInstance(localClass, allLength);
for (int k = 0; k < allLength; ++k) {
if (k < firstArrayLength) {
Array.set(result, k, Array.get(firstArray, k));
} else {
Array.set(result, k, Array.get(secondArray, k - firstArrayLength));
}
}
return result;
}
/** 合并宿主与插件的nativeLib */
private static synchronized void insertNativeLibrary(DexClassLoader dexClassLoader) throws Exception {
if (sHasInsertedNativeLibrary) {
return;
}
sHasInsertedNativeLibrary = true;
Object basePathList = getPathList(getPathClassLoader());
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP_MR1) {//6.0及以上系统
//nativeLibraryDirectories是 DexPathList.class中用于保存nativeLib文件的"文件夹集合"，注意是文件夹
//获取宿主进程存放nativeLib的文件夹集合 /** List of application native library directories. */
List<File> nativeLibraryDirectories = (List<File>) ReflectUtil.getField(basePathList.getClass(), basePathList, "nativeLibraryDirectories");
//把自定义的 Constants.NATIVE_DIR 文件夹添加到 宿主进程nativeLib文件夹集合中，后面只需要把插件nativeLib放到该文件夹就可以了
nativeLibraryDirectories.add(Systems.getContext().getDir(Constants.NATIVE_DIR, Context.MODE_PRIVATE));
//获取宿主进程存放nativeLib路径的Element数组 /** List of native library path elements. */
Object baseNativeLibraryPathElements = ReflectUtil.getField(basePathList.getClass(), basePathList, "nativeLibraryPathElements");
//宿主进程nativeLib数量
final int baseArrayLength = Array.getLength(baseNativeLibraryPathElements);
//插件的PathList
Object newPathList = getPathList(dexClassLoader);
//插件的nativeLib文件路径的Element数组 这个Element是DexPathList.class文件中定义的一个静态类/*Element of the dex/resource file path*/
Object newNativeLibraryPathElements = ReflectUtil.getField(newPathList.getClass(), newPathList, "nativeLibraryPathElements");
Class<?> elementClass = newNativeLibraryPathElements.getClass().getComponentType();
//创建一个新的Element数组，长度为宿主Element数组长度+1
Object allNativeLibraryPathElements = Array.newInstance(elementClass, baseArrayLength + 1);
//把宿主进程nativeLib的Element数组拷贝的新的Element数组中
System.arraycopy(baseNativeLibraryPathElements, 0, allNativeLibraryPathElements, 0, baseArrayLength);
Field soPathField;
if (Build.VERSION.SDK_INT >= 26) {//8.0及以上版本，获取path字段
soPathField = elementClass.getDeclaredField("path");
} else {// >=6.0 && <8.0 获取dir字段
soPathField = elementClass.getDeclaredField("dir");
}
soPathField.setAccessible(true);
//获取插件nativeLib的Element数组长度
final int newArrayLength = Array.getLength(newNativeLibraryPathElements);
for (int i = 0; i < newArrayLength; i++) {
//获取插件nativeLib的每个元素element
Object element = Array.get(newNativeLibraryPathElements, i);
//获取每个element的path/dir
String dir = ((File)soPathField.get(element)).getAbsolutePath();
if (dir.contains(Constants.NATIVE_DIR)) {
Array.set(allNativeLibraryPathElements, baseArrayLength, element);
break;
}
}
ReflectUtil.setField(basePathList.getClass(), basePathList, "nativeLibraryPathElements", allNativeLibraryPathElements);
} else {//5.1及以下版本
File[] nativeLibraryDirectories = (File[]) ReflectUtil.getFieldNoException(basePathList.getClass(), basePathList, "nativeLibraryDirectories");
final int N = nativeLibraryDirectories.length;
File[] newNativeLibraryDirectories = new File[N + 1];
System.arraycopy(nativeLibraryDirectories, 0, newNativeLibraryDirectories, 0, N);
newNativeLibraryDirectories[N] = Systems.getContext().getDir(Constants.NATIVE_DIR, Context.MODE_PRIVATE);
ReflectUtil.setField(basePathList.getClass(), basePathList, "nativeLibraryDirectories", newNativeLibraryDirectories);
}
}
}