Activity啟動流程

Activity啟動流程分析有很多文章了，為什么我要再寫一篇，因為我覺得大部分的文章講的都有點復(fù)雜，個人經(jīng)驗認(rèn)為學(xué)習(xí)一種技術(shù)盡量從全局去看，否則會陷入細(xì)節(jié)而讓自己對這種技術(shù)沒有一個全局的概念，看了網(wǎng)上幾篇文章，我總結(jié)歸納了一張圖，圖里我也加了很多注釋，先看圖我再補(bǔ)充一下細(xì)節(jié)

Activity啟動流程.jpg

請求階段：

ActivityManagerProxy是ActivityManagerService在app進(jìn)程中的Binder代理對象。調(diào)用ActivityManagerProxy.startActivity()最后會調(diào)用ActivityManagerService.startActivity()。這樣請求就到了ActivityManagerService

響應(yīng)階段：

在不考慮多進(jìn)程的情況下，Activity的啟動過程是一個Binder雙向通信的過程。AMS要主動與app進(jìn)程通信要依靠請求啟動Activity階段傳過來的IBinder對象，這個IBinder對象就是上面介紹過的Instrumentation.execStartActivity()中的 whoThread對象，它實際上是一個ApplicationThreadProxy對象，用來和ApplicationThread通信。AMS通知app進(jìn)程啟動Activity是通過調(diào)用ApplicationThreadProxy.scheduleLaunchActivity()完成的。根據(jù)Binder通信，ApplicationThread.scheduleLaunchActivity()會被調(diào)用。

1. scheduleLaunchActivity()將從AMS中傳過來的參數(shù)封裝成ActivityClientRecord對象，然后將消息發(fā)送給mH，mH是一個Handler對象。
2. H是ActivityThread的內(nèi)部類，繼承自Handler，它在收到LAUNCH_ACTIVITY的消息后，會調(diào)用ActivityThread.handlerLaunchActivity()。
3. handleLaunchActivity()主要調(diào)用了兩個方法：performLaunchActivity()和handleResumeActivity()。performLaunchActivity()會完成Activity的創(chuàng)建，以及調(diào)用Activity的onCreate()、onStart()等方法。handleResumeActivity()會完成Activity.onResume()的調(diào)用。

插件化的實現(xiàn)

插件化的實現(xiàn)有很多種方式，我下面說的方式是我認(rèn)為比較簡單的方式，滴滴的插件化框架貌似就是這么實現(xiàn)的.

假如在插件中有一個未在AndroidManifest.xml注冊的TargetActivity，我們想啟動它，可以分為三步。

1. 在AndroidManifest.xml中預(yù)先注冊一個我們項目中沒有的Activity，例如ProxyActivity。我們把這種行為稱為插樁。
2. 在請求啟動Activity階段，我們把TargetActivity替換成AndroidManifest中預(yù)先注冊的ProxyActivity。
3. 在AMS響應(yīng)階段，Activity實例產(chǎn)生之前，我們再做一個完全相反的動作。即把響應(yīng)信息中要啟動的ProxyActivity替換回TargetActivity。

第一步十分簡單，沒什么好說的。要實現(xiàn)第二步和第三步就需要用到Activity啟動流程的知識了。 在Activity啟動流程中，Instrumentation無論在請求階段還是響應(yīng)階段都扮演著重要的角色。在請求階段Instrumentation.execStartActivity()會被調(diào)用，而在響應(yīng)階段Instrumentation.newActivity()會被調(diào)用。因此如果我們可以Hook Instrumentation，那么我們就可以在execStartActivity()和newActivity()分別完成第二步和第三步中的功能。

ActivityThread中的Instrumentation在什么時候被創(chuàng)建：

public static void main(String[] args) {
    //...
    ActivityThread thread = new ActivityThread();
    thread.attach(false);
    //...
}

private void attach(boolean system) {
    sCurrentActivityThread = this;
    final IActivityManager mgr = ActivityManagerNative.getDefault();
    //與AMS通信
    mgr.attachApplication(mAppThread);
}

public static ActivityThread currentActivityThread() {
    return sCurrentActivityThread;
} 

