小白也能看懂的插件化DroidPlugin原理（三）-- 如何攔截startActivity方法

　　前言：在前兩篇文章中分別介紹了動態代理、反射機制和Hook機制，如果對這些還不太了解的童鞋建議先去參考一下前兩篇文章。經過了前面兩篇文章的鋪墊，終於可以玩點真刀實彈的了，本篇將會通過 Hook 掉 startActivity 方法的一個小例子來介紹如何找出合適的 Hook 切入點。 開始之前我們需要知道的一點就是，其實在 Android 里面啟動一個 Activity 可以通過兩種方式實現，一種是我們常用的調用 Activity.startActivity 方法，一種是調用 Context.startActivity 方法，兩種方法相比之下， 第一種啟動Activity的方式更為簡單，所以先以第一種為例。

　　本系列文章的代碼已經上傳至github，下載地址：https://github.com/lgliuwei/DroidPluginStudy 本篇文章對應的代碼在 com.liuwei.proxy_hook.hook.activityhook 包內，下載下來對照代碼看文章效果會更好！

一、Hook 掉 Activity 的 startActivity 的方法

　　在 Hook Activity 的 startActivity 方法之前，我們首先明確一下我們的目標，我們先通過追蹤源碼找出 startActivity 調用的真正起作用的方法，然后想辦法把目標方法攔截掉，並輸出我們的一條 Log 信息。

　　我們先來一步步分析 startActivity 的源碼，隨手寫一個 startActivity 的示例，按住 command 鍵（ windows 下按住 control ）用鼠標點擊 startActivity的方法即可跳轉到方法里面。

　　startActivity(Intent intent) 源碼如下：

public void startActivity(Intent intent) {
        this.startActivity(intent, null);
}

　　接着看 this.startActivity(intent, null) 方法源碼：

public void startActivity(Intent intent, @Nullable Bundle options) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            // Note we want to go through this call for compatibility with
            // applications that may have overridden the method.
            startActivityForResult(intent, -1);
        }
}

　　從上一步傳入的參數 options 為 null 我們就可以知道這一步調用了 startActivityForResult(intent, -1) 的代碼。

　　startActivityForResult(Intent intent, int requestCode) 源碼如下：

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
        startActivityForResult(intent, requestCode, null);
}

　　startActivityForResult(Intent intent, int requestCode, Bundle options) 源碼如下：

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) {
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
 6                 mInstrumentation.execStartActivity(
 7                     this, mMainThread.getApplicationThread(), mToken, this,
 8                     intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= 0) {
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }

            cancelInputsAndStartExitTransition(options);
            // TODO Consider clearing/flushing other event sources and events for child windows.
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
}

 　　到這一步我們已經看到了關鍵點，注意上面代碼塊中紅色的代碼，其實 startActivity 真正調用的是 mInstrumentation.execStartActivity(...) 方法，mInstrumentation 是 Activity 的一個私有變量。接下來的任務將變得非常簡單，回憶一下上一篇博文《小白也能看懂插件化DroidPlugin原理（二）-- 反射機制和Hook入門》中的方案一，在替換汽車引擎時我們繼承原來的汽車引擎類創建了一個新類，然后在新引擎類中攔截了最大速度的方法，這里的思路是一樣的，我們直接新建一個繼承 Instrumentation 的新類，然后重寫 execStartActivity() 。對此有不明白的童鞋建議再看一遍上一篇博文《小白也能看懂插件化DroidPlugin原理（二）-- 反射機制和Hook入門》。代碼如下：

