devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android插件化原理分析(基于Neptune框架)

作者：凡人多烦事01 | 2024-03-24 07:09:37

赞

踩

android 插件化架构图

前言

Android插件化不算是一门新技术，发展了有一些年头了。不同公司的插件化方案大体原理上很相似。本文通过阅读爱奇艺的Neptune框架来介绍插件化的整体思路和流程。

插件化基础知识点

插件应用安装

所谓的插件其实本质上也是一个apk。在原生的Android应用中，apk在运行时会被映射成一个LoadedApk对象。插件在安装之后也会被映射成类似的PluginLoadedApk对象，统一管理插件的相关信息。

  1. public class PluginLoadedApk {
  2.     public static final ConcurrentMap<String, Vector<Method>> sMethods = new ConcurrentHashMap<String, Vector<Method>>(1);
  3.     private static final String TAG = "PluginLoadedApk";
  4.     /* 保存注入到宿主ClassLoader的插件 */
  5.     private static Set<String> sInjectedPlugins = Collections.synchronizedSet(new HashSet<String>());
  6.     /* 保存所有的插件ClassLoader */
  7.     private static Map<String, DexClassLoader> sAllPluginClassLoader = new ConcurrentHashMap<>();
  8.  
  9.     /* 宿主的Context */
  10.     private final Context mHostContext;
  11.     /* 宿主的ClassLoader */
  12.     private final ClassLoader mHostClassLoader;
  13.     /* 宿主的Resource对象 */
  14.     private final Resources mHostResource;
  15.     /* 宿主的包名 */
  16.     private final String mHostPackageName;
  17.     /* 插件的路径 */
  18.     private final String mPluginPath;
  19.     /* 插件运行的进程名 */
  20.     private final String mProcessName;
  21.     /* 插件ClassLoader的parent */
  22.     private ClassLoader mParent;
  23.     /* 插件的类加载器 */
  24.     private DexClassLoader mPluginClassLoader;
  25.     /* 插件的Resource对象 */
  26.     private Resources mPluginResource;
  27.     /* 插件的AssetManager对象 */
  28.     private AssetManager mPluginAssetManager;
  29.     /* 插件的全局默认主题 */
  30.     private Resources.Theme mPluginTheme;
  31.     /* 插件的详细信息，主要通过解析AndroidManifest.xml获得 */
  32.     private PluginPackageInfo mPluginPackageInfo;
  33.     /* 插件工程的包名 */
  34.     private String mPluginPackageName;
  35.     /* 插件的Application */
  36.     private Application mPluginApplication;
  37.     /* 自定义插件Context,主要用来改写其中的一些方法从而改变插件行为 */
  38.     private PluginContextWrapper mPluginAppContext;
  39.     /* 自定义Instrumentation，对Activity跳转进行拦截 */
  40.     private PluginInstrument mPluginInstrument;
  41.     ...
  42. }    
  43. 复制代码

插件的安装分为内置插件（asset目录，sdcard）和线上插件两部分。

  • 内置插件：
    • 约定存放在assets/pluginapp/<plugin_pkg_name>.apk形式，安装时解压到/data/data/<host_pkg_name>/app_pluginapp目录
    • sdcard插件，允许调试模式下安装，以<plugin_pkg_name>.apk命名
  • 线上插件：直接将插件下载到sdcard目录上，然后拷贝到/data/data/<host_pkg_name>/app_pluginapp目录下；为了减少拷贝操作，可以直接下载到/data/data/<hots_pkg_name>/app_pluginapp目录；

插件的安装通过运行在独立进程的Service完成，主要防止部分机型dexopt hang住主进程。

dexopt

Android根据系统版本不同会采用两种虚拟机。Dalvik虚拟机是JIT方式解释执行dex字节码；ART虚拟机是AOT方式将dex字节码转化为oat机器码。

  • Dalvik是运行时解释dex文件，安装比较快，开启应用比较慢，应用占用空间小
  • ART是安装的时候字节码预编译成机器码存储在本地，执行的时候直接就可以运行的，安装慢，开启应用快，占用空间大；

如果当前运行在Dalvik虚拟机下，Dalvik会对classes.dex进行一次“翻译”，“翻译”的过程也就是守护进程installd的函数dexopt来对dex字节码进行优化，实际上也就是由dex文件生成odex文件，最终odex文件被保存在手机的VM缓存目录data/dalvik-cache下（注意！这里所生成的odex文件依旧是以dex为后缀名，格式如：system@priv-app@Settings@Settings.apk@classes.dex）。如果当前运行于ART模式下， ART同样会在首次进入系统的时候调用/system/bin/dexopt（此处应该是dex2oat工具吧）工具来将dex字节码翻译成本地机器码，保存在data/dalvik-cache下。 那么这里需要注意的是，无论是对dex字节码进行优化，还是将dex字节码翻译成本地机器码，最终得到的结果都是保存在相同名称的一个odex文件里面的，但是前者对应的是一个.dex文件（表示这是一个优化过的dex），后者对应的是一个.oat文件。通过这种方式，原来任何通过绝对路径引用了该odex文件的代码就都不需要修改了。 由于在系统首次启动时会对应用进行安装，那么在预置APK比较多的情况下，将会大大增加系统首次启动的时间。

对于插件安装来说，插件的安装通过运行在独立进程的Service完成，主要防止部分机型dexopt hang住主进程。

插件安装过程主要执行以下几步：

  1. 拷贝apk到内置存储区，重命名为<plugin_pkg_name>.apk
  2. 解压apk中的so库到app_pluginapp/<plugin_pkg_name>/lib目录
  3. dexopt优化插件dex，Android 7.0以上第一次会使用解释模式执行dex，优化加载速度

类加载

Java中的类都是通过ClassLoader加载的，而Android中类的加载也离不开ClassLoadder。在Android系统中，主要的ClassLoader有三个：

  • BootClassLoader：Android系统启动时用来预加载常用的类
  • PathClassLoader：用来加载系统和应用程序中的类，如果是非系统应用程序类，则会加载/data/app目录下的dex、apk或jar文件
  • DexClassLoader：可以加载指定路径的dex、apk或jar文件，支持从SD卡进行加载，是插件化的技术基础

类加载的双亲委派机制

某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。

关于插件中类的加载机制有两种处理方式，一种是单类加载机制，另一种是多类加载机制；单类加载器机制，即所有插件APP的类都通过宿主的ClassLoader（即PathClassLoader）进行加载，与MultiDex、Qzone热修复技术类似，通过Dex前插后者后插的方式实现。采用单类加载器模型，随着业务团队和插件的增加，很容易出现类重复问题，无法保证所有类都是独一无二的。多类加载器机制是指每个插件都由一个新的类加载器实例来加载，组件间的类是完全隔离，不能直接互相访问。

利用ClassLoader的双亲委派机制，多类加载有两种思路：

  • 自定义代理的ClassLoader设置为PathClassLoader的父类加载器，那么自定义的类加载器就能代理所有的类加载行为；在代理ClassLoader内部做类加载的逻辑分发，先尝试从宿主的ClassLoader加载，再尝试插件的ClassLoader加载。(好处：只需要在启动时hook ClassLoader，添加DelegateClassLoader，后续的类加载由DelegateClassLoader分发；对于未加载的插件，可以通过包名匹配，先触发插件加载，再加载类)
  • 每个PluginLoadedApk维护一个PluginClassLoader实例，其父ClassLoader是PathClassLoader；在类加载时，先尝试从宿主的ClassLoader加载，再尝试本插件的ClassLoader加载。（好处：每个插件维护自己的PluginLoadedApk，不存在分发，类隔离做的更好）

资源加载

