小白也能看懂的插件化DroidPlugin原理(美学原理三)– 如何阻止startActivity方法

美学原理 1

 1 public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
 2             @Nullable Bundle options) {
 3         if (mParent == null) {
 4             options = transferSpringboardActivityOptions(options);
 5             Instrumentation.ActivityResult ar =
 6                 mInstrumentation.execStartActivity(
 7                     this, mMainThread.getApplicationThread(), mToken, this,
 8                     intent, requestCode, options);
 9             if (ar != null) {
10                 mMainThread.sendActivityResult(
11                     mToken, mEmbeddedID, requestCode, ar.getResultCode(),
12                     ar.getResultData());
13             }
14             if (requestCode >= 0) {
15                 // If this start is requesting a result, we can avoid making
16                 // the activity visible until the result is received.  Setting
17                 // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
18                 // activity hidden during this time, to avoid flickering.
19                 // This can only be done when a result is requested because
20                 // that guarantees we will get information back when the
21                 // activity is finished, no matter what happens to it.
22                 mStartedActivity = true;
23             }
24 
25             cancelInputsAndStartExitTransition(options);
26             // TODO Consider clearing/flushing other event sources and events for child windows.
27         } else {
28             if (options != null) {
29                 mParent.startActivityFromChild(this, intent, requestCode, options);
30             } else {
31                 // Note we want to go through this method for compatibility with
32                 // existing applications that may have overridden it.
33                 mParent.startActivityFromChild(this, intent, requestCode);
34             }
35         }
36 }

  《Android应用程序的Activity运营进度不难介绍和学习安插》

 1 public class MainActivity extends Activity {
 2     private Button btn_start_by_context;
 3     @Override
 4     protected void onCreate(Bundle savedInstanceState) {
 5         super.onCreate(savedInstanceState);
 6         setContentView(R.layout.activity_main);
 7         btn_start_by_context = (Button) findViewById(R.id.btn_start_by_context);
 8         btn_start_by_context.setOnClickListener(new View.OnClickListener() {
 9             @Override
10             public void onClick(View v) {
11                 Intent intent = new Intent(MainActivity.this, OtherActivity.class);
12                 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
13                 getApplicationContext().startActivity(intent);
14             }
15         });
16     }
17     @Override
18     protected void attachBaseContext(Context newBase) {
19         super.attachBaseContext(newBase);
20         ActivityThreadHookHelper.doContextStartHook();
21     }
22 }

  Activity.attach() 的源码如下(注意第十行和第③6行):

  从上一步传入的参数 options 为 null
我们就能够领略这一步调用了 startActivityForResult(intent, -1) 的代码。

1 public class MyApplication extends Application {
2     @Override
3     protected void attachBaseContext(Context base) {
4         super.attachBaseContext(base);
5         ActivityThreadHookHelper.doContextStartHook();
6     }
7 } 

  再进入 startActivity(intent, null) 查看源码如下:

 1 public class MainActivity extends Activity {
 2     private final static String TAG = MainActivity.class.getSimpleName();
 3     private Button btn_start_by_activity;
 4     private Button btn_start_by_context;
 5     @Override
 6     protected void onCreate(Bundle savedInstanceState) {
 7         super.onCreate(savedInstanceState);
 8         setContentView(R.layout.activity_main);
 9         btn_start_by_activity = (Button) findViewById(R.id.btn_start_by_activity);
10         btn_start_by_context = (Button) findViewById(R.id.btn_start_by_context);
11         ActivityThreadHookHelper.doActivityStartHook(this);
12         btn_start_by_activity.setOnClickListener(new View.OnClickListener() {
13             @Override
14             public void onClick(View v) {
15                 Log.i(TAG, "onClick: Activity.startActivity()");
16                 Intent intent = new Intent(MainActivity.this, OtherActivity.class);
17                 startActivity(intent);
18             }
19         });
20 
21         btn_start_by_context.setOnClickListener(new View.OnClickListener() {
22             @Override
23             public void onClick(View v) {
24                 Log.i(TAG, "onClick: Context.startActivity()");
25                 Intent intent = new Intent(MainActivity.this, OtherActivity.class);
26                 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
27                 getApplicationContext().startActivity(intent);
28             }
29         });
30     }
31 }

   到此甘休大家早已 hook 了 Activity 的 startActivity