1. 在ActivityThread的main()方法中，ActivityThread會被初始化并最終把對象保存在靜態(tài)的sCurrentActivityThread中。在一個app進(jìn)程中只有一個ActivityThread實例sCurrentActivityThread。sCurrentActivityThread可以通過ActivityThread.currentActivityThread()拿到。
2. attach()中，mgr.attachApplication(mAppThread)這段代碼又是一個Binder雙向通信的過程，它主要為創(chuàng)建Application對象服務(wù)。整個通信過程和Activity啟動過程類似，我就不再詳細(xì)介紹了。在通信的最后，ActivtiyThread.handleBindApplication()被調(diào)用，而在方法內(nèi)部，Instrumentation被初始化。

總結(jié)：一個App進(jìn)程，只有一個ActivityThread對象，這個對象保存在sCurrentActivityThread中，可以通過ActivityThread.currentActivityThread()獲取。ActivityThread的mInstrumentation會在Application創(chuàng)建之前初始化。

Activity中的Instrumentation在什么時候被設(shè)置:

1. Activtiy中的Instrumentation是通過Activity.attach()傳進(jìn)來的。
2. Activity.attach()在介紹Activity啟動流程時提到過。它會在ActivityThread.performLaunchActivity()中被調(diào)用。
3. 這樣ActivtyThread把自己內(nèi)部的Instrumentation傳遞到了Activity中。

最終目的：Hook Instrumentation:

通過以上分析，我們知道，要Hook app的Instrumentation，只需要替換掉ActivityThread的Instrumentation即可。但是，Android SDK沒有為我們提供任何關(guān)于ActivityThread的api。在滴滴的VirtualAPK插件化框架里重新聲明了這些Android SDK沒有提供的Framework層的類。這些類只有方法的聲明，這樣我們就可以使用這些Android SDK沒有提供的類或隱藏的方法了。需要注意的一點是，AndroidStub應(yīng)該只參與編譯過程，這很簡單，用compileOnly依賴就可以了。

1. 接下來，通過反射替換ActivitThread的Instrumentation：

protected void hookInst rumentation() {
try {
    ActivityThread activityThread = ActivityThread.currentActivityThread();
    Instrumentation baseInstrumentation = activityThread.getInstrumentation();
    final VAInstrumentation instrumentation = createInstrumentation(baseInstrumentation);
    Reflector.with(activityThread).field("mInstrumentation").set(instrumentation);
} catch (Exception e) {
    Log.w(TAG, e);
}
}
public class VAInstrumentation extends Instrumentation {
    private Inst rumentation mBase ;
    private PluginManager mPluginManager;
    public VAInstrumentation(PluginManager pluginManager, Instrumentation base) {
        this.mPluginManager = pluginManager;
        this.mBase = base;
    }
} 

2. 上面的VAInstrumentation是對系統(tǒng)Instrumentation的代理類。在VAInstrumentation的內(nèi)部我們可以加入任何我們想要的邏輯。在Instrumentation.execStartActivity()執(zhí)行前將我們要啟動的Activity替換成預(yù)注冊的ProxyActivity。