Android APP运行除了类还有资源，运行时需要加载资源；对于Android来说，资源是通过AssetManager和Resources这两个类管理。App在运行时查找资源是通过当前Context的Resource实例中查找，在Resource内部是通过AssetManager管理当前的资源，AssetManager维护了资源包路径的数组。插件化的原理，就是将插件的资源路径添加到AssetManager的资源路径数组中，通过反射AssetManager的隐藏方法addAssetPath实现插件资源的加载。

  1. try{
  2.     AssetManager am = AssetManager.class.newInstance();
  3.     Method addAssetPath = AssetManager.class.getDeclaredMethod("addAssetPath", String.class);
  4.     addAssetPath.setAccessible(true);
  5.     addAssetPath.invoke(am, pluginApkPath);
  6.     Resources pluginResources = new Resources(am, hostResource.getDisplayMetrics(), hostResources.getConfiguration());
  7. } catch (Exception e) {
  8.     e.printStackTrace();
  9. }
  10. 复制代码

各种插件化方案的资源加载原理都是一样，区别主要在于不同插件的资源管理，是公用一套资源还是插件独立资源，插件和宿主的资源访问ID冲突问题。

  • 公用一套资源需要采用固定资源id及ID分段机制避免冲突
  • 独立资源方案，不同插件管理自己的资源

插件化中资源使用限制

限制：插件不能使用自己的转场动画，只能使用宿主、系统定义的转场动画。

转场动画最终会调用到IActivityManager,发起IPC请求，与AMS交互

  1.     public void overridePendingTransition(IBinder token, String packageName,
  2.             int enterAnim, int exitAnim) throws RemoteException;
  3. 复制代码

Apk打包流程

先附上两张Android原生打包流程图



在插件编译打包时，需要完成以下几件事：

  • 插件的资源和宿主的资源通过不同的资源分段区分
  • 在插件化中，如果插件需要引用宿主的资源，则需要将宿主的资源id进行固定
  • 处理插件aapt的编译产物，不将宿主的资源打入apk中
  • 处理Manifest文件，将占坑的四大组件写入Manifest文件中
  • 在字节码层面对代码做修改

Hook点

  • Hook MergeResources Task，将public.xml文件拷贝至资源merge完成的目录
  • Hook ProcessAndroidResources Task，修改生成的arsc文件。
  • Hook ManifestProcessorTask， 在Manifest中插入特定信息。
  • Hook dexTask/Transform，最源代码的修改

四大组件的插件化

Activity的插件化

Activity启动可以分为两个阶段：往AMS发起启动Activity的请求、AMS校验后执行Activity启动。

往AMS发起请求

在Android 8.0（api 26）以下，应用往AMS发起启动Activity请求的流程如上。在Android 8.0及以上版本，AMN、AMP已经被弃用，而是使用ActivityManager类；参考文章。

Hook点：
  • Hook Instrumentation类，代理execStartActivity方法
  • Hook AMN（<26）/ActivityManager（>=26），动态代理IActivityManager接口的实例对象
AMS校验后启动Activity

Android P(api 28)对Activity的启动过程做了修改；在Android P之前，是在H类的handleMessage方法的switch分支语句中，有专门处理启动Activity的逻辑

  1.  public void handleMessage(Message msg) {
  2.             switch (msg.what) {
  3.                 case LAUNCH_ACTIVITY: {
  4.                     final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
  5.  
  6.                     r.packageInfo = getPackageInfoNoCheck(
  7.                             r.activityInfo.applicationInfo, r.compatInfo);
  8.                     handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
  9.                 } break;
  10.             
  11.             //以下省略很多代码
  12.             }
  13.         }
  14. 复制代码

在Android P中，启动Activity的这部分逻辑，被转移到了LaunchActivityItem类的execute方法中

  1. public class LaunchActivityItem extends ClientTransactionItem {
  2.  
  3.     @Override
  4.     public void execute(ClientTransactionHandler client, IBinder token,
  5.             PendingTransactionActions pendingActions) {
  6.         ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
  7.                 mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
  8.                 mPendingResults, mPendingNewIntents, mIsForward,
  9.                 mProfilerInfo, client);
  10.         client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
  11.     }
  12. }
  13. 复制代码

Android P把H类中的100-109这10个消息都删除了，取而代之的是159这个消息，名为EXECUTE_TRANSACTION。收敛了Activity相关的message分发。

Hook点：
  • Hook H类，将占坑Activity替换成真实的Activity（需要做Android P的适配）
  • Hook Instrumentation类，替换成自定义的Instrument，重写newActivity、callActivityOnCreate等方法

Service的插件化

Service启动可以分为两个阶段：往AMS发起启动Service的请求、AMS校验后执行Service启动。

往AMS发起启动Service的请求

在Android 8.0（api 26）以下，应用往AMS发起启动Service请求的流程如上。在Android 8.0及以上版本，AMN、AMP已经被弃用，而是使用ActivityManager类。

Hook点
  • Hook ContextWrapper；替换成自定义的ContextWrapper，将Service替换成占坑的Service
  • Hook AMN（<26）/ActivityManager（>=26），动态代理IActivityManager接口的实例对象
AMS校验后执行Service启动

Hook点：
  • 在占坑Service的onStartCommand提取真实Service信息，并分发执行真实Service逻辑
  • Hook handleServiceCreate方法，发射获取ServiceInfo，修改ServiceInfo的name字段为真实Service的名字。加载真实的Service类。

BroadCastReceiver插件化

广播分为静态广播、动态广播。动态广播在运行时向AMS注册相关信息。

Hook点：
  • 静态广播转换为动态广播

ContentProvider插件化

Hook点：
  • Hook AMN（<26）/ActivityManager（>=26），动态代理IActivityManager接口的实例对象；将目标ContentProvider的信息放在query参数中

Neptune源码分析

Neptune类