方法,万分简单,代码量也很少,但大家也很轻易的发现那种艺术须要在每二个Activity 的 onCreate 方法里面调用3遍 doActivityStartHook
方法,分明那不是1个好的方案,所以大家在寻觅 hook
点时一定要留意尽量找一些在进度中保证不变或不便于被转移的变量,就像单例和静态变量。

   那对于我们来说已经非常熟谙了,非常快就写完了,然后我们在 Activity
的 onCreate() 方法中要求调用一下 doActivityStartHook 即可到位对
Activity.startActivity 的 hook。MainActivity 的代码如下:

 1 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
 2         ...
 3             if (activity != null) {
 4                 Context appContext = createBaseContextForActivity(r, activity);
 5                 CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
 6                 Configuration config = new Configuration(mCompatConfiguration);
 7         ...
 8 }
 9         ...
10 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;
14          ...
15 }

  startActivity(Intent intent) 源码如下:

 1 public class EvilInstrumentation extends Instrumentation {
 2     private Instrumentation instrumentation;
 3     public EvilInstrumentation(Instrumentation instrumentation) {
 4         this.instrumentation = instrumentation;
 5     }
 6     public ActivityResult execStartActivity(
 7             Context who, IBinder contextThread, IBinder token, Activity target,
 8             Intent intent, int requestCode, Bundle options) {
 9         Logger.i(EvilInstrumentation.class, "请注意! startActivity已经被hook了!");
10         try {
11             Method execStartActivity = Instrumentation.class.getDeclaredMethod("execStartActivity", Context.class,
12                     IBinder.class, IBinder.class, Activity.class,
13                     Intent.class, int.class, Bundle.class);
14             return (ActivityResult)execStartActivity.invoke(instrumentation, who, contextThread, token, target,
15                     intent, requestCode, options);
16         } catch (Exception e) {
17             e.printStackTrace();
18         }
19 
20         return null;
21     }
22 }

   到这一步咱们早已看到了关键点,注意下面代码块中青白的代码,其实
startActivity 真正调用的是 mInstrumentation.execStartActivity(…)
方法,mInstrumentation 是
Activity 的贰个民用变量。接下来的职务将变得非凡简单,回忆一下上一篇博文《小白也能看懂插件化DroidPlugin原理(二)–
反射机制和Hook入门》
中的方案一,在轮换小车斯特林发动机时我们继续原来的小车引擎类创造了3个新类,然后在新引擎类中梗阻了最大速度的法子,那里的笔触是均等的,大家一直新建三个继续
Instrumentation 的新类,然后重写 execStartActivity()
。对此有不明了的童鞋建议再看一次上一篇博文《小白也能看懂插件化DroidPlugin原理(二)–
反射机制和Hook入门》
。代码如下:

    其实代码也不难掌握,跟 Hook Activity 的 startActivity()
方法是3个思路,只是 Hook 的点差异而已。上面大家在 MainActivity
的 attachBaseContext() 方法中调用 doContextStartHook()
方法,并丰硕相关测试代码,具体代码如下:

  http://androidxref.com

  startActivityForResult(Intent intent, int requestCode) 源码如下:

  接着看 this.startActivity(intent, null) 方法源码:

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    }

  调节和测试发现,我们在