public class EvilInstrumentation extends Instrumentation {
    private Instrumentation instrumentation;
    public EvilInstrumentation(Instrumentation instrumentation) {
        this.instrumentation = instrumentation;
    }
    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        Logger.i(EvilInstrumentation.class, "請注意! startActivity已經被hook了!");
        try {
            Method execStartActivity = Instrumentation.class.getDeclaredMethod("execStartActivity", Context.class,
                    IBinder.class, IBinder.class, Activity.class,
                    Intent.class, int.class, Bundle.class);
            return (ActivityResult)execStartActivity.invoke(instrumentation, who, contextThread, token, target,
                    intent, requestCode, options);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

 　　重寫工作已經做完了，接着我們通過反射機制用新建的 EvilInstrumentation 替換掉 Activity 的 mInstrumentation 變量，具體代碼如下：

public static void doActivityStartHook(Activity activity){
        try {
            Field mInstrumentationField = Activity.class.getDeclaredField("mInstrumentation");
            mInstrumentationField.setAccessible(true);
            Instrumentation originalInstrumentation = (Instrumentation)mInstrumentationField.get(activity);
            mInstrumentationField.set(activity, new EvilInstrumentation(originalInstrumentation));
        } catch (Exception e) {
            e.printStackTrace();
        }
}

 　　這對於我們來說已經很是輕車熟路了，很快就寫完了，然后我們在 Activity 的 onCreate() 方法中需要調用一下 doActivityStartHook 即可完成對 Activity.startActivity 的 hook。MainActivity 的代碼如下：

public class MainActivity extends Activity {
    private Button btn_start_by_activity;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // hook Activity.startActivity()的方法時不知道這行代碼為什么放在attachBaseContext里面不行？
        // 調試發現,被hook的Instrumentation后來又會被替換掉原來的。
        ActivityThreadHookHelper.doActivityStartHook(this);
        btn_start_by_activity = (Button) findViewById(R.id.btn_start_by_activity);
        btn_start_by_activity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, OtherActivity.class);
                startActivity(intent);
            }
        });
    }
}

 　　程序運行之后，點擊啟動 Activity 的按鈕將輸出以下 Log：

　　 [EvilInstrumentation] : 請注意! startActivity已經被hook了!

 　　到此為止我們已經 hook 了 Activity 的 startActivity 方法，非常簡單，代碼量也很少，但我們也很輕易的發現這種方法需要在每一個 Activity 的 onCreate 方法里面調用一次 doActivityStartHook 方法，顯然這不是一個好的方案，所以我們在尋找 hook 點時一定要注意盡量找一些在進程中保持不變或不容易被改變的變量，就像單例和靜態變量。

　　問題1：在這里有一點值得一提，我們將 doActivityStartHook(...) 方法的調用如果放到  MainActivity 的 attachBaseContext(...) 方法中替換工作將不會生效，為什么？

　　調試發現，我們在 attachBaseContext(..) 里面執行完畢 doActivityStartHook(...) 方法后確實將 Activity 的 mInstrumentation 變量換成了我們自己的 EvilInstrumentation，但程序執行到 onCreate() 方法后就會發現這時候 mInstrumentation 變成了系統自己的 Instrumentation 對象了。這時候我們可以確信的是 mInstrumentation 變量一定是在 attachBaseContext() 之后被初始化或者賦值的。帶着這個目標我們很輕松就在 Activity 源碼的 attach() 方法中找到如下代碼：

　　Activity.attach() 的源碼如下（注意第8行和第26行）：

　　final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window) {
 8         attachBaseContext(context);

        mFragments.attachHost(null /*parent*/);

        mWindow = new PhoneWindow(this, window);
        mWindow.setWindowControllerCallback(this);
        mWindow.setCallback(this);
        mWindow.setOnWindowDismissedCallback(this);
        mWindow.getLayoutInflater().setPrivateFactory(this);
        if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
            mWindow.setSoftInputMode(info.softInputMode);
        }
        if (info.uiOptions != 0) {
            mWindow.setUiOptions(info.uiOptions);
        }
        mUiThread = Thread.currentThread();

        mMainThread = aThread;