Neptune类是整个插件系统的入口类，主要方法如下

  • init()方法
  1. /**
  2.      * 初始化Neptune插件环境
  3.      *
  4.      * @param application  宿主的Appliction
  5.      * @param config  配置信息
  6.      */
  7.     public static void init(Application application, NeptuneConfig config) {
  8.  
  9.         sHostContext = application;
  10.         sGlobalConfig = config != null ? config
  11.                 : new NeptuneConfig.NeptuneConfigBuilder().build();
  12.  
  13.         PluginDebugLog.setIsDebug(sGlobalConfig.isDebug());
  14.  
  15.         boolean hookInstr = VersionUtils.hasPie() || sGlobalConfig.getSdkMode() != NeptuneConfig.LEGACY_MODE;
  16.         if (hookInstr) {
  17.             //Hook Instrumentation
  18.             hookInstrumentation();
  19.         }
  20.  
  21.         // 调用getInstance()方法会初始化bindService，管理插件安装的Service
  22.         PluginPackageManagerNative.getInstance(sHostContext).setPackageInfoManager(sGlobalConfig.getPluginInfoProvider());
  23.         // 注册插件卸载监听广播
  24.         PluginManager.registerUninstallReceiver(sHostContext);
  25.     }
  26. 复制代码
  • launchPlugin()方法
  1.  /**
  2.      * 启动插件
  3.      *
  4.      * @param mHostContext       主工程的上下文
  5.      * @param mIntent            需要启动的组件的Intent
  6.      * @param mServiceConnection bindService时需要的ServiceConnection,如果不是bindService的方式启动组件，传入Null
  7.      * @param mProcessName       需要启动的插件运行的进程名称,插件方可以在Application的android:process指定
  8.      *                           如果没有指定，则有插件中心分配
  9.      */
  10.     public static void launchPlugin(final Context mHostContext,
  11.                                     final Intent mIntent,
  12.                                     final ServiceConnection mServiceConnection,
  13.                                     final String mProcessName) {
  14.         final String packageName = tryParsePkgName(mHostContext, mIntent);
  15.         if (TextUtils.isEmpty(packageName)) {
  16.             if (null != mHostContext) {
  17.                 deliver(mHostContext, false, mHostContext.getPackageName(), ErrorType.ERROR_PLUGIN_LOAD_NO_PKGNAME_INTENT);
  18.             }
  19.             PluginDebugLog.runtimeLog(TAG, "enterProxy packageName is null return! packageName: " + packageName);
  20.             return;
  21.         }
  22.         // 处理不同进程跳转
  23.         final String targetProcessName = TextUtils.isEmpty(mProcessName) ?
  24.                 ProcessManager.chooseDefaultProcess(mHostContext, packageName) : mProcessName;
  25.         String currentProcess = FileUtils.getCurrentProcessName(mHostContext);
  26.         if (!TextUtils.equals(currentProcess, targetProcessName)) {
  27.             // 启动进程和目标进程不一致，需要先启动目标进程，初始化PluginLoadedApk
  28.             Intent transIntent = new Intent();
  29.             transIntent.setAction(IntentConstant.ACTION_START_PLUGIN);
  30.             //目标进程的Service中重新通过mIntent启动插件
  31.             transIntent.putExtra(IntentConstant.EXTRA_START_INTENT_KEY, mIntent);
  32.             transIntent.putExtra(IntentConstant.EXTRA_TARGET_PROCESS, targetProcessName);
  33.             try {
  34.                 String proxyServiceName = ComponentFinder.matchServiceProxyByFeature(targetProcessName);
  35.                 transIntent.setClass(mHostContext, Class.forName(proxyServiceName));
  36.                 mHostContext.startService(transIntent);
  37.             } catch (ClassNotFoundException e) {
  38.                 e.printStackTrace();
  39.             }
  40.             return;
  41.         }
  42.  
  43.         LinkedBlockingQueue<Intent> cacheIntents = PActivityStackSupervisor.getCachedIntent(packageName);
  44.         //该插件有其他任务排队中，mIntent添加到队尾
  45.         if (cacheIntents != null && cacheIntents.size() > 0) {
  46.             cacheIntents.add(mIntent);
  47.             PluginDebugLog.runtimeLog(TAG, "LoadingMap is not empty, Cache current intent, intent: " + mIntent + ", packageName: " + packageName);
  48.             return;
  49.         }
  50.  
  51.         boolean isLoadAndInit = isPluginLoadedAndInit(packageName);
  52.         if (!isLoadAndInit) {
  53.             if (null == cacheIntents) {
  54.                 cacheIntents = new LinkedBlockingQueue<Intent>();
  55.                 PActivityStackSupervisor.addCachedIntent(packageName, cacheIntents);
  56.             }
  57.             // 缓存这个intent，等待PluginLoadedApk加载到内存之后再启动这个Intent
  58.             PluginDebugLog.runtimeLog(TAG, "Environment is initializing and loading, cache current intent first, intent: " + mIntent);
  59.             cacheIntents.add(mIntent);
  60.         } else {
  61.             PluginDebugLog.runtimeLog(TAG, "Environment is already ready, launch current intent directly: " + mIntent);
  62.             //可以直接启动组件
  63.             readyToStartSpecifyPlugin(mHostContext, mServiceConnection, mIntent, true);
  64.             return;
  65.         }
  66.  
  67.         // 处理插件的依赖关系
  68.         final PluginLiteInfo info = PluginPackageManagerNative.getInstance(mHostContext.getApplicationContext())
  69.                 .getPackageInfo(packageName);
  70.                 //获取插件的依赖关系
  71.         final List<String> mPluginRefs = PluginPackageManagerNative.getInstance(mHostContext)
  72.                 .getPluginRefs(packageName);
  73.         if (info != null && mPluginRefs != null
  74.                 && mPluginRefs.size() > 0) {
  75.             PluginDebugLog.runtimeLog(TAG,
  76.                     "start to check dependence installation size: " + mPluginRefs.size());
  77.             //依赖的总数量
  78.             final AtomicInteger count = new AtomicInteger(mPluginRefs.size());
  79.             for (String pkgName : mPluginRefs) {
  80.                 PluginDebugLog.runtimeLog(TAG, "start to check installation pkgName: " + pkgName);
  81.                 final PluginLiteInfo refInfo = PluginPackageManagerNative.getInstance(mHostContext.getApplicationContext())
  82.                         .getPackageInfo(pkgName);
  83.  
  84.                 PluginPackageManagerNative.getInstance(mHostContext.getApplicationContext()).packageAction(refInfo,
  85.                         new IInstallCallBack.Stub() {
  86.                             @Override
  87.                             public void onPackageInstalled(PluginLiteInfo packageInfo) {
  88.                                 //未ready的依赖数量
  89.                                 count.getAndDecrement();
  90.                                 PluginDebugLog.runtimeLog(TAG, "check installation success pkgName: " + refInfo.packageName);
  91.                                 if (count.get() == 0) {
  92.                                     PluginDebugLog.runtimeLog(TAG,
  93.                                             "start Check installation after check dependence packageName: "
  94.                                                     + packageName);
  95.                                     //真正加载插件
  96.                                     checkPkgInstallationAndLaunch(mHostContext, info, mServiceConnection, mIntent, targetProcessName);
  97.                                 }
  98.                             }
  99.  
  100.                             @Override
  101.                             public void onPackageInstallFail(PluginLiteInfo info, int failReason) throws RemoteException {
  102.                                 PluginDebugLog.runtimeLog(TAG,
  103.                                         "check installation failed pkgName: " + info.packageName + " failReason: " + failReason);
  104.                                 count.set(-1);
  105.                             }
  106.                         });
  107.             }
  108.         } else if (info != null) {
  109.             PluginDebugLog.runtimeLog(TAG, "start Check installation without dependence packageName: " + packageName);
  110.             //真正加载插件
  111.             checkPkgInstallationAndLaunch(mHostContext, info, mServiceConnection, mIntent, targetProcessName);
  112.         } else {
  113.             //异常case
  114.             PluginDebugLog.runtimeLog(TAG, "pluginLiteInfo is null packageName: " + packageName);
  115.             PActivityStackSupervisor.clearLoadingIntent(packageName);
  116.             if (PluginDebugLog.isDebug()) {
  117.                 throw new IllegalStateException("pluginLiteInfo is null when launchPlugin " + packageName);
  118.             }
  119.         }
  120.     }
  121. 复制代码
  1. /**
  2.      * 真正启动一个组件
  3.      *
  4.      * @param mHostContext 主工程Context
  5.      * @param mLoadedApk   需要启动的插件的PluginLoadedApk
  6.      * @param mIntent      需要启动组件的Intent
  7.      * @param mConnection  bindService时需要的ServiceConnection,如果不是bindService的方式启动组件，传入Null
  8.      */
  9.     private static void doRealLaunch(Context mHostContext,
  10.                                      PluginLoadedApk mLoadedApk,
  11.                                      Intent mIntent,
  12.                                      ServiceConnection mConnection) {
  13.  
  14.         String targetClassName = "";
  15.         ComponentName mComponent = mIntent.getComponent();
  16.         if (mComponent != null) {
  17.             //显式启动
  18.             targetClassName = mComponent.getClassName();
  19.             PluginDebugLog.runtimeLog(TAG, "launchIntent_targetClassName:" + targetClassName);
  20.             if (TextUtils.isEmpty(targetClassName)) {
  21.                 targetClassName = mLoadedApk.getPluginPackageInfo().getDefaultActivityName();
  22.             }
  23.         }
  24.  
  25.         String pkgName = mLoadedApk.getPluginPackageName();
  26.         Class<?> targetClass = null;
  27.         if (!TextUtils.isEmpty(targetClassName)
  28.                 && !TextUtils.equals(targetClassName, IntentConstant.EXTRA_VALUE_LOADTARGET_STUB)) {
  29.             try {
  30.                 //插件ClassLoader加载类
  31.                 targetClass = mLoadedApk.getPluginClassLoader().loadClass(targetClassName);
  32.             } catch (Exception e) {
  33.                 deliver(mHostContext, false,
  34.                         pkgName, ErrorType.ERROR_PLUGIN_LOAD_COMP_CLASS);
  35.                 PluginDebugLog.runtimeLog(TAG, "launchIntent loadClass failed for targetClassName: "
  36.                         + targetClassName);
  37.                 executeNext(mLoadedApk, mConnection, mHostContext);
  38.                 return;
  39.             }
  40.         }
  41.  
  42.         String action = mIntent.getAction();
  43.  
  44.         if (TextUtils.equals(action, IntentConstant.ACTION_PLUGIN_INIT)
  45.                 || TextUtils.equals(targetClassName, IntentConstant.EXTRA_VALUE_LOADTARGET_STUB)) {
  46.             PluginDebugLog.runtimeLog(TAG, "launchIntent load target stub!");
  47.             //通知插件初始化完毕
  48.             if (targetClass != null && BroadcastReceiver.class.isAssignableFrom(targetClass)) {
  49.                 Intent newIntent = new Intent(mIntent);
  50.                 newIntent.setComponent(null);
  51.                 newIntent.putExtra(IntentConstant.EXTRA_TARGET_PACKAGE_KEY, pkgName);
  52.                 newIntent.setPackage(mHostContext.getPackageName());
  53.                 //通过广播通知插件加载完成
  54.                 mHostContext.sendBroadcast(newIntent);
  55.             }
  56.             // 表示后台加载，不需要处理该Intent
  57.             executeNext(mLoadedApk, mConnection, mHostContext);
  58.             return;
  59.         }
  60.  
  61.         mLoadedApk.changeLaunchingIntentStatus(true);
  62.         PluginDebugLog.runtimeLog(TAG, "launchIntent_targetClass: " + targetClass);
  63.         if (targetClass != null && Service.class.isAssignableFrom(targetClass)) {
  64.             //处理的是Service, 宿主启动插件Service只能通过显式启动
  65.             ComponentFinder.switchToServiceProxy(mLoadedApk, mIntent, targetClassName);
  66.             if (mConnection == null) {
  67.                 mHostContext.startService(mIntent);
  68.             } else {
  69.                 mHostContext.bindService(mIntent, mConnection,
  70.                         mIntent.getIntExtra(IntentConstant.BIND_SERVICE_FLAGS, Context.BIND_AUTO_CREATE));
  71.             }
  72.         } else {
  73.             //处理的是Activity
  74.             ComponentFinder.switchToActivityProxy(pkgName,
  75.                     mIntent, -1, mHostContext);
  76.             PActivityStackSupervisor.addLoadingIntent(pkgName, mIntent);
  77.             Context lastActivity = null;
  78.             PActivityStackSupervisor mActivityStackSupervisor =
  79.                     mLoadedApk.getActivityStackSupervisor();
  80.             lastActivity = mActivityStackSupervisor.getAvailableActivity();
  81.             if (mHostContext instanceof Activity) {
  82.                 mHostContext.startActivity(mIntent);
  83.             } else if (lastActivity != null) {
  84.                 // Clear the Intent.FLAG_ACTIVITY_NEW_TASK
  85.                 int flag = mIntent.getFlags();
  86.                 flag = flag ^ Intent.FLAG_ACTIVITY_NEW_TASK;
  87.                 mIntent.setFlags(flag);
  88.                 lastActivity.startActivity(mIntent);
  89.             } else {
  90.                 // Add the Intent.FLAG_ACTIVITY_NEW_TASK
  91.                 mIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  92.                 mHostContext.startActivity(mIntent);
  93.             }
  94.         }
  95.         // 执行下一个Intent
  96.         executeNext(mLoadedApk, mConnection, mHostContext);
  97.     }
  98. 复制代码
  1.  /**
  2.      * 异步初始化插件，宿主静默加载插件
  3.      *
  4.      * @deprecated 不建议使用
  5.      */
  6.     @Deprecated
  7.     public static void initPluginAsync(final Context mHostContext,
  8.                                        final String packageName,
  9.                                        final String processName,
  10.                                        final org.qiyi.pluginlibrary.listenter.IPluginStatusListener mListener) {
  11.         // 插件已经加载
  12.         if (PluginManager.isPluginLoadedAndInit(packageName)) {
  13.             if (mListener != null) {
  14.                 mListener.onInitFinished(packageName);
  15.             }
  16.             return;
  17.         }
  18.  
  19.         BroadcastReceiver recv = new BroadcastReceiver() {
  20.             public void onReceive(Context ctx, Intent intent) {
  21.                 String curPkg = IntentUtils.getTargetPackage(intent);
  22.                 if (IntentConstant.ACTION_PLUGIN_INIT.equals(intent.getAction()) && TextUtils.equals(packageName, curPkg)) {
  23.                     PluginDebugLog.runtimeLog(TAG, "收到自定义的广播org.qiyi.pluginapp.action.TARGET_LOADED");
  24.                     //插件初始化结束
  25.                     if (mListener != null) {
  26.                         mListener.onInitFinished(packageName);
  27.                     }
  28.                     mHostContext.getApplicationContext().unregisterReceiver(this);
  29.                 }
  30.             }
  31.         };
  32.         PluginDebugLog.runtimeLog(TAG, "注册自定义广播org.qiyi.pluginapp.action.TARGET_LOADED");
  33.         IntentFilter filter = new IntentFilter();
  34.         filter.addAction(IntentConstant.ACTION_PLUGIN_INIT);
  35.         //注册广播
  36.         mHostContext.getApplicationContext().registerReceiver(recv, filter);
  37.  
  38.         Intent intent = new Intent();
  39.         intent.setAction(IntentConstant.ACTION_PLUGIN_INIT);
  40.         intent.setComponent(new ComponentName(packageName, recv.getClass().getName()));
  41.         //发送一个启动插件的intent
  42.         launchPlugin(mHostContext, intent, processName);
  43.     }
  44. 复制代码

NeptuneInstrument（PluginInstrument）类

Hook系统原生的Instrument，替换成NeptuneInstrument。NeptuneInstrument继承PluginInstrument。 PluginInstrument负责往AMS发送的请求，NeptuneInstrument负责AMS返回的结果处理。

  1. /**
  2.  * 负责转移插件的跳转目标<br>
  3.  * 用于Hook插件Activity中Instrumentation
  4.  *
  5.  * @see android.app.Activity#startActivity(android.content.Intent)
  6.  */
  7. public class PluginInstrument extends Instrumentation {
  8.     private static final String TAG = "PluginInstrument";
  9.  
  10.     private static ConcurrentMap<String, Vector<Method>> sMethods = new ConcurrentHashMap<String, Vector<Method>>(5);
  11.     Instrumentation mHostInstr;
  12.     private String mPkgName;
  13.     private ReflectionUtils mInstrumentRef;
  14.  
  15.     /**
  16.      * 插件的Instrumentation
  17.      */
  18.     public PluginInstrument(Instrumentation hostInstr) {
  19.         this(hostInstr, "");
  20.     }
  21.  
  22.     public PluginInstrument(Instrumentation hostInstr, String pkgName) {
  23.         mHostInstr = hostInstr;
  24.         mInstrumentRef = ReflectionUtils.on(hostInstr);
  25.         mPkgName = pkgName;
  26.     }
  27.  
  28.     /**
  29.      * 如果是PluginInstrumentation，拆装出原始的HostInstr
  30.      *
  31.      * @param instrumentation
  32.      * @return
  33.      */
  34.     public static Instrumentation unwrap(Instrumentation instrumentation) {
  35.         if (instrumentation instanceof PluginInstrument) {
  36.             return ((PluginInstrument) instrumentation).mHostInstr;
  37.         }
  38.         return instrumentation;
  39.     }
  40.  
  41.     /**
  42.      * @Override
  43.      */
  44.     public ActivityResult execStartActivity(
  45.             Context who, IBinder contextThread, IBinder token, Activity target,
  46.             Intent intent, int requestCode, Bundle options) {
  47.  
  48.         ...
  49.     }
  50.  
  51.     /**
  52.      * @Override
  53.      */
  54.     public ActivityResult execStartActivity(
  55.             Context who, IBinder contextThread, IBinder token, Activity target,
  56.             Intent intent, int requestCode) {
  57.         ...
  58.     }
  59.  
  60.     /**
  61.      * @Override For below android 6.0
  62.      */
  63.     public ActivityResult execStartActivityAsCaller(
  64.             Context who, IBinder contextThread, IBinder token, Activity target,
  65.             Intent intent, int requestCode, Bundle options, int userId) {
  66.         ...
  67.     }
  68.  
  69.     /**
  70.      * @Override For android 6.0
  71.      */
  72.     public ActivityResult execStartActivityAsCaller(
  73.             Context who, IBinder contextThread, IBinder token, Activity target,
  74.             Intent intent, int requestCode, Bundle options,
  75.             boolean ignoreTargetSecurity, int userId) {
  76.         ...
  77.     }
  78.  
  79.     /**
  80.      * @Override
  81.      */
  82.     public void execStartActivitiesAsUser(
  83.             Context who, IBinder contextThread, IBinder token, Activity target,
  84.             Intent[] intents, Bundle options, int userId) {
  85.         ...
  86.     }
  87.  
  88.     /**
  89.      * @Override For below android 6.0, start activity from Fragment
  90.      */
  91.     public ActivityResult execStartActivity(
  92.             Context who, IBinder contextThread, IBinder token, Fragment target,
  93.             Intent intent, int requestCode, Bundle options) {
  94.         ...
  95.     }
  96.  
  97.     /**
  98.      * @Override For android 6.0, start activity from Fragment
  99.      */
  100.     public ActivityResult execStartActivity(
  101.             Context who, IBinder contextThread, IBinder token, String target,
  102.             Intent intent, int requestCode, Bundle options) {
  103.        ...
  104.     }
  105. }
  106.  
  107. 复制代码
  1. /**
  2.  * 自定义的全局的Instrumentation
  3.  * 负责转移插件的跳转目标和创建插件的Activity实例
  4.  * 用于Hook ActivityThread中的全局Instrumentation
  5.  */
  6. public class NeptuneInstrument extends PluginInstrument {
  7.  
  8.     private static final String TAG = "NeptuneInstrument";
  9.     private PluginActivityRecoveryHelper mRecoveryHelper = new PluginActivityRecoveryHelper();
  10.  
  11.     public NeptuneInstrument(Instrumentation hostInstr) {
  12.         super(hostInstr);
  13.     }
  14.  
  15.     @Override
  16.     public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  17.         ...
  18.     }
  19.  
  20.     @Override
  21.     public void callActivityOnCreate(Activity activity, Bundle icicle) {
  22.         ...
  23.     }
  24.  
  25.     @Override
  26.     public void callActivityOnDestroy(Activity activity) {
  27.         ...
  28.     }
  29.  
  30.     @Override
  31.     public void callActivityOnRestoreInstanceState(Activity activity, Bundle savedInstanceState) {
  32.         ...
  33.     }
  34.  
  35.     /**
  36.      * 将Activity反射相关操作分发给插件Activity的基类
  37.      */
  38.     private boolean dispatchToBaseActivity(Activity activity) {
  39.  
  40.         //这个模式已弃用
  41.         return Neptune.getConfig().getSdkMode() == NeptuneConfig.INSTRUMENTATION_BASEACT_MODE
  42.                 && activity instanceof IPluginBase;
  43.     }
  44. }
  45. 复制代码