attachBaseContext(..) 里面执行完结 doActivityStartHook(…) 方法后真正将
Activity 的 mInstrumentation 变量换到了大家友好的
EvilInstrumentation,但程序执行到 onCreate() 方法后就会发现此时候
mInstrumentation 变成了系统协调的 Instrumentation
对象了。那时候大家能够确信的是 mInstrumentation 变量一定是在
attachBaseContext() 之后被初阶化恐怕赋值的。带着这一个目标大家很轻松就在
Activity 源码的 attach() 方法中找到如下代码:

 1   public static void doContextStartHook(){
 2         try {
 3             Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
 4             Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");
 5             Object activityThread = currentActivityThreadMethod.invoke(null);
 6 
 7             Field mInstrumentationField = activityThreadClass.getDeclaredField("mInstrumentation");
 8             mInstrumentationField.setAccessible(true);
 9             Instrumentation originalInstrumentation = (Instrumentation)mInstrumentationField.get(activityThread);
10             mInstrumentationField.set(activityThread, new EvilInstrumentation(originalInstrumentation));
11         } catch (Exception e) {
12             e.printStackTrace();
13         }
14     }

   点击按钮后翻看 Log 输出如下:

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

  本篇小说通过拦截 Context.startActivity() 和 Activity.startActivity()
五个办法,将上一篇文章中牵线的 Hook 技术实施 Activity
的启航流程之中,同时通过那多个小例子初阶摸底了 Android
源码以及哪些去选定一个方便的 Hook 点。想要领悟插件化的基本原理,熟谙Activity 的启航流程是必需的,下一篇小说将会详细介绍 Activity
的起步流程,感兴趣的同桌能够关心一下!

   由地点第4行代码可以看到在代码中判断了 intent 的 flag
类型,若是非 FLAG_ACTIVITY_NEW_TASK
类型就会抛出越发。接着看浅绿灰部分的根本代码,能够看来先从 ActivityTread
中获取到了 Instrumentation 最终如故调用了 Instrumentation 的
execStartActivity(…) 方法,大家昨天须要做的正是分析 ActivityTread
类,并想艺术用大家协调写的 EvilInstrumentation 类将 ActivityTread 的
mInstrumentation 替换掉。

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

  源码地址:

 1 public class MainActivity extends Activity {
 2     private Button btn_start_by_activity;
 3     @Override
 4     protected void onCreate(Bundle savedInstanceState) {
 5         super.onCreate(savedInstanceState);
 6         setContentView(R.layout.activity_main);
 7         // hook Activity.startActivity()的方法时不知道这行代码为什么放在attachBaseContext里面不行?
 8         // 调试发现,被hook的Instrumentation后来又会被替换掉原来的。
10         ActivityThreadHookHelper.doActivityStartHook(this);
11         btn_start_by_activity = (Button) findViewById(R.id.btn_start_by_activity);
12         btn_start_by_activity.setOnClickListener(new View.OnClickListener() {
13             @Override
14             public void onClick(View v) {
15                 Intent intent = new Intent(MainActivity.this, OtherActivity.class);
16                 startActivity(intent);
17             }
18         });
19     }
20 }

   重写工作早就做完了,接着大家由此反射机制用新建的
EvilInstrumentation 替换掉 Activity 的 mInstrumentation
变量,具体代码如下:

  纵观代码,唯有多个地方有疑问,那正是我们松开MyApplication.attachBaseContext() 方法里面包车型地铁 doContextStartHook()
起的功能!

  在 Hook Activity 的 startActivity
方法在此以前,大家先是肯定一下我们的靶子,我们先通过追踪源码找出
startActivity
调用的着实起效果的法子,然后想办法把对象措施拦截掉,并出口我们的一条 Log
新闻。

  源码地址:

  小说初步我们就说 Android 中有个三种运转 Activity 的方法,一种是
Activity.startActivity 另一种是
Context.startActivity,但须求注意的时,大家在行使 Context.startActivity
运转多个 Activity 的时候将 flags 钦命为 FLAG_ACTIVITY_NEW_TASK。

1 @Override
2 public void startActivity(Intent intent) {
3         warnIfCallingFromSystemProcess();
4         startActivity(intent, null);
5 }

   [EvilInstrumentation] :
请注意! startActivity已经被hook了!

  在接下去的辨析中要求查阅 Android 源码,先引进三个查看 Android
