replugin原理笔记

Replugin源码目录主要有4个工程组成，其组成如下图所示，包括2个gradle工程，2个Android library工程。

replugin-host-gradle
replugin-host-library
replugin-plugin-gradle
replugin-plugin-library
Replugin是一套完整的、稳定的、适合全面使用的，占坑类插件化方案。Replugin的hook点只有一处，确保了框架的兼容性、稳定性。使用Replugin宿主和插件都需引入其gradle插件，但是宿主、插件的改造接入都非常简便。

1 宿主的改造

replugin-host-gradle，宿主工程构建时需要依赖的gradle插件，主要作用是进行宿主应用的构建任务，生成带插件坑位的AndroidManifest.xml，插件坑位可在宿主工程的gradle文件的repluginHostConfig中进行配置。以及生成包含插件信息的plugins-builtin.json文件。其主要任务包括：
生成带 RePlugin 插件坑位的 AndroidManifest.xml（允许自定义数量）
生成 RepluginHostConfig 类，方便插件框架读取并自定义其属性
生成 plugins-builtin.json，json中含有插件应用的信息，包名，插件名，插件路径等。
主要实现在RePlugin.groovy的apply方法中：

public void apply(Project project) {
···
def appID = variant.generateBuildConfig.appPackageName
def newManifest = ComponentsGenerator.generateComponent(appID, config)
···
//json generate task
def generateBuiltinJsonTaskName = scope.getTaskName(AppConstant.TASK_GENERATE, "BuiltinJson")
def generateBuiltinJsonTask = project.task(generateBuiltinJsonTaskName)

generateBuiltinJsonTask.doLast {
    FileCreators.createBuiltinJson(project, variant, config)
}
generateBuiltinJsonTask.group = AppConstant.TASKS_GROUP
variant.outputs.each { output ->
    output.processManifest.doLast {
        output.processManifest.outputs.files.each { File file ->
            def manifestFile = null;
            //在gradle plugin 3.0.0之前，file是文件，且文件名为AndroidManifest.xml
            //在gradle plugin 3.0.0之后，file是目录，且不包含AndroidManifest.xml，需要自己拼接
            //除了目录和AndroidManifest.xml之外，还可能会包含manifest-merger-debug-report.txt等不相干的文件，过滤它
            if ((file.name.equalsIgnoreCase("AndroidManifest.xml") && !file.isDirectory()) || file.isDirectory()) {
                if (file.isDirectory()) {
                    //3.0.0之后，自己拼接AndroidManifest.xml
                    manifestFile = new File(file, "AndroidManifest.xml")
                } else {
                    //3.0.0之前，直接使用
                    manifestFile = file
                }
                //检测文件是否存在
                if (manifestFile != null && manifestFile.exists()) {
                    println "${AppConstant.TAG} handle manifest: ${manifestFile}"
                    def updatedContent = manifestFile.getText("UTF-8").replaceAll("</application>", newManifest + "</application>")
                    manifestFile.write(updatedContent, 'UTF-8')
                }
            }
        }
    }
}

replugin-host-gradle 插件的构建任务基于{productFlavors}{buildTypes}组合出多维构建任务，为每一个组合在AndroidManifest.xml中生成四大组件坑位。生成四大组件坑位的代码在ComponentsGenerator中.

def newManifest = ComponentsGenerator.generateComponent(appID, config)

ComponentsGenerator的generateComponent方法主要实现在AndroidManifest中四大组件坑位的写入。

/* 透明坑 */
config.countTranslucentStandard.times {
    activity(
            "${name}": "${applicationID}.${infix}N1NRTS${it}",
            "${cfg}": "${cfgV}",
            "${exp}": "${expV}",
            "${ori}": "${oriV}",
            "${theme}": "${themeTS}")
}

循环进行坑位的生成，其原理基于Groovy的MarkupBuilder，组装出四大组件坑位的xml。宿主app编译完成后，可以在build\intermediates\manifests\full\ AndroidManifest.xml中看到四大组件的坑位。

2 插件的改造

replugin-plugin-gradle主要在插件应用的编译器基于Transform api 注入到编译流程中, 再通过Javassist对编译中间环节的 Java 字节码文件进行修改，以便实现编译期动态修改插件应用的目的。

replugin-plugin-gradle插件基于Gradle的Transform API，在编译期的构建任务流中，在class转为dex之前，插入一个Transform，基于Javassist技术实现对字节码文件的注入，修改Activity的继承关系、Provider和LocalBroadcastManager的调用代码为插件库的调用代码。

Javassist是一个Java字节码类库。Java的字节码是包含Java类与接口，并按照一定的顺序存在class文件中。
插件的工作原理主要在ReClassPlugin.grooovy文件中：

public class ReClassPlugin implements Plugin<Project> {

    @Override
public void apply(Project project) {
······
def transform = new ReClassTransform(project)
// 将 transform 注册到 android
android.registerTransform(transform)
······
}

在apply方法中，创建了很多的Task，主要用于插件调试。直接看到apply方法的最后的ReClassTransform。

public class ReClassTransform extends Transform {

Transform 是 Android Gradle API ，允许第三方插件在class文件转为dex文件前操作编译完成的class文件，这个API的引入是为了简化class文件的自定义操作而无需对Task进行处理。

ReClassTransform.groovy中的关键代码是transform方法中调用了doTransform方法，在其中遍历注入器进行注入。

def doTransform(Collection<TransformInput> inputs,
                TransformOutputProvider outputProvider,
                Object config,
                def injectors) {

    /* 初始化 ClassPool */
    Object pool = initClassPool(inputs)

    /* 进行注入操作 */
    Util.newSection()
    Injectors.values().each {
        if (it.nickName in injectors) {
            println ">>> Do: ${it.nickName}"
            // 将 NickName 的第 0 个字符转换成小写，用作对应配置的名称
            def configPre = Util.lowerCaseAtIndex(it.nickName, 0)
            doInject(inputs, pool, it.injector, config.properties["${configPre}Config"])
        } else {
            println ">>> Skip: ${it.nickName}"
        }
    }

    if (config.customInjectors != null) {
        config.customInjectors.each {
            doInject(inputs, pool, it)
        }
    }

    /* 重打包 */
    repackage()

    /* 拷贝 class 和 jar 包 */
    copyResult(inputs, outputProvider)

    Util.newSection()
}

Replugin中的注入器如下图所示，每个注入器执行特定的注入任务，分别处理相应的class文件和jar文件。

Activity注入器LoaderActivityInjector，其中定义了Activity替换规则。即如果我在插件中写了一个WelcomeActivity extends Activity，则通过该注入器，最终继承关系会被改成WelcomeActivity extends PluginActivity。PluginActivity、PluginFragmentActivity等的定义在replugin-plugin-library工程中。

/* LoaderActivity 替换规则 */
def private static loaderActivityRules = [
        'android.app.Activity'                    : 'com.qihoo360.replugin.loader.a.PluginActivity',
        'android.app.TabActivity'                 : 'com.qihoo360.replugin.loader.a.PluginTabActivity',
        'android.app.ListActivity'                : 'com.qihoo360.replugin.loader.a.PluginListActivity',
        'android.app.ActivityGroup'               : 'com.qihoo360.replugin.loader.a.PluginActivityGroup',
        'android.support.v4.app.FragmentActivity' : 'com.qihoo360.replugin.loader.a.PluginFragmentActivity',
        'android.support.v7.app.AppCompatActivity': 'com.qihoo360.replugin.loader.a.PluginAppCompatActivity',
        'android.preference.PreferenceActivity'   : 'com.qihoo360.replugin.loader.a.PluginPreferenceActivity',
        'android.app.ExpandableListActivity'      : 'com.qihoo360.replugin.loader.a.PluginExpandableListActivity'
]

LoaderActivityInjector的关键代码在handleActivity方法中。

private def handleActivity(ClassPool pool, String activity, String classesDir) {
        def clsFilePath = classesDir + File.separatorChar + activity.replaceAll('\\.', '/') + '.class'
        if (!new File(clsFilePath).exists()) {
            return
        }

        println ">>> Handle $activity"

        def stream, ctCls
        try {
            stream = new FileInputStream(clsFilePath)
            ctCls = pool.makeClass(stream);
/*
             // 打印当前 Activity 的所有父类
            CtClass tmpSuper = ctCls.superclass
            while (tmpSuper != null) {
                println(tmpSuper.name)
                tmpSuper = tmpSuper.superclass
            }
*/
            // ctCls 之前的父类
            def originSuperCls = ctCls.superclass

            /* 从当前 Activity 往上回溯，直到找到需要替换的 Activity */
            def superCls = originSuperCls
            while (superCls != null && !(superCls.name in loaderActivityRules.keySet())) {
                // println ">>> 向上查找 $superCls.name"
                ctCls = superCls
                superCls = ctCls.superclass
            }

            // 如果 ctCls 已经是 LoaderActivity，则不修改
            if (ctCls.name in loaderActivityRules.values()) {
                // println "    跳过 ${ctCls.getName()}"
                return
            }

            /* 找到需要替换的 Activity, 修改 Activity 的父类为 LoaderActivity */
            if (superCls != null) {
                def targetSuperClsName = loaderActivityRules.get(superCls.name)
                // println "    ${ctCls.getName()} 的父类 $superCls.name 需要替换为 ${targetSuperClsName}"
                CtClass targetSuperCls = pool.get(targetSuperClsName)

                if (ctCls.isFrozen()) {
                    ctCls.defrost()
                }
                ctCls.setSuperclass(targetSuperCls)

                // 修改声明的父类后，还需要方法中所有的 super 调用。
                ctCls.getDeclaredMethods().each { outerMethod ->
                    outerMethod.instrument(new ExprEditor() {
                        @Override
                        void edit(MethodCall call) throws CannotCompileException {
                            if (call.isSuper()) {
                                if (call.getMethod().getReturnType().getName() == 'void') {
                                    call.replace('{super.' + call.getMethodName() + '($$);}')
                                } else {
                                    call.replace('{$_ = super.' + call.getMethodName() + '($$);}')
                                }
                            }
                        }
                    })
                }

                ctCls.writeFile(CommonData.getClassPath(ctCls.name))
                println "    Replace ${ctCls.name}'s SuperClass ${superCls.name} to ${targetSuperCls.name}"
            }

        } catch (Throwable t) {
            println "    [Warning] --> ${t.toString()}"
        } finally {
            if (ctCls != null) {
                ctCls.detach()
            }
            if (stream != null) {
                stream.close()
            }
        }
    }

在Javassist中CtClass是一个class文件的抽象表述。一个CtClass（compile-time class）的实例是一个可以用来操作class文件的句柄。ClassPool是用来管理字节码的编辑,ClassPool是一个存放着代表class文件的CtClass类容器，它扫描读取了class文件并且构造了CtClass类，并且是后面响应修改class文件的入口。

如果想要修改一个class文件，用户必须实例化一个ClassPool类，并且使用ClassPool的get方法取得代表这个那个class文件的CtClass的引用。

在injectClass方法中遍历插件的AndroidManifest.xml中声明的所有Activity，在handleActivity方法中根据loaderActivityRules定义的替换规则，修改此Activity的父类为对应插件库中的父类。除了修改Activity的继承规则，还要对方法体进行修改。

3 插件Activity的启动过程

3.1 classLoader的hook

public static final void init(Application application) {
    setApplicationContext(application);

    PluginManager.init(application);

    sPluginMgr = new PmBase(application);
    sPluginMgr.init();

    Factory.sPluginManager = PMF.getLocal();
    Factory2.sPLProxy = PMF.getInternal();

    PatchClassLoaderUtils.patch(application);
}

PatchClassLoaderUtils.patch(application)方法，进行classLoader的hook，替换为RePluginClassLoader。

// 获取mPackageInfo.mClassLoader
ClassLoader oClassLoader = (ClassLoader) ReflectUtils.readField(oPackageInfo, "mClassLoader");
if (oClassLoader == null) {
    if (LOGR) {
        LogRelease.e(PLUGIN_TAG, "pclu.p: nf mpi. mb cl=" + oBase.getClass() + "; mpi cl=" + oPackageInfo.getClass());
    }
    return false;
}

// 外界可自定义ClassLoader的实现，但一定要基于RePluginClassLoader类
ClassLoader cl = RePlugin.getConfig().getCallbacks().createClassLoader(oClassLoader.getParent(), oClassLoader);

// 将新的ClassLoader写入mPackageInfo.mClassLoader
ReflectUtils.writeField(oPackageInfo, "mClassLoader", cl);

接着还会进行守护进程(guardService)的启动，守护进程主要是通过启动ContentProvider组件来启动。在守护进程中进行加载插件，及相关信息保存。

3.2 Activity的启动、类加载

启动插件的Activity通过Replugin.startActivity(Context context, Intent intent)启动，执行PluginLibraryInternalProxy的startActivity方法

    public boolean startActivity(Context context, Intent intent, String plugin, String activity, int process, boolean download) {
        if (LOG) {
            LogDebug.d(PLUGIN_TAG, "start activity: intent=" + intent + " plugin=" + plugin + " activity=" + activity + " process=" + process + " download=" + download);
        }

        // 是否启动下载
        // 若插件不可用（不存在或版本不匹配），则直接弹出“下载插件”对话框
        // 因为已经打开UpdateActivity，故在这里返回True，告诉外界已经打开，无需处理
        if (download) {
            if (PluginTable.getPluginInfo(plugin) == null) {
                if (LOG) {
                    LogDebug.d(PLUGIN_TAG, "plugin=" + plugin + " not found, start download ...");
                }

                // 如果用户在下载即将完成时突然点按“取消”，则有可能出现插件已下载成功，但没有及时加载进来的情况
                // 因此我们会判断这种情况，如果是，则重新加载一次即可，反之则提示用户下载
                // 原因：“取消”会触发Task.release方法，最终调用mDownloadTask.destroy，导致“下载服务”的Receiver被注销，即使文件下载了也没有回调回来
                // NOTE isNeedToDownload方法会调用pluginDownloaded再次尝试加载
                if (isNeedToDownload(context, plugin)) {
                    return RePlugin.getConfig().getCallbacks().onPluginNotExistsForActivity(context, plugin, intent, process);
                }
            }
        }

        /* 检查是否是动态注册的类 */
        // 如果要启动的 Activity 是动态注册的类，则不使用坑位机制，而是直接动态类。
        // 原因：宿主的某些动态注册的类不能运行在坑位中（如'桌面'插件的入口Activity）
        if (LOG) {
            LogDebug.d("loadClass", "isHookingClass(" + plugin + " , " + activity + ") = "
                    + Factory2.isDynamicClass(plugin, activity));
        }

        if (Factory2.isDynamicClass(plugin, activity)) {
            intent.putExtra(IPluginManager.KEY_COMPATIBLE, true);
            intent.setComponent(new ComponentName(IPC.getPackageName(), activity));
            context.startActivity(intent);
            return true;
        }

        // 如果插件状态出现问题，则每次弹此插件的Activity都应提示无法使用，或提示升级（如有新版）
        // Added by Jiongxuan Zhang
        if (PluginStatusController.getStatus(plugin) < PluginStatusController.STATUS_OK) {
            if (LOG) {
                LogDebug.d(PLUGIN_TAG, "PluginLibraryInternalProxy.startActivity(): Plugin Disabled. pn=" + plugin);
            }
            return RePlugin.getConfig().getCallbacks().onPluginNotExistsForActivity(context, plugin, intent, process);
        }

        // 若为首次加载插件，且是“大插件”，则应异步加载，同时弹窗提示“加载中”
        // Added by Jiongxuan Zhang
        if (!RePlugin.isPluginDexExtracted(plugin)) {
            PluginDesc pd = PluginDesc.get(plugin);
            if (pd != null && pd.isLarge()) {
                if (LOG) {
                    LogDebug.d(PLUGIN_TAG, "PM.startActivity(): Large Plugin! p=" + plugin);
                }
                return RePlugin.getConfig().getCallbacks().onLoadLargePluginForActivity(context, plugin, intent, process);
            }
        }

        // WARNING：千万不要修改intent内容，尤其不要修改其ComponentName
        // 因为一旦分配坑位有误（或压根不是插件Activity），则外界还需要原封不动的startActivity到系统中
        // 可防止出现“本来要打开宿主，结果被改成插件”，进而无法打开宿主Activity的问题

        // 缓存打开前的Intent对象，里面将包括Action等内容
        Intent from = new Intent(intent);

        // 帮助填写打开前的Intent的ComponentName信息（如有。没有的情况如直接通过Action打开等）
        if (!TextUtils.isEmpty(plugin) && !TextUtils.isEmpty(activity)) {
            from.setComponent(new ComponentName(plugin, activity));
        }

        ComponentName cn = mPluginMgr.mLocal.loadPluginActivity(intent, plugin, activity, process);
        if (cn == null) {
            if (LOG) {
                LogDebug.d(PLUGIN_TAG, "plugin cn not found: intent=" + intent + " plugin=" + plugin + " activity=" + activity + " process=" + process);
            }
            return false;
        }

        // 将Intent指向到“坑位”。这样：
        // from：插件原Intent
        // to：坑位Intent
        intent.setComponent(cn);

        if (LOG) {
            LogDebug.d(PLUGIN_TAG, "start activity: real intent=" + intent);
        }

        context.startActivity(intent);

        // 通知外界，已准备好要打开Activity了
        // 其中：from为要打开的插件的Intent，to为坑位Intent
        RePlugin.getConfig().getEventCallbacks().onPrepareStartPitActivity(context, from, intent);

        return true;
    }

其中会先检查插件的状态，若插件未加载，会回调让用户去加载。

ComponentName cn = mPluginMgr.mLocal.loadPluginActivity(intent, plugin, activity, process);

接着寻找坑位，Replugin插件化技术最关键的2个技术点，一个是四大组件占坑，二是只有一个hook点classloader。在PluginCommImpl加载插件的Activity时，通过调用远程方法进行坑位分配。

  public ComponentName loadPluginActivity(Intent intent, String plugin, String activity, int process) {

        ActivityInfo ai = null;
        String container = null;
        PluginBinderInfo info = new PluginBinderInfo(PluginBinderInfo.ACTIVITY_REQUEST);

        try {
            // 获取 ActivityInfo(可能是其它插件的 Activity，所以这里使用 pair 将 pluginName 也返回)
            ai = getActivityInfo(plugin, activity, intent);
            if (ai == null) {
                if (LOG) {
                    LogDebug.d(PLUGIN_TAG, "PACM: bindActivity: activity not found");
                }
                return null;
            }

            // 存储此 Activity 在插件 Manifest 中声明主题到 Intent
            intent.putExtra(INTENT_KEY_THEME_ID, ai.theme);
            if (LOG) {
                LogDebug.d("theme", String.format("intent.putExtra(%s, %s);", ai.name, ai.theme));
            }

            // 根据 activity 的 processName，选择进程 ID 标识
            if (ai.processName != null) {
                process = PluginClientHelper.getProcessInt(ai.processName);
            }

            // 容器选择（启动目标进程）
            IPluginClient client = MP.startPluginProcess(plugin, process, info);
            if (client == null) {
                return null;
            }

            // 远程分配坑位
            container = client.allocActivityContainer(plugin, process, ai.name, intent);
            if (LOG) {
                LogDebug.i(PLUGIN_TAG, "alloc success: container=" + container + " plugin=" + plugin + " activity=" + activity);
            }
        } catch (Throwable e) {
            if (LOGR) {
                LogRelease.e(PLUGIN_TAG, "l.p.a spp|aac: " + e.getMessage(), e);
            }
        }

        // 分配失败
        if (TextUtils.isEmpty(container)) {
            return null;
        }

        PmBase.cleanIntentPluginParams(intent);

        // TODO 是否重复
        // 附上额外数据，进行校验
//        intent.putExtra(PluginManager.EXTRA_PLUGIN, plugin);
//        intent.putExtra(PluginManager.EXTRA_ACTIVITY, activity);
//        intent.putExtra(PluginManager.EXTRA_PROCESS, process);
//        intent.putExtra(PluginManager.EXTRA_CONTAINER, container);

        PluginIntent ii = new PluginIntent(intent);
        ii.setPlugin(plugin);
        ii.setActivity(ai.name);
        ii.setProcess(IPluginManager.PROCESS_AUTO);
        ii.setContainer(container);
        ii.setCounter(0);
        return new ComponentName(IPC.getPackageName(), container);
    }

远程调用找到坑位后，将要启动的目标Activity、插件名称、坑位等信息保存到PluginIntent中，PluginIntent没发现什么大用处，保存了信息，但又没把信息返回给调用方，loadPluginActivity方法将坑位信息返回。

坑位的分配在PluginProcessPer.java中的allocActivityContainer方法中，再看bindActivity方法中继续调用其他方法进行坑位分配。

final String bindActivity(String plugin, int process, String activity, Intent intent) {
        /* 获取插件对象 */
        Plugin p = mPluginMgr.loadAppPlugin(plugin);
        if (p == null) {
            if (LOG) {
                LogDebug.w(PLUGIN_TAG, "PACM: bindActivity: may be invalid plugin name or load plugin failed: plugin=" + plugin);
            }
            return null;
        }

        /* 获取 ActivityInfo */
        ActivityInfo ai =   p.mLoader.mComponents.getActivity(activity);
······
// 自定义进程`
 if (ai.processName.contains(PluginProcessHost.PROCESS_PLUGIN_SUFFIX2)) {
    String processTail = PluginProcessHost.processTail(ai.processName);
    container = mACM.alloc2(ai, plugin, activity, process, intent, processTail);
} else {
    container = mACM.alloc(ai, plugin, activity, process, intent);
}

首先根据插件名称去获取加载的插件信息，插件信息中包含待启动Activity的类名、主题、启动模式等信息。

再看PluginContainers类中的alloc2方法，根据Activity不同的启动模式，分配不同的坑位，宿主的gradle在编译阶段会给不同启动模式的Activity都生成一定数量的坑位。所以在分配坑位时，也根据当前要启动的Activity的启动模式去对应的坑位集合中去寻找坑位。

tring alloc2(ActivityInfo ai, String plugin, String activity, int process, Intent intent, String processTail) {
    // 根据进程名称，取得该进程对应的 PluginContainerStates
    ProcessStates states = mProcessStatesMap.get(processTail);

    ActivityState state;

    String defaultPluginTaskAffinity = ai.applicationInfo.packageName;
    if (LOG) {
        LogDebug.d(TaskAffinityStates.TAG, String.format("插件 %s 默认 TaskAffinity 为 %s", plugin, defaultPluginTaskAffinity));
        LogDebug.d(TaskAffinityStates.TAG, String.format("%s 的 TaskAffinity 为 %s", activity, ai.taskAffinity));
    }

    /* SingleInstance */
    if (ai.launchMode == LAUNCH_SINGLE_INSTANCE) {
        synchronized (mLock) {
            state = allocLocked(ai, states.mLaunchModeStates.getStates(ai.launchMode, ai.theme), plugin, activity, intent);
        }

    /* TaskAffinity */
    } else if (!defaultPluginTaskAffinity.equals(ai.taskAffinity)) { // 非默认 taskAffinity
        synchronized (mLock) {
            state = allocLocked(ai, states.mTaskAffinityStates.getStates(ai), plugin, activity, intent);
        }

    /* other mode */
    } else {
        synchronized (mLock) {
            state = allocLocked(ai, states.mLaunchModeStates.getStates(ai.launchMode, ai.theme), plugin, activity, intent);
        }
    }

    if (state != null) {
        return state.container;
    }
    return null;
}

真正执行坑位的方法allocLocked方法

private final ActivityState allocLocked(ActivityInfo ai, HashMap<String, ActivityState> map,
                                        String plugin, String activity, Intent intent) {
    ······

    // 新分配：找空白的，第一个
    for (ActivityState state : map.values()) {
        if (state.state == STATE_NONE) {
            if (LOG) {
                LogDebug.d(PLUGIN_TAG, "PACM: alloc empty container=" + state.container);
            }
            state.occupy(plugin, activity);
            return state;
        }
    }
    ·······

    // never reach here
    return null;
}

在allocLocked方法中坑位Activity和真实要启动的Activity之间的对应关系，被保存在ActivityState类中，plugin是插件名，activity是待启动的插件中的activity，container是坑位。

static final class ActivityState {

    final String container;

    int state;

    String plugin;

    String activity;

    long timestamp;

    final ArrayList<WeakReference<Activity>> refs;
    ···
}

坑位container到底是什么样的一个东西呢，搜索container在哪里进行了赋值，发现container只在ActivityState 的构造函数中进行了赋值。搜索构造函数的调用方，可以在LaunchModeStates看到相关代码。

    /**
     * 初始化 LaunchMode 和 Theme 对应的坑位
     *
     * @param containers  保存所有 activity 坑位的引用
     * @param prefix      坑位前缀
     * @param launchMode  launchMode
     * @param translucent 是否是透明的坑
     * @param count       坑位数
     */
    void addStates(Map<String, ActivityState> allStates, HashSet<String> containers, String prefix, int launchMode, boolean translucent, int count) {
        String infix = getInfix(launchMode, translucent);
        HashMap<String, ActivityState> states = mStates.get(infix);
        if (states == null) {
            states = new HashMap<>();
            mStates.put(infix, states);
        }

        for (int i = 0; i < count; i++) {
            String key = prefix + infix + i;

            // 只有开启“详细日志”时才输出每一个坑位的信息，防止刷屏
            if (RePlugin.getConfig().isPrintDetailLog()) {
                LogDebug.d(TAG, "LaunchModeStates.add(" + key + ")");
            }

            ActivityState state = new ActivityState(key);
            states.put(key, state);
            allStates.put(key, state);
            containers.add(key);
        }
    }

可以看出，在循环中container = prefix + infix +i;infix的值可以在getInfix方法查看。继续往上查找调用关系，查看PluginContainers.java中的init方法。

    final void init(int process, HashSet<String> containers) {
        if (process != IPluginManager.PROCESS_UI
                && !PluginProcessHost.isCustomPluginProcess(process)
                && !PluginManager.isPluginProcess()) {
            return;
        }

        //prefix = 包名+“.loader.a.Activity”
        String prefix = IPC.getPackageName() + CONTAINER_ACTIVITY_PART; 

        // 因为自定义进程可能也会唤起使用 UI 进程的坑，所以这里使用'或'条件
        if (process == IPluginManager.PROCESS_UI || PluginProcessHost.isCustomPluginProcess(process)) {

            /* UI 进程标识为 N1 */
            String suffix = "N1";

            // Standard
            mLaunchModeStates.addStates(mStates, containers, prefix + suffix, LAUNCH_MULTIPLE, true, HostConfigHelper.ACTIVITY_PIT_COUNT_TS_STANDARD);
            mLaunchModeStates.addStates(mStates, containers, prefix + suffix, LAUNCH_MULTIPLE, false, HostConfigHelper.ACTIVITY_PIT_COUNT_NTS_STANDARD);
        ······
        }
    }

基本可以看出container的根据不同启动模式、主题等有所不同，但基本类似于：包名+“.loader.a.Activity”+“N1”+“NR”+“NTS”+i，i代表数字编号。可以看出来就是replugin- host-gradle插件在AndroidManifest.xml文件中生成的坑位。

插件Activity的坑位找到后，就调用startActivity通知AMS去启动坑位Activity，中间还有一大堆的流程略过，然后要进行类的加载。这时Replugin中的RepluginClassLoader开始发挥作用了。

RepluginClassLoader的loadClass方法最终会调用PmBase类中的loadClass方法。

    final Class<?> loadClass(String className, boolean resolve) {
        // 加载Service中介坑位
        if (className.startsWith(PluginPitService.class.getName())) {
            if (LOG) {
                LogDebug.i(TAG, "loadClass: Loading PitService Class... clz=" + className);
            }
            return PluginPitService.class;
        }

        //
        if (mContainerActivities.contains(className)) {
            Class<?> c = mClient.resolveActivityClass(className);
            if (c != null) {
                return c;
            }
            // 输出warn日志便于查看
            // use DummyActivity orig=
            if (LOGR) {
                LogRelease.w(PLUGIN_TAG, "p m hlc u d a o " + className);
            }
            return DummyActivity.class;
        }
      ······
}

再看看关键的PluginProcessPer类的resolveActivityClass方法，找到要真正启动的Activity类，并进行加载。

    final Class<?> resolveActivityClass(String container) {
        String plugin = null;
        String activity = null;

        // 先找登记的，如果找不到，则用forward activity
        PluginContainers.ActivityState state = mACM.lookupByContainer(container);
        ······
        plugin = state.plugin;
        activity = state.activity;
        Plugin p = mPluginMgr.loadAppPlugin(plugin);
        ······
        ClassLoader cl = p.getClassLoader();
        Class<?> c = null;
        try {
            c = cl.loadClass(activity);
        } catch (Throwable e) {
            if (LOGR) {
                LogRelease.e(PLUGIN_TAG, e.getMessage(), e);
            }
        }
        return c;
    }

而lookupByContainer方法在PluginContainer类中，前面查找坑位的时候，也是用的PluginContainer中的alloc2、allocLocked方法。坑位与真实待启动Activity的对应关系就保存在ActivityState中。
找到插件中真正待启动Activity的类信息后，进行类加载，然后就是Android系统Activity的启动流程。从而通过占坑骗过了AMS的校验，通过hook系统ClassLoader完成真实插件Activity类的加载，进而通过系统完成插件Activity的启动。