26         mInstrumentation = instr;
        mToken = token;
        mIdent = ident;
        mApplication = application;
        mIntent = intent;
        mReferrer = referrer;
        mComponent = intent.getComponent();
        mActivityInfo = info;
        mTitle = title;
        mParent = parent;
        mEmbeddedID = id;
        mLastNonConfigurationInstances = lastNonConfigurationInstances;
        if (voiceInteractor != null) {
            if (lastNonConfigurationInstances != null) {
                mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
            } else {
                mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
                        Looper.myLooper());
            }
        }

        mWindow.setWindowManager(
                (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                mToken, mComponent.flattenToString(),
                (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
        if (mParent != null) {
            mWindow.setContainer(mParent.getWindow());
        }
        mWindowManager = mWindow.getWindowManager();
        mCurrentConfig = config;
    }

　　至此，問題1算是找到了答案。

二、Hook 掉 Context 的 startActivity 的方法

　　文章開頭我們就說 Android 中有個兩種啟動 Activity 的方式，一種是 Activity.startActivity 另一種是 Context.startActivity，但需要注意的時，我們在使用 Context.startActivity 啟動一個 Activity 的時候將 flags 指定為 FLAG_ACTIVITY_NEW_TASK。

　　在接下來的分析中需要查看 Android 源碼，先推薦兩個查看 Android 源碼的網站：

　　http://androidxref.com

　　http://grepcode.com/project/repository.grepcode.com/java/ext/com.google.android/android/

　　我們試着 hook 掉 Context.startActivity 方法，我們依然隨手寫一個 Context 方式啟動 Activity 的示例，如下：

Intent intent = new Intent(MainActivity.this, OtherActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
getApplicationContext().startActivity(intent);

 　　照着（一）中的姿勢點入 startActivity() 方法里面，由於 Context 是一個抽象類，所以我們需要找到它的實現類才能看到具體的代碼，通過查看 Android 源碼我們可以在 ActivityTread 中可知 Context 的實現類是 ContextImpl。（在這里大家先知道這一點就行，具體的調用細節將會在下一篇博文中詳細介紹）

　　源碼地址：

　　http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/app/ActivityThread.java#2338

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ...
            if (activity != null) {
 4                 Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
        ...
}
        ...
private Context createBaseContextForActivity(ActivityClientRecord r, final Activity activity) {
11          ContextImpl appContext = ContextImpl.createActivityContext(this, r.packageInfo, r.token);
12          appContext.setOuterContext(activity);
13          Context baseContext = appContext;
         ...
}

 　  現在我們來查看 ContextImpl.startActivity() 的源碼。 

　　源碼地址：

　　http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/app/ContextImpl.java#ContextImpl.startActivity%28android.content.Intent%29

@Override
public void startActivity(Intent intent) {
        warnIfCallingFromSystemProcess();
        startActivity(intent, null);
}

　　再進入 startActivity(intent, null) 查看源碼如下：

@Override
public void startActivity(Intent intent, Bundle options) {
        warnIfCallingFromSystemProcess();
        if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
            throw new AndroidRuntimeException(
                    "Calling startActivity() from outside of an Activity "
                    + " context requires the FLAG_ACTIVITY_NEW_TASK flag."
                    + " Is this really what you want?");
        }
10         mMainThread.getInstrumentation().execStartActivity(
11             getOuterContext(), mMainThread.getApplicationThread(), null,
12             (Activity)null, intent, -1, options);
}

 　　由上面第四行代碼可以看出在代碼中判斷了 intent 的 flag 類型，如果非 FLAG_ACTIVITY_NEW_TASK 類型就會拋出異常。接着看紅色部分的關鍵代碼，可以看出先從 ActivityTread 中獲取到了 Instrumentation 最后還是調用了 Instrumentation 的 execStartActivity(...) 方法，我們現在需要做的就是分析 ActivityTread 類，並想辦法用我們自己寫的 EvilInstrumentation 類將 ActivityTread 的 mInstrumentation 替換掉。

　　源碼地址：

　　http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/app/ActivityThread.java#ActivityThread.0sCurrentActivityThread

　　ActivityTread 部分代碼如下：

206     private static ActivityThread sCurrentActivityThread;
207     Instrumentation mInstrumentation;
...
1597    public static ActivityThread currentActivityThread() {
1598        return sCurrentActivityThread;
1599    }
...
1797    public Instrumentation getInstrumentation()
1798    {
1799        return mInstrumentation;
1800    }

　　這里需要告訴大家是，ActivityTread 即代表應用的主線程，而一個應用中只有一個主線程，並且由源碼可知，ActivityTreadd 的對象又是以靜態變量的形式存在的，太好了，這正是我們要找的 Hook 點。廢話不多說了，現在我們只需利用反射通過 currentActivityThread() 方法拿到 ActivityThread 的對象，然后在將 mInstrumentation 替換成 EvilInstrumentation 即可，代碼如下：

 1　　 public static void doContextStartHook(){
        try {
            Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
            Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");
            Object activityThread = currentActivityThreadMethod.invoke(null);

            Field mInstrumentationField = activityThreadClass.getDeclaredField("mInstrumentation");
            mInstrumentationField.setAccessible(true);
            Instrumentation originalInstrumentation = (Instrumentation)mInstrumentationField.get(activityThread);
            mInstrumentationField.set(activityThread, new EvilInstrumentation(originalInstrumentation));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

  　　其實代碼也不難理解，跟 Hook Activity 的 startActivity() 方法是一個思路，只是 Hook 的點不同而已。下面我們在 MainActivity 的 attachBaseContext() 方法中調用 doContextStartHook() 方法，並添加相關測試代碼，具體代碼如下：

public class MainActivity extends Activity {
    private Button btn_start_by_context;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn_start_by_context = (Button) findViewById(R.id.btn_start_by_context);
        btn_start_by_context.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(MainActivity.this, OtherActivity.class);
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                getApplicationContext().startActivity(intent);
            }
        });
    }
    @Override
    protected void attachBaseContext(Context newBase) {
        super.attachBaseContext(newBase);
        ActivityThreadHookHelper.doContextStartHook();
    }
}

 　　點擊按鈕后查看 Log 輸出如下：