源码的网站:

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

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

  那里须求报告大家是,ActivityTread
即代表行使的主线程,而3个用到中唯有二个主线程,并且由源码可见,ActivityTreadd
的对象又是以静态变量的款式存在的,太好了,那多亏我们要找的 Hook
点。废话不多说了,现在大家只需接纳反射通过 currentActivityThread()
方法获得 ActivityThread 的靶子,然后在将 mInstrumentation 替换成EvilInstrumentation 即可,代码如下:

一、Hook 掉 Activity 的 startActivity
的方法

  那难点又来了,为何 Activity 的 mInstrumentation
对象在我们轮换从前就曾经变成了 EvilInstrumentation? 

  ActivityTread 部分代码如下:

  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

  前言:在前两篇作品中分头介绍了动态代理、反射机制和Hook机制,假设对那一个还不太了然的童鞋提议先去参考一下前两篇小说。经过了前边两篇小说的反衬,终于可以玩点真刀实弹的了,本篇将会由此Hook 掉 startActivity 方法的二个小例子来介绍怎么样找出万分的 Hook
切入点。 初始此前大家需求明白的一些正是,其实在 Android 里面运营2个Activity 能够因而二种格局贯彻,一种是大家常用的调用
Activity.startActivity 方法,一种是调用 Context.startActivity
方法,二种办法相比较,
第壹种运维Activity的法子更是简单,所以先以第贰种为例。

  注意!前方惊现彩蛋一枚!!

  大家不妨先猜度一下,一定是 Activity 的 mInstrumentation
对象在大家轮换此前就曾经变为了 EvilInstrumentation, 然后大家又在
Activity.onCreate 方法调用了一回 doActivityStartHook(), 约等于大家又用
EvilInstrumentation 又重写了 EvilInstrumentation 的 startActivity()
方法,所以造成 log 新闻输出了三次。

  照旧先直接省略说一下真情的真相啊,结合上文所说,3个使用内只设有一个ActivityTread 对象,也只存在三个 Instrumentation
对象,那几个 Instrumentation 是 ActivityTread 的积极分子变量,并在
ActivityTread 内到位初叶化,在开发银行3个 Activity 的流水生产线中山大学约在最后的位置ActivityTread 会回调 Activity 的 attach() 方法,并将本身的
Instrumentation 对象传给 Activity。运营 Activity
的事无巨细流程及调用细节将会在下一篇博文介绍,敬请期待!

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

  大家试着 hook 掉 Context.startActivity 方法,我们照例随手写二个Context 情势运维 Activity 的演示,如下:

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

  难点1:在此处有几许值得一提,大家将
doActivityStartHook(…) 方法的调用假诺放置  MainActivity
的 attachBaseContext(…) 方法中替换工作将不会收效,为何?

 1 public static void doActivityStartHook(Activity activity){
 2         try {
 3             Field mInstrumentationField = Activity.class.getDeclaredField("mInstrumentation");
 4             mInstrumentationField.setAccessible(true);
 5             Instrumentation originalInstrumentation = (Instrumentation)mInstrumentationField.get(activity);
 6             mInstrumentationField.set(activity, new EvilInstrumentation(originalInstrumentation));
 7         } catch (Exception e) {
 8             e.printStackTrace();
 9         }
10 }

   代码如上,布局文件非常粗大略就不贴出来了,就是五个按钮,一个测试
Activity.startActivity() 方法,一个测试 Context.startActivity()
方法,然后在 MainActivity 的 onCreate() 中调用了 doActivityStartHook()
在 MyApplication 里面调用了 doContextStartHook(),
近期看来代码很健康,符合我们地点的笔触,但楼主在点击按钮发现 Log
输出如下:

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

  《Android插件化原理分析——Hook机制之动态代理》

   看到这么的 Log,表达大家曾经打响的 Hook 了