NeptuneInstrument类中的几个方法有一些特殊的逻辑处理，下面单独分析：

  1. @Override
  2.     public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  3.         if (className.startsWith(ComponentFinder.DEFAULT_ACTIVITY_PROXY_PREFIX)) {
  4.             // 插件代理Activity，替换回插件真实的Activity
  5.             String[] result = IntentUtils.parsePkgAndClsFromIntent(intent);
  6.             String packageName = result[0];
  7.             String targetClass = result[1];
  8.  
  9.             PluginDebugLog.runtimeLog(TAG, "newActivity: " + className + ", targetClass: " + targetClass);
  10.             if (!TextUtils.isEmpty(packageName)) {
  11.                 //找到对应插件
  12.                 PluginLoadedApk loadedApk = PluginManager.getPluginLoadedApkByPkgName(packageName);
  13.                 if (loadedApk != null && targetClass != null) {
  14.                     Activity activity = mHostInstr.newActivity(loadedApk.getPluginClassLoader(), targetClass, intent);
  15.                     activity.setIntent(intent);
  16.  
  17.                     if (!dispatchToBaseActivity(activity)) {
  18.                         // 这里需要替换Resources，是因为ContextThemeWrapper会缓存一个Resource对象，而在Activity#attach()和
  19.                         // Activity#onCreate()之间，系统会调用Activity#setTheme()初始化主题，Android 4.1+
  20.                         //替换成插件的Resource资源
  21.                         ReflectionUtils.on(activity).setNoException("mResources", loadedApk.getPluginResource());
  22.                     }
  23.  
  24.                     return activity;
  25.                 } else if (loadedApk == null) {
  26.                     // loadedApk 为空，可能是正在恢复进程，跳转到 RecoveryActivity
  27.                     return mHostInstr.newActivity(cl, mRecoveryHelper.selectRecoveryActivity(className), intent);
  28.                 }
  29.             }
  30.         }
  31.         return mHostInstr.newActivity(cl, className, intent);
  32.     }
  33. 复制代码
  1.     @Override
  2.     public void callActivityOnCreate(Activity activity, Bundle icicle) {
  3.         boolean isRecovery = activity instanceof TransRecoveryActivity0;
  4.         if (isRecovery) {
  5.         //插件加载中的Activity，使用宿主的Instrument
  6.             mRecoveryHelper.saveIcicle(activity, icicle);
  7.             mHostInstr.callActivityOnCreate(activity, null);
  8.             return;
  9.         }
  10.         final Intent intent = activity.getIntent();
  11.         String[] result = IntentUtils.parsePkgAndClsFromIntent(intent);
  12.         boolean isLaunchPlugin = false;
  13.         if (IntentUtils.isIntentForPlugin(intent)) {
  14.             String packageName = result[0];
  15.             String targetClass = result[1];
  16.             if (!TextUtils.isEmpty(packageName)) {
  17.                 PluginDebugLog.runtimeLog(TAG, "callActivityOnCreate: " + packageName);
  18.                 PluginLoadedApk loadedApk = PluginManager.getPluginLoadedApkByPkgName(packageName);
  19.                 if (loadedApk != null) {
  20.                     icicle = mRecoveryHelper.recoveryIcicle(activity, icicle);
  21.                     // 设置 extra 的 ClassLoader，不然可能会出现 BadParcelException, ClassNotFound
  22.                     if (icicle != null) {
  23.                         icicle.setClassLoader(loadedApk.getPluginClassLoader());
  24.                     }
  25.                     if (!dispatchToBaseActivity(activity)) {
  26.                         // 如果分发给插件Activity的基类了，就不需要在这里反射hook替换相关成员变量了
  27.                         try {
  28.                             ReflectionUtils activityRef = ReflectionUtils.on(activity);
  29.                             //设置为插件资源
  30.                             activityRef.setNoException("mResources", loadedApk.getPluginResource());
  31.                             //设置插件的Application
  32.                             activityRef.setNoException("mApplication", loadedApk.getPluginApplication());
  33.                             Context pluginContext = new PluginContextWrapper(activity.getBaseContext(), packageName);
  34.                             //替换为PluginContextWrapper，处理inflate相关
  35.                             ReflectionUtils.on(activity, ContextWrapper.class).set("mBase", pluginContext);
  36.                             // 5.0以下ContextThemeWrapper内会保存一个mBase，也需要反射替换掉
  37.                             ReflectionUtils.on(activity, ContextThemeWrapper.class).setNoException("mBase", pluginContext);
  38.                             //替换为插件的Instrumentation
  39.                             ReflectionUtils.on(activity).setNoException("mInstrumentation", loadedApk.getPluginInstrument());
  40.  
  41.                             // 修改插件Activity的ActivityInfo, theme, window等信息
  42.                             PluginActivityControl.changeActivityInfo(activity, targetClass, loadedApk);
  43.                         } catch (Exception e) {
  44.                         PluginDebugLog.runtimeLog(TAG, "callActivityOnCreate with exception: " + e.getMessage());
  45.                         }
  46.  
  47.                     }
  48.  
  49.                     if (activity.getParent() == null) {
  50.                     //Activity栈的逻辑是怎么处理的？
  51.                         loadedApk.getActivityStackSupervisor().pushActivityToStack(activity);
  52.                     }
  53.                     isLaunchPlugin = true;
  54.                 }
  55.             }
  56.             IntentUtils.resetAction(intent);  //恢复Action
  57.         }
  58.  
  59.         try {
  60.             mHostInstr.callActivityOnCreate(activity, icicle);
  61.  
  62.             if (isLaunchPlugin) {
  63.                 NotifyCenter.notifyPluginStarted(activity, intent);
  64.                 NotifyCenter.notifyPluginActivityLoaded(activity);
  65.             }
  66.             //check是否需要hook callActivityOnRestoreInstanceState方法
  67.             mRecoveryHelper.mockActivityOnRestoreInstanceStateIfNeed(this, activity);
  68.         } catch (Exception e) {
  69.             ErrorUtil.throwErrorIfNeed(e);
  70.             if (isLaunchPlugin) {
  71.                 NotifyCenter.notifyStartPluginError(activity);
  72.             }
  73.             activity.finish();
  74.         }
  75.     }
  76. 复制代码
  1.  @Override
  2.     public void callActivityOnDestroy(Activity activity) {
  3.         mHostInstr.callActivityOnDestroy(activity);
  4.         if (activity.getParent() != null) {
  5.             return;
  6.         }
  7.  
  8.         final Intent intent = activity.getIntent();
  9.         String pkgName = IntentUtils.parsePkgNameFromActivity(activity);
  10.         if (IntentUtils.isIntentForPlugin(intent)
  11.                 || intent == null) {
  12.             // intent为null时，如果能够从Activity中解析出pkgName，也应该是插件的页面
  13.             if (!TextUtils.isEmpty(pkgName)) {
  14.                 PluginDebugLog.runtimeLog(TAG, "callActivityOnDestroy: " + pkgName);
  15.                 PluginLoadedApk loadedApk = PluginManager.getPluginLoadedApkByPkgName(pkgName);
  16.                 if (loadedApk != null) {
  17.                 //退出插件的Activity栈
  18.                     loadedApk.getActivityStackSupervisor().popActivityFromStack(activity);
  19.                 }
  20.             }
  21.         }
  22.     }
  23. 复制代码
  1.   @Override
  2.     public void callActivityOnRestoreInstanceState(Activity activity, Bundle savedInstanceState) {
  3.         if (activity instanceof TransRecoveryActivity0) {
  4.             mRecoveryHelper.saveSavedInstanceState(activity, savedInstanceState);
  5.             return;
  6.         }
  7.         if (IntentUtils.isIntentForPlugin(activity.getIntent())) {
  8.             String pkgName = IntentUtils.parsePkgAndClsFromIntent(activity.getIntent())[0];
  9.             PluginLoadedApk loadedApk = PluginManager.getPluginLoadedApkByPkgName(pkgName);
  10.             if (loadedApk != null && savedInstanceState != null) {
  11.             //用插件的ClassLoader恢复数据
  12.                 savedInstanceState.setClassLoader(loadedApk.getPluginClassLoader());
  13.             }
  14.         }
  15.         mHostInstr.callActivityOnRestoreInstanceState(activity, savedInstanceState);
  16.     }
  17. 复制代码