public class VAInstrumentation extends Instrumentation implements Handler.Callback {
    @override
    public ActivityResult execStartActivity(
        Context who, 
        IBinder contextThread, 
        IBinder token, 
        String target, 
        Intent intent, 
        int requestCode, 
        Bundle options) (
    injectIntent(intent);
    return mBase.execStartActivity (who, contextThread, token, target, intent, requestCode, options);
}
private void injectIntent(Intent intent) {
    if(intent.getComponent() != null) {
        String targetPackageName = intent.getComponent().getPackageName();
        String targetClassName = intent.getComponent().getClassName();
        //如果啟動插件中的Activity
        if (!targetPackageName.equals(mContext.getPackageName())) (
            //將Activity的原始信息存入Intent中
            intent.putExtra(Constants.KEY_IS_PLUGIN, true);
            intent.putExtra (Constants.KEY_TARGET_ PACKAGE, targetPackageName);
            intent.putExtra(Constants.KEY_TARGET_ACTIVITY, targetClassName);
            //用ProxyActivity替換
            dispatchStubActivity(intent);
        }
    }
}
private void dispatchStubActivity(Intent intent) {
    String stubActivity = "com.like.virtualapk.ProxyActivity";
    intent.setClassName(mContext, stubActivity);
} 

3. 在Instrumentation.newActivity()執(zhí)行前將預(yù)注冊的ProxyActivity替換回我們要啟動的Activity。

@override
public Activity newActivity(ClassLoader cl, String className, Intent intent) {
    try {
        cl.loadClass(className);
    } catch (ClassNotFoundException e) {
        ComponentName component = getComponent(intent);
        if ( component == null) {
            return mBase.newActivity(cl, className, intent) ;
        }
        String targetClassName = component.getClassName();
        Log. i(TAG, String. format("newActivity[%s : &s/%s]", className, component.getPackageName(), targetClassName));
        Activity activity = mBase.newActivity(cl, targetClassName, intent);
        activity.setIntent(intent);
        return activity;
    }
    return mBase.newActivity(cl, className, intent);
}
public static boolean isIntentFromPlugin(Intent intent) {
    if ( intent = null) {
        return false;
    }
    return intent.getBooleanExtra(Constants.KEY_IS_PLUGIN, false);
}
public static ComponentName getComponent(Intent intent) {
    if (intent = null) {
        return null;
    }
    if(isIntentFromPlugin(intent)) {
        return new ComponentNameintent.getStringExtra(Constants.KEY_TARGET_PACKAGE),
            intent.getStringExtra(Constants.KEY_TARGET_ACTIVITY));
    }
    return intent.getComponent() ;
} 

加載插件資源：

1. 反射調(diào)用AssetsManager的addAssetPath方法，將外部的apk路徑添加進(jìn)去，構(gòu)建新的Resource對象。
2. 通過DexClassLoader加載R.class，通過資源名稱獲取對應(yīng)的id，通過上述構(gòu)建的Resource和資源id獲取資源對象。

/**
* 反射添加資源路徑，并創(chuàng)建新的Resources 對象
*/
private Resources getPluginResources() {
    try {
        AssetManager assetManager = AssetManager.class.newInstance();
        //反射獲取AssetManager的addAssetPath方法
        Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
        //將插件包地址添加進(jìn)行
        addAssetPath.invoke(assetManager, apkDir+ File.separator+apkName);
        Resources superRes = context.getResources();
        //創(chuàng)建Resources
        Resources mResources = new Resources(assetManager, superRes.getDisplayMetrics(),
                superRes.getConfiguration());
        return mResources;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

/**
* 1. 先獲取資源的名稱對應(yīng)的id（通過反射R.class文件的變量）
* 2. 再根據(jù)我們構(gòu)造的Resources 獲取對應(yīng)的資源對象。
*/
public Drawable getApkDrawable(String drawableName){
    try {
        DexClassLoader dexClassLoader = new DexClassLoader(apkDir+File.separator+apkName,
        optimizedDirectoryFile.getPath(), null, context.getClassLoader());
 
        //通過使用apk自己的類加載器，反射出R類中相應(yīng)的內(nèi)部類進(jìn)而獲取我們需要的資源id
        Class<?> clazz = dexClassLoader.loadClass(apkPackageName + ".R$drawable");
        Field field = clazz.getDeclaredField(drawableName);
        int resId = field.getInt(R.id.class);//得到圖片id
        Resources mResources = getPluginResources();
        assert mResources != null;
        return mResources.getDrawable(resId);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return null;
} 

常見的插件化框架：

1. 靜態(tài)代理 dynamic-load-apk最早使用ProxyActivity這種靜態(tài)代理技術(shù)，由ProxyActivity去控制插件中PluginActivity的生命周期
2. 動態(tài)替換（HOOK） 在實現(xiàn)原理上都是趨近于選擇盡量少的hook，并通過在manifest中預(yù)埋一些組件實現(xiàn)對四大組件的動態(tài)插件化。像Replugin。
3. 容器化框架 VirtualApp能夠完全模擬app的運行環(huán)境，能夠?qū)崿F(xiàn)app的免安裝運行和雙開技術(shù)。
4. Atlas是阿里的結(jié)合組件化和熱修復(fù)技術(shù)的一個app基礎(chǔ)框架，號稱是一個容器化框架。

最后

一、面試合集

在這里插入圖片描述

在這里插入圖片描述

在這里插入圖片描述