Context.startActivity()。而且 doContextStartHook()
方法只在先后起始的时候调用1次即可,后边在先后别的的 Activity 中调用
Context.startActivity() 时此拦截工作均可生效,那是因为
Context.startActivity() 在执行运转 Activity 的操作时调是由此ActivityTread 获取到 Instrumentation,然后再调用
Instrumentation.execStartActivity() 方法,而 ActivityTread
在先后中是以单例的格局存在的,那就是原因。所以说调用
doContextStartHook() 方法最好的空子应该是身处 Application 中。

  本体系小说的代码已经上传至github,下载地址:https://github.com/lgliuwei/DroidPluginStudy 本篇小说对应的代码在 com.liuwei.proxy_hook.hook.activityhook
包内,下载下来对照代码看文章效果会更好!

  是的,Activity.startActivity 被 hook 的消息输出了两回!为何?

   [EvilInstrumentation]
: 请注意! startActivity已经被hook了!

   照着(一)中的姿势点入 startActivity() 方法里面,由于 Context
是多个抽象类,所以我们要求找到它的兑现类才能来看实际的代码,通过查看
Android 源码大家能够在 ActivityTread 中可见 Context 的落到实处类是
ContextImpl。(在那边我们先掌握那点就行,具体的调用细节将会在下一篇博文中详尽介绍)

  将 doContextStartHook() 方法放入到了 MyApplication
的 attachBaseContext() 里面后,代码如下:

参照文章

    今后大家来查看 ContextImpl.startActivity() 的源码。 

 1   final void attach(Context context, ActivityThread aThread,
 2             Instrumentation instr, IBinder token, int ident,
 3             Application application, Intent intent, ActivityInfo info,
 4             CharSequence title, Activity parent, String id,
 5             NonConfigurationInstances lastNonConfigurationInstances,
 6             Configuration config, String referrer, IVoiceInteractor voiceInteractor,
 7             Window window) {
 8         attachBaseContext(context);
 9 
10         mFragments.attachHost(null /*parent*/);
11 
12         mWindow = new PhoneWindow(this, window);
13         mWindow.setWindowControllerCallback(this);
14         mWindow.setCallback(this);
15         mWindow.setOnWindowDismissedCallback(this);
16         mWindow.getLayoutInflater().setPrivateFactory(this);
17         if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
18             mWindow.setSoftInputMode(info.softInputMode);
19         }
20         if (info.uiOptions != 0) {
21             mWindow.setUiOptions(info.uiOptions);
22         }
23         mUiThread = Thread.currentThread();
24 
25         mMainThread = aThread;
26         mInstrumentation = instr;
27         mToken = token;
28         mIdent = ident;
29         mApplication = application;
30         mIntent = intent;
31         mReferrer = referrer;
32         mComponent = intent.getComponent();
33         mActivityInfo = info;
34         mTitle = title;
35         mParent = parent;
36         mEmbeddedID = id;
37         mLastNonConfigurationInstances = lastNonConfigurationInstances;
38         if (voiceInteractor != null) {
39             if (lastNonConfigurationInstances != null) {
40                 mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
41             } else {
42                 mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
43                         Looper.myLooper());
44             }
45         }
46 
47         mWindow.setWindowManager(
48                 (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
49                 mToken, mComponent.flattenToString(),
50                 (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
51         if (mParent != null) {
52             mWindow.setContainer(mParent.getWindow());
53         }
54         mWindowManager = mWindow.getWindowManager();
55         mCurrentConfig = config;
56     }
1 Intent intent = new Intent(MainActivity.this, OtherActivity.class);
2 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
3 getApplicationContext().startActivity(intent);

   程序运行之后,点击运营 Activity 的按钮将出口以下 Log:

  至此,难题1算是找到了答案。

二、Hook 掉 Context 的 startActivity
的方法

  源码地址:

  大家先来一步步解析 startActivity 的源码,随手写3个 startActivity
的以身作则,按住 command 键( windows 下按住 control )用鼠标点击
startActivity的章程即可跳转到方法里面。

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

  startActivityForResult(Intent intent, int requestCode, Bundle
options) 源码如下:

三、小结

  MainActivity 的代码如下: