1.引言
以前一直很好奇，啟動一個新的Activity，為什麼非要在清單檔案裡註冊，到底是哪裡地方進行了校驗，整個啟動的流程是什麼樣子的。如果想實現外掛化機制，啟動一個外掛中新的Activity的話有什麼其它方法去做到。這篇文章本來是想寫在Activity的啟動流程分析之後的，但是裡面確實涉及的類，邏輯很多，寫起來可能會有些漏缺，而且比較無聊，所以先寫一下android的hook技術，先大概講一下Activity的啟動流程，裡面會涉及到一些程式互動，如果對android中的Binder機制不熟悉的朋友可以看我上篇文章3分鐘帶你看懂android的Binder機制
2.Activity大致啟動流程
啟動一個Activity大致會經歷一下幾個方法：
- Activity.startActivity()
- Activity.startActivityForResult()
- Instrumentation.execStartActivity()
- ActivityManagerService.startActivity()
- ApplicationThread.scheduleLaunchActivity()
- ActivityThread.Handler.handleMessage()
具體方法本文就不詳細說了，免得篇幅太長，引用一張圖來表述整個的互動過程：
從上圖我們可以看出整個通訊過程是涉及到2次Binder通訊過程的，APP程式和system_server程式分別作為了一次client和server端。APP程式也就是我們自己的應用程式，system_server程式是系統程式，javaframework框架的核心載體，裡面執行了大量的系統服務，比如這裡提供ApplicationThreadProxy），ActivityManagerService，結合圖，啟動流程大致如下：
- APP程式入口是ActivityThread，初始化時便會建立一個Binder執行緒（具體是指ApplicationThread，Binder的服務端，用於接收系統服務AMS傳送來的事件），ApplicationThread主要有兩個作用：1.作為Binder服務端接受system_server中的client端ApplicationThreadProxy傳送過來的訊息，對應上面的方法是ActivityManagerService------>ApplicationThread，2.作為訊息的中轉站，將msg通過handler傳遞到ActivityThread中，也就是傳遞到上述的最後一個方法中。
- system_server程式中的ActivityManagerService作為Binder的服務端，接受ActivityManagerProxy作為client端傳送過來的訊息，也就是Instrumentation.execStartActivity()---->ActivityManagerService.startActivity()。
這裡主要看下Instrumentation.execStartActivity這個方法，比較關鍵，跳過去可能有的朋友比較模糊，主要程式碼如下：
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
....
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
複製程式碼這裡的contextThread也就是上面講的ApplicationThread物件，主要看下面ActivityManager.getService()，返回的是一個IActivityManager介面型別物件，繼續看：
static public IActivityManager getDefault() {
return gDefault.get();
}
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
IBinder b = ServiceManager.getService("activity");
if (false) {
Log.v("ActivityManager", "default service binder = " + b);
}
IActivityManager am = asInterface(b);//注意這一行
if (false) {
Log.v("ActivityManager", "default service = " + am);
}
return am;
}
};
static public IActivityManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IActivityManager in =
(IActivityManager)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}
return new ActivityManagerProxy(obj);
}
複製程式碼這裡我用的API25,API26及以上，實現的程式碼不太一樣，廢棄了ActivityManagerProxy，改用了AIDL來實現通訊，為了讓大傢伙更理解Binder，這裡就用之前的API了，邏輯應該很清晰通過ServiceManager拿到IBinder物件，再在本地進行查詢，如果不在同一個程式，就返回ActivityManagerProxy代理物件，所以很清晰，Instrumentation.execStartActivity()實際上最後就呼叫到了ActivityManagerProxy中。
3.Hook實現
3.1 hook實現思路
咳咳！！我們回到正題，上面只是鋪墊，我們的主題是hook，怎麼啟動一個沒註冊的Activity呢，先將下思路，既然最終檢查是在AMS中，那我們可以在之前做一些騷操作，來個狸貓換太子，具體思路如下：
-
直接startActivity（）開啟一個未註冊的TargetActivity
-
既然在AMS之前，訊息是從ActivityManagerProxy中發出去的，我們可以動態代理生成一個類（不熟悉動態代理的朋友只能自行google了~），代理ActivityManagerProxy物件，攔截其中的startActivity()方法，拿到其中的intent引數物件。我們把真正的intent替換成我們一個已經註冊過的ProxyActivity，先把AMS的check這一關給過了，再把真正的intent當做物件存在ProxyActivity的intent中。
-
既然intent替換了，AMS是過了，那肯定得給它搞回來，要不然不就直接開啟了ProxyActivity？我們知道最好訊息時回到了ActivityThread.Handler.handleMessage()中的，嘿嘿，熟悉Handler機制的朋友應該知道，在這之前是會先走dispatchMessage方法的，不熟悉的可以看下我之前的文章Android原始碼學習之handler,
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
複製程式碼是分別會先後執行handleCallback(msg)--->mCallback.handleMessage(msg)--->handleMessage(msg)，而Activity中正好是最好一個，那我們可以hook一下這個mCallback，讓我們在最後訊息執行時，把我們的intent給替換回去
3.2 上程式碼！！
public class HookActivityUtils {
private static final String TAG = "HookActivityUtils";
private volatile static HookActivityUtils sHookActivityUtils;
public static HookActivityUtils getInstance(){
if (sHookActivityUtils==null){
synchronized (HookActivityUtils.class){
if (sHookActivityUtils==null){
sHookActivityUtils = new HookActivityUtils();
}
}
}
return sHookActivityUtils;
}
private HookActivityUtils(){
}
public void hooks(Context mContext){
Object object;
try {
//尋找hook點，最好是靜態或者單例，不容易發生改變,因為是靜態，所以傳入null即可
//因為版本差異，所以要分開處理
if (Build.VERSION.SDK_INT>=26){
Field iActivityManagerSingleton = ActivityManager.class.getDeclaredField("IActivityManagerSingleton");
iActivityManagerSingleton.setAccessible(true);
object = iActivityManagerSingleton.get(null);
}else{
Field gDefault = Class.forName("android.app.ActivityManagerNative").getDeclaredField("gDefault");
gDefault.setAccessible(true);
object = gDefault.get(null);
}
//獲取單例物件,實現IActivityManager介面的實現類
Field mFieldInstance = Class.forName("android.util.Singleton").getDeclaredField("mInstance");
mFieldInstance.setAccessible(true);
Object mInstance = mFieldInstance.get(object);
//尋找到hook點後，新建一個代理物件
ActivityManagerDelegate managerDelegate = new ActivityManagerDelegate(mInstance,mContext);
Class<?> aClass = Class.forName("android.app.IActivityManager");
Object proxy = Proxy.newProxyInstance(aClass.getClassLoader(), new Class<?>[]{aClass}, managerDelegate);
//替換動態代理物件
mFieldInstance.set(object,proxy);
} catch (Exception mE) {
mE.printStackTrace();
}
}
public void hookHanlder(){
try {
Class<?> aClass = Class.forName("android.app.ActivityThread");
Method currentActivityThread = aClass.getDeclaredMethod("currentActivityThread");
currentActivityThread.setAccessible(true);
//ActivityThread 本身物件
Object invoke = currentActivityThread.invoke(null);
Field mH = aClass.getDeclaredField("mH");
mH.setAccessible(true);
//獲取handler物件
Object handler = mH.get(invoke);
//獲取handler中的mCallback
Field mCallback = Handler.class.getDeclaredField("mCallback");
mCallback.setAccessible(true);
mCallback.set(handler,new HookCallBack((Handler) handler));
} catch (Exception mE) {
mE.printStackTrace();
}
}
}
複製程式碼主要也就是對應的兩個方法，一個通過反射拿到實現IActivityManager介面的物件，並生成一個代理此物件的代理物件，另外一個是反射拿到ActivityThread中的mH Handler物件，然後傳入一個實現Handler.callback介面的物件，這樣Handler中的mcallback就不為空了，也就達到了我們的目的
然後是我們的代理物件：
public class ActivityManagerDelegate implements InvocationHandler {
private static final String TAG = "ActivityManagerDelegate";
private Object mObject;
private Context mContext;
public ActivityManagerDelegate(Object mObject,Context mContext) {
this.mObject = mObject;
this.mContext = mContext;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().equals("startActivity")){
//攔截方法
Log.e(TAG,"i got you");
Intent intent =null;
for (int i = 0; i < args.length; i++) {
if (args[i] instanceof Intent){
intent = (Intent) args[i];
//找到了intent引數
Intent mIntent = new Intent();
ComponentName componentName = new ComponentName(mContext,ProxyActivity.class);
//將真正的intent帶上，後續替換
mIntent.setComponent(componentName);
mIntent.putExtra("realObj",intent);
//修改為已註冊Activity的intent，先讓AMS檢查通過
args[i] = mIntent;
}
}
}
return method.invoke(mObject,args);
}
}
複製程式碼我們攔截startActivity，然後將ProxyActivity的ComponentName傳遞進去，狸貓換太子，同時將真正的intent帶過去，接下來就是處理訊息了：
public class HookCallBack implements Handler.Callback {
private static final String TAG = "HookCallBack";
private Handler mHandler;
public HookCallBack(Handler mHandler) {
this.mHandler = mHandler;
}
@Override
public boolean handleMessage(Message msg) {
if (msg.what==100){
handleHookMsg(msg);
}
mHandler.handleMessage(msg);
return false;
}
private void handleHookMsg(Message mMsg) {
Object obj = mMsg.obj;
try {
Field intent = obj.getClass().getDeclaredField("intent");
//這時候拿出之前存進來真正的intent
intent.setAccessible(true);
Intent proxyIntent = (Intent) intent.get(obj);
Intent realIntent = proxyIntent.getParcelableExtra("realObj");
proxyIntent.setComponent(realIntent.getComponent());
} catch (Exception mE) {
mE.printStackTrace();
}
}
}
複製程式碼什麼？為什麼要攔截msg.what等於100的訊息？
private class H extends Handler {
....
public static final int LAUNCH_ACTIVITY = 100;
public static final int PAUSE_ACTIVITY = 101;
....
}
複製程式碼這下明白了吧，攔截到這個訊息後，把事先存進去的intent的Component再set回去就完美了~~
主頁面MainActivity：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
HookActivityUtils.getInstance().hooks(this);
HookActivityUtils.getInstance().hookHanlder();
findViewById(R.id.textView).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent(MainActivity.this,TargetActivity.class);
startActivity(intent);
}
});
}
}
複製程式碼這裡我們開啟的是TargetActivity，但是清單檔案中並沒有宣告：
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".ProxyActivity"></activity>
</application>
複製程式碼這樣的話，就實現開啟一個未註冊的Activity了，是不是也是挺easy的，在實現外掛化機制的時候，要開啟外掛中的activity的話，因為沒有在原宿主中的清單檔案註冊，是無法直接調轉的，這時候我們這個代理activity就可以起很大的作用了。
有興趣的朋友可以跟著一起實現一下，感謝觀看，溜了溜了~~