插件Activity任务栈

  1. /**
  2.  * 插件的Activity栈抽象, 和系统的{@link com.android.server.am.ActivityStack}类似
  3.  */
  4. public class PActivityStack {
  5.     private final LinkedList<Activity> mActivities;
  6.     // taskAffinity
  7.     private String taskName;
  8.  
  9.     PActivityStack(String taskName) {
  10.         this.taskName = taskName;
  11.         mActivities = new LinkedList<>();
  12.     }
  13.  
  14.     /**
  15.      * 获取当前任务栈的名称
  16.      */
  17.     public String getTaskName() {
  18.         return taskName;
  19.     }
  20.  
  21.     public LinkedList<Activity> getActivities() {
  22.         return mActivities;
  23.     }
  24.  
  25.     public int size() {
  26.         return mActivities.size();
  27.     }
  28.  
  29.     public synchronized boolean isEmpty() {
  30.         return mActivities.isEmpty();
  31.     }
  32.  
  33.     // 放入链表的前面
  34.     public synchronized void push(Activity activity) {
  35.         mActivities.addFirst(activity);
  36.     }
  37.  
  38.     public synchronized void insertFirst(Activity activity) {
  39.         mActivities.addLast(activity);
  40.     }
  41.  
  42.     public synchronized boolean pop(Activity activity) {
  43.         return mActivities.remove(activity);
  44.     }
  45.  
  46.     public synchronized Activity getTop() {
  47.         return mActivities.getFirst();
  48.     }
  49.  
  50.     /**
  51.      * 清空当前任务栈里的Activity
  52.      */
  53.     public void clear(boolean needFinish) {
  54.         Iterator<Activity> iterator = mActivities.iterator();
  55.         while (iterator.hasNext()) {
  56.             Activity activity = iterator.next();
  57.             if (activity != null && needFinish
  58.                     && !FileUtils.isFinished(activity)) {
  59.                 activity.finish();
  60.             }
  61.             iterator.remove();
  62.         }
  63.     }
  64. }
  65. 复制代码