　　 [EvilInstrumentation] : 請注意! startActivity已經被hook了!

 　　看到這樣的 Log，說明我們已經成功的 Hook 了 Context.startActivity()。而且 doContextStartHook() 方法只在程序開始的時候調用一次即可，后面在程序其他的 Activity 中調用 Context.startActivity() 時此攔截工作均可生效，這是因為 Context.startActivity() 在執行啟動 Activity 的操作時調是通過 ActivityTread 獲取到 Instrumentation，然后再調用 Instrumentation.execStartActivity() 方法，而 ActivityTread 在程序中是以單例的形式存在的，這就是原因。所以說調用 doContextStartHook() 方法最好的時機應該是放在 Application 中。

　　注意！前方驚現彩蛋一枚！！

　　將 doContextStartHook() 方法放入到了 MyApplication 的 attachBaseContext() 里面后，代碼如下：

public class MyApplication extends Application {
    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
5         ActivityThreadHookHelper.doContextStartHook();
    }
} 

　　MainActivity 的代碼如下：

public class MainActivity extends Activity {
    private final static String TAG = MainActivity.class.getSimpleName();
    private Button btn_start_by_activity;
    private Button btn_start_by_context;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn_start_by_activity = (Button) findViewById(R.id.btn_start_by_activity);
        btn_start_by_context = (Button) findViewById(R.id.btn_start_by_context);
11         ActivityThreadHookHelper.doActivityStartHook(this);
        btn_start_by_activity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: Activity.startActivity()");
                Intent intent = new Intent(MainActivity.this, OtherActivity.class);
                startActivity(intent);
            }
        });

        btn_start_by_context.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: Context.startActivity()");
                Intent intent = new Intent(MainActivity.this, OtherActivity.class);
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                getApplicationContext().startActivity(intent);
            }
        });
    }
}

 　　代碼如上，布局文件很簡單就不貼出來了，就是兩個按鈕，一個測試 Activity.startActivity() 方法，一個測試 Context.startActivity() 方法，然后在 MainActivity 的 onCreate() 中調用了 doActivityStartHook() 在 MyApplication 里面調用了 doContextStartHook(), 目前看來代碼很正常，符合我們上面的思路，但樓主在點擊按鈕發現 Log 輸出如下：

　　是的，Activity.startActivity 被 hook 的信息輸出了兩次！為什么？

　　我們不妨先猜想一下，一定是 Activity 的 mInstrumentation 對象在我們替換之前就已經變成了 EvilInstrumentation, 然后我們又在 Activity.onCreate 方法調用了一次 doActivityStartHook(), 相當於我們又用 EvilInstrumentation 又重寫了 EvilInstrumentation 的 startActivity() 方法，所以導致 log 信息輸出了兩次。

　　那問題又來了，為什么 Activity 的 mInstrumentation 對象在我們替換之前就已經變成了 EvilInstrumentation? 

　　縱觀代碼，只有一個地方有疑點，那就是我們放到 MyApplication.attachBaseContext() 方法里面的 doContextStartHook() 起的作用！

　　還是先直接簡單說一下事實的真相吧，結合上文所說，一個應用內只存在一個 ActivityTread 對象，也只存在一個 Instrumentation 對象，這個 Instrumentation 是 ActivityTread 的成員變量，並在 ActivityTread 內完成初始化，在啟動一個 Activity 的流程中大概在最后的位置 ActivityTread 會回調 Activity 的 attach() 方法，並將自己的 Instrumentation 對象傳給 Activity。啟動 Activity 的詳細流程及調用細節將會在下一篇博文介紹，敬請期待！

三、小結

　　本篇文章通過攔截 Context.startActivity() 和 Activity.startActivity() 兩個方法，將上一篇文章中介紹的 Hook 技術實踐 Activity 的啟動流程之中，同時通過這兩個小例子初步了解了 Android 源碼以及怎么樣去選定一個合適的 Hook 點。想要了解插件化的基本原理，熟悉 Activity 的啟動流程是必不可少的，下一篇文章將會詳細介紹 Activity 的啟動流程，感興趣的同學可以關注一下！

參考文章

　　《Android插件化原理解析——Hook機制之動態代理》

　　《Android應用程序的Activity啟動過程簡要介紹和學習計划》

本文鏈接：http://www.cnblogs.com/codingblock/p/6666239.html