PActivityStackSupervisor管理Activity任务栈

  1.     /**
  2.      * 处理Activity的launchMode，给Intent添加相关的Flags
  3.      */
  4.     public void dealLaunchMode(Intent intent) {
  5.         if (null == intent) {
  6.             return;
  7.         }
  8.  
  9.         String targetActivity = IntentUtils.getTargetClass(intent);
  10.         if (TextUtils.isEmpty(targetActivity)) {
  11.             return;
  12.         }
  13.  
  14.         PluginDebugLog.runtimeLog(TAG, "dealLaunchMode target activity: " + intent + " source: "
  15.                 + targetActivity);
  16.         // 不支持LAUNCH_SINGLE_INSTANCE
  17.         ActivityInfo info = mLoadedApk.getPluginPackageInfo().getActivityInfo(targetActivity);
  18.         if (info == null || info.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
  19.             return;
  20.         }
  21.         boolean isSingleTop = info.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP
  22.                 || (intent.getFlags() & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0;
  23.         boolean isSingleTask = info.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK;
  24.         boolean isClearTop = (intent.getFlags() & Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0;
  25.         PluginDebugLog.runtimeLog(TAG, "dealLaunchMode isSingleTop " + isSingleTop + " isSingleTask "
  26.                 + isSingleTask + " isClearTop " + isClearTop);
  27.         int flag = intent.getFlags();
  28.         PluginDebugLog.runtimeLog(TAG, "before flag: " + Integer.toHexString(intent.getFlags()));
  29.         if ((isSingleTop || isSingleTask) && (flag & Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0) {
  30.             flag = flag ^ Intent.FLAG_ACTIVITY_SINGLE_TOP;
  31.         }
  32.         if ((isSingleTask || isClearTop) && (flag & Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) {
  33.             flag = flag ^ Intent.FLAG_ACTIVITY_CLEAR_TOP;
  34.         }
  35.         intent.setFlags(flag);
  36.         PluginDebugLog.runtimeLog(TAG, "after flag: " + Integer.toHexString(intent.getFlags()));
  37.  
  38.         if (isSingleTop && !isClearTop) {
  39.             // 判断栈顶是否为需要启动的Activity, 只需要处理前台栈
  40.             Activity activity = null;
  41.             if (!mFocusedStack.isEmpty()) {
  42.                 activity = mFocusedStack.getTop();
  43.             }
  44.             boolean hasSameActivity = false;
  45.             String proxyClsName = ComponentFinder.findActivityProxy(mLoadedApk, info);
  46.             if (activity != null) {
  47.                 // 栈内有实例, 可能是ProxyActivity，也可能是插件真实的Activity
  48.                 //Fix: 新的实现中只有插件真实的Activity
  49.                 if (TextUtils.equals(proxyClsName, activity.getClass().getName())
  50.                         || TextUtils.equals(targetActivity, activity.getClass().getName())) {
  51.                     String key = getActivityStackKey(activity);
  52.  
  53.                     if (!TextUtils.isEmpty(key) && TextUtils.equals(targetActivity, key)) {
  54.                         intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
  55.                         hasSameActivity = true;
  56.                     }
  57.                 }
  58.             }
  59.             if (hasSameActivity) {
  60.                 handleOtherPluginActivityStack(activity, mFocusedStack);
  61.             }
  62.         } else if (isSingleTask || isClearTop) {
  63.  
  64.             PActivityStack targetStack; // 需要搜索的任务栈
  65.             boolean fromBackStack = false;
  66.             if (isClearTop) {
  67.                 targetStack = mFocusedStack;
  68.             } else {
  69.                 // singleTask
  70.                 if (mLastFocusedStack != null
  71.                         && TextUtils.equals(mLastFocusedStack.getTaskName(), matchTaskName(info.taskAffinity))) {
  72.                     // 后台栈和Activity的taskAffinity匹配
  73.                     targetStack = mLastFocusedStack;
  74.                     fromBackStack = true;
  75.                     PluginDebugLog.runtimeLog(TAG, "dealLaunchMode search in background stack: " + info.taskAffinity);
  76.                 } else {
  77.                     // 前台栈中搜索
  78.                     targetStack = mFocusedStack;
  79.                 }
  80.             }
  81.             // 查找栈中是否存在已有实例
  82.             Activity found = null;
  83.             // 遍历已经起过的activity
  84.             for (Activity activity : targetStack.getActivities()) {
  85.                 String proxyClsName = ComponentFinder.findActivityProxy(mLoadedApk, info);
  86.                 if (activity != null) {
  87.                     if (TextUtils.equals(proxyClsName, activity.getClass().getName())
  88.                             || TextUtils.equals(targetActivity, activity.getClass().getName())) {
  89.                         String key = getActivityStackKey(activity);
  90.                         if (!TextUtils.isEmpty(key) && TextUtils.equals(targetActivity, key)) {
  91.                             PluginDebugLog.runtimeLog(TAG, "dealLaunchMode found:" + IntentUtils.dump(activity));
  92.                             found = activity;
  93.                             break;
  94.                         }
  95.                     }
  96.                 }
  97.             }
  98.  
  99.             // 栈中已经有当前activity
  100.             if (found != null) {
  101.                 // 处理其他插件的逻辑
  102.                 // 在以这两种SingleTask， ClearTop flag启动情况下，在同一个栈的情况下
  103.                 handleOtherPluginActivityStack(found, targetStack);
  104.  
  105.                 // 处理当前插件的Activity
  106.                 List<Activity> popActivities = new ArrayList<Activity>(5);
  107.                 for (Activity activity : targetStack.getActivities()) {
  108.                     if (activity == found) {
  109.                         if (isSingleTask || isSingleTop) {
  110.                             PluginDebugLog.runtimeLog(TAG, "dealLaunchMode add single top flag!");
  111.                             intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
  112.                         }
  113.                         PluginDebugLog.runtimeLog(TAG, "dealLaunchMode add clear top flag!");
  114.                         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  115.                         break;
  116.                     }
  117.                     popActivities.add(activity);
  118.                 }
  119.  
  120.                 for (Activity act : popActivities) {
  121.                     PluginDebugLog.runtimeLog(TAG, "dealLaunchMode popActivities finish " + IntentUtils.dump(act));
  122.                     popActivityFromStack(act);
  123.                     if (!FileUtils.isFinished(act)) {
  124.                         act.finish();
  125.                     }
  126.                 }
  127.  
  128.                 // 如果Activity是在后台堆栈中找到的，需要合并前后台栈
  129.                 if (fromBackStack) {
  130.                     // https://developer.android.com/guide/components/activities/tasks-and-back-stack
  131.                     // 把返回栈中的Activity全部推到前台
  132.                     PActivityStack sysForeStack = findAssociatedStack(mFocusedStack);
  133.                     PActivityStack sysBackStack = findAssociatedStack(mLastFocusedStack);
  134.                     mergeActivityStack(sysBackStack, sysForeStack);
  135.                     // 处理插件自身的栈
  136.                     mergeActivityStack(mLastFocusedStack, mFocusedStack);
  137.                     // 切换前后台堆栈
  138.                     switchToBackStack(mFocusedStack, mLastFocusedStack);
  139.                 }
  140.  
  141.                 mLoadedApk.quitApp(false);
  142.             } else {
  143.                 // 堆栈里没有找到，遍历还未启动cache中的activity记录
  144.                 LinkedBlockingQueue<Intent> records = sIntentCacheMap
  145.                         .get(mLoadedApk.getPluginPackageName());
  146.                 if (null != records) {
  147.                     Iterator<Intent> recordIterator = records.iterator();
  148.                     String notLaunchTargetClassName = null;
  149.                     while (recordIterator.hasNext()) {
  150.                         Intent record = recordIterator.next();
  151.                         if (null != record) {
  152.                             if (null != record.getComponent()) {
  153.                                 notLaunchTargetClassName = record.getComponent().getClassName();
  154.                             }
  155.                             if (TextUtils.equals(notLaunchTargetClassName, targetActivity)) {
  156.                                 PluginDebugLog.runtimeLog(TAG, "sIntentCacheMap found: " + targetActivity);
  157.                                 if (isSingleTask || isSingleTop) {
  158.                                     intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
  159.                                 }
  160.                                 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  161.                                 break;
  162.                             }
  163.                         }
  164.                     }
  165.                 }
  166.                 // 遍历启动过程中的activity记录
  167.                 List<Intent> loadingIntents = sIntentLoadingMap.get(mLoadedApk.getPluginPackageName());
  168.                 if (null != loadingIntents) {
  169.                     Iterator<Intent> loadingRecordIterator = loadingIntents.iterator();
  170.                     String notLaunchTargetClassName = null;
  171.                     while (loadingRecordIterator.hasNext()) {
  172.                         Intent record = loadingRecordIterator.next();
  173.                         if (null != record) {
  174.                             notLaunchTargetClassName = IntentUtils.getTargetClass(record);
  175.                             if (TextUtils.equals(notLaunchTargetClassName, targetActivity)) {
  176.                                 PluginDebugLog.runtimeLog(TAG,
  177.                                         "sIntentLoadingMap found: " + targetActivity);
  178.                                 if (isSingleTask || isSingleTop) {
  179.                                     intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
  180.                                 }
  181.                                 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  182.                                 break;
  183.                             }
  184.                         }
  185.                     }
  186.                 }
  187.  
  188.                 if (isSingleTask) {
  189.                     // 是否需要放到单独的任务栈
  190.                     String taskName = matchTaskName(info.taskAffinity);
  191.                     if (!TextUtils.equals(mFocusedStack.getTaskName(), taskName)) {
  192.                         PluginDebugLog.runtimeLog(TAG, "dealLaunchMode push activity into separated stack: " + taskName);
  193.                         PActivityStack stack = mActivityStacks.get(taskName);
  194.                         if (stack == null) {
  195.                             // 创建一个新的任务栈
  196.                             stack = new PActivityStack(taskName);
  197.                             mActivityStacks.put(taskName, stack);
  198.                         }
  199.                         // 切换前后台栈
  200.                         switchToBackStack(mFocusedStack, stack);
  201.                     } else {
  202.                         PluginDebugLog.runtimeLog(TAG, "dealLaunchMode push activity into current stack: " + taskName);
  203.                     }
  204.                 }
  205.             }
  206.         }
  207.         PluginDebugLog.runtimeLog(TAG, "dealLaunchMode end: " + intent + " "
  208.                 + targetActivity);
  209.     }
  210. 复制代码

处理插件中的广播

  1.   /**
  2.      * 动态注册插件中的静态Receiver
  3.      */
  4.     private void installStaticReceiver() {
  5.         if (mPluginPackageInfo == null || mHostContext == null) {
  6.             return;
  7.         }
  8.         Map<String, PluginPackageInfo.ReceiverIntentInfo> mReceiverIntentInfos =
  9.                 mPluginPackageInfo.getReceiverIntentInfos();
  10.         if (mReceiverIntentInfos != null) {
  11.             Set<Map.Entry<String, PluginPackageInfo.ReceiverIntentInfo>> mEntrys =
  12.                     mReceiverIntentInfos.entrySet();
  13.             Context mGlobalContext = mHostContext.getApplicationContext();
  14.             for (Map.Entry<String, PluginPackageInfo.ReceiverIntentInfo> mEntry : mEntrys) {
  15.                 PluginPackageInfo.ReceiverIntentInfo mReceiverInfo = mEntry.getValue();
  16.                 if (mReceiverInfo != null) {
  17.                     try {
  18.                         BroadcastReceiver mReceiver =
  19.                                 BroadcastReceiver.class.cast(mPluginClassLoader.
  20.                                         loadClass(mReceiverInfo.mInfo.name).newInstance());
  21.                         List<IntentFilter> mFilters = mReceiverInfo.mFilter;
  22.                         if (mFilters != null) {
  23.                             for (IntentFilter mItem : mFilters) {
  24.                                 mGlobalContext.registerReceiver(mReceiver, mItem);
  25.                             }
  26.                         }
  27.                     } catch (Exception e) {
  28.                         e.printStackTrace();
  29.                     }
  30.                 }
  31.             }
  32.         }
  33.     }
  34. 复制代码

处理插件中的Service

PluginContextWrapper类中完成了startService等方法的代理

  1.     @Override
  2.     public ComponentName startService(Intent service) {
  3.         PluginDebugLog.log(TAG, "startService: " + service);
  4.         PluginLoadedApk mLoadedApk = getPluginLoadedApk();
  5.         if (mLoadedApk != null) {
  6.             ComponentFinder.switchToServiceProxy(mLoadedApk, service);
  7.         }
  8.         return super.startService(service);
  9.     }
  10.  
  11.     @Override
  12.     public boolean stopService(Intent name) {
  13.         PluginDebugLog.log(TAG, "stopService: " + name);
  14.         PluginLoadedApk mLoadedApk = getPluginLoadedApk();
  15.         if (mLoadedApk != null) {
  16.             String actServiceClsName = "";
  17.             if (name.getComponent() != null) {
  18.                 actServiceClsName = name.getComponent().getClassName();
  19.             } else {
  20.                 ServiceInfo mServiceInfo = getPluginPackageInfo().resolveService(name);
  21.                 if (mServiceInfo != null) {
  22.                     actServiceClsName = mServiceInfo.name;
  23.                 }
  24.             }
  25.  
  26.             PluginServiceWrapper plugin = PServiceSupervisor
  27.                     .getServiceByIdentifer(PluginServiceWrapper.getIdentify(getPluginPackageName(), actServiceClsName));
  28.             if (plugin != null) {
  29.                 plugin.updateServiceState(PluginServiceWrapper.PLUGIN_SERVICE_STOPED);
  30.                 plugin.tryToDestroyService();
  31.                 return true;
  32.             }
  33.         }
  34.         return super.stopService(name);
  35.     }
  36.  
  37.     @Override
  38.     public boolean bindService(Intent service, ServiceConnection conn, int flags) {
  39.         PluginDebugLog.log(TAG, "bindService: " + service);
  40.         PluginLoadedApk mLoadedApk = getPluginLoadedApk();
  41.         if (mLoadedApk != null) {
  42.             ComponentFinder.switchToServiceProxy(mLoadedApk, service);
  43.         }
  44.         if (conn != null) {
  45.             if (mLoadedApk != null && service != null) {
  46.                 String serviceClass = IntentUtils.getTargetClass(service);
  47.                 String packageName = mLoadedApk.getPluginPackageName();
  48.                 if (!TextUtils.isEmpty(serviceClass) && !TextUtils.isEmpty(packageName)) {
  49.                     PServiceSupervisor.addServiceConnectionByIdentifer(packageName + "." + serviceClass, conn);
  50.                 }
  51.             }
  52.         }
  53.         return super.bindService(service, conn, flags);
  54.     }
  55.  
  56.     @Override
  57.     public void unbindService(ServiceConnection conn) {
  58.         super.unbindService(conn);
  59.         PServiceSupervisor.removeServiceConnection(conn);
  60.         PluginDebugLog.log(TAG, "unbindService: " + conn);
  61.     }
  62. 复制代码

总结

Neptune框架注释比较清晰。但是由于Neptune框架代码存在两套对Activity插件化的方案实现(版本迭代，一套老的，一套新的)，】，导致代码逻辑不是很统一。在阅读代码的时候，把握住Hook思路，只看相关的代码，还是比较容易理解的。

转载于:https://juejin.im/post/5cd6f1bce51d456e3963198c

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/300648
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号