Activity插件化原理第二種方案：Hook IActivityManager

溫馨提示：閱讀本文需要20-30分鐘（一大波代碼）關注公衆号：顧林海

今天，我們來解決一個問題：

人生一切難題，知識給你答案。

第一種方案Hook Instrumentation已經順利完成，接下來我們看第二個方案，還是看這段代碼：

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
            @Nullable Bundle options) {
        if (mParent == null) {
            //Activity啟動
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode, options);
            if (ar != null) {
                mMainThread.sendActivityResult(
                    mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                    ar.getResultData());
            }
            if (requestCode >= ) {
                mStartedActivity = true;
            }

            cancelInputsAndStartExitTransition(options);
            windows.
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

複制代碼

通過mInstrumentation的execStartActivity方法啟動Activity，在execStartActivity方法中會擷取AMS的代理，Android 7.0通過ActivityManagerNative的getDefault方法擷取一個ActivityManagerProxy，這個ActivityManagerProxy内部封裝了IBinder類型的ActivityManagerService的代理類，這樣在應用程式程序中就可以通過這個ActivityManagerProxy與SystemServer程序的ActivityManagerService進行通信，而在Android 8.0去除了ActivityManagerProxy這個代理類，由IActivityManager代替，這裡的IActivityManager.aidl通過AIDL工具自動生成IActivityManager.java。

Android 7.0-Activity啟動

ActivityManager是一個和AMS相關聯的類，它主要對運作中的Activity進行管理，ActivityManager中相關管理方法最終會通過ActivityManagerNative的getDefault方法來得到ActivityManagerProxy，再調用ActivityManagerProxy的相關管理方法，ActivityManagerProxy就是AMS的代理類，通過這個代理類就可以和AMS進行通信。

Android7.0的Activity啟動過程會調用Instrumentation的execStartActivity方法，代碼如下：

public ActivityResult execStartActivity(
        ...
        try {
            ...
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target, requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }
複制代碼

在execStartActivity方法中會調用ActivityManagerNative的getDefault方法來擷取ActivityManagerProxy，ActivityManagerProxy又是AMS的代理類，這樣的話就可以通過ActivityManagerProxy向AMS發送startActivity的請求。

ActivityManagerNative的getDefault方法的代碼如下：

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
        protected IActivityManager create() {
            IBinder b = ServiceManager.getService("activity");
            ...
            IActivityManager am = asInterface(b);
            ...
            return am;
        }
    };

    static public IActivityManager getDefault() {
        return gDefault.get();
    }
複制代碼

在getDefault方法中調用了gDefault的get方法，gDefault是一個單例類。通過ServiceManager的getService方法擷取一個IBinder類型的AMS的引用，再将它通過asInterface方法轉換成ActivityManagerProxy類型的對象。

asInterface方法：

static public IActivityManager asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }
        //檢查本地程序是否有IActivityManager接口的實作
        IActivityManager in =
            (IActivityManager)obj.queryLocalInterface(descriptor);
        if (in != null) {
            return in;
        }
        //本地程序沒有IActivityManager接口的實作，将IBinder類型的AMS引用封裝成AMP
        return new ActivityManagerProxy(obj);
    }
複制代碼

在asInterface方法中分兩種情況，首先會檢查本地程序是否有IActivityManager接口的實作，如果有就直接傳回；如果沒有，就将IBinder類型的AMS引用封裝成ActivityManagerProxy。

public abstract class ActivityManagerNative extends Binder implements IActivityManager{
    ...
    class ActivityManagerProxy implements IActivityManager{
        public ActivityManagerProxy(IBinder remote){
            mRemote = remote;
        }
                ...
    }
    ...
}
複制代碼

ActivityManagerProxy是ActivityManagerNative的内部類，在ActivityManagerProxy的構造方法中将AMS的引用指派給變量mRemote，這樣在ActivityManagerProxy中就可以使用AMS了。

繼續回到Instrumentation的execStartActivity方法，代碼如下：

public ActivityResult execStartActivity(
        ...
        try {
            ...
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target, requestCode, 0, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }
複制代碼

通過ActivityManagerNative的getDefault方法擷取AMS的代理類ActivityManagerProxy，再調用ActivityManagerProxy的startActivity方法。

ActivityManagerProxy的startActivity方法：

public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
            String resolvedType, IBinder resultTo, String resultWho, int requestCode,
            int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
        ...
        //向AMS發送START_ACTIVITY_TRANSACTION類型的程序間通信請求
        mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, );
        reply.readException();
        int result = reply.readInt();
        reply.recycle();
        data.recycle();
        return result;
    }
複制代碼

在ActivityManagerProxy的startActivity方法中，通過mRemote，也就是AMS的引用，向服務端的AMS發送一個START_ACTIVITY_TRANSACTION類型的程序間通信請求，服務端AMS就會從Binder線程池中讀取用戶端發來的資料，最終會調用ActivityManagerNative的onTransact方法。

@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
    switch (code) {
        case START_ACTIVITY_TRANSACTION:{
            ...
            int result = startActivity(app, callingPackage, intent, resolvedType,
            ...
            return true;
        }
        ...
    }

    return super.onTransact(code, data, reply, flags);
}
複制代碼

同時ActivityManagerService繼承自ActivityManagerNative，是以onTransact方法的switch語句的START_ACTIVITY_TRANSACTION分支會調用AMS的startActivity。

public final class ActivityManagerService extends ActivityManagerNative implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {

    @Override    public final int startActivity(IApplicationThread caller, String callingPackage,
            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
           int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
            return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
                resultWho, requestCode, startFlags, profilerInfo, bOptions,
                UserHandle.getCallingUserId());
      }
}
複制代碼

Android 8.0-Activity啟動

Android8.0和7.0的Activity啟動過程都會調用Instrumentation的execStartActivity方法，代碼如下：

public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, String target,
        Intent intent, int requestCode, Bundle options) {
        ...
        try {
            ...
            int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target, requestCode, , null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
            throw new RuntimeException("Failure from system", e);
        }
        return null;
    }
複制代碼

在execStartActivity方法中通過ActivityManager的getService擷取IActivityManager對象，并通過IActivityManager對象的startActivity方法通知AMS啟動Activity。

public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }

    private static final Singleton<IActivityManager> IActivityManagerSingleton =
            new Singleton<IActivityManager>() {
                @Override
                protected IActivityManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
            };
複制代碼

IActivityManagerSingleto是一個單例類，在它的create方法中擷取iBinder類型的AMS引用，接着通過AIDL，将AMS應用轉換成IActivityManager類型的對象。相比于Android 7.0來說，這裡去掉了ActivityManagerProxy這個代理類，由IActivityManager代替，這裡的IActivityManager.aidl通過AIDL工具自動生成IActivityManager.java。

通過Android 7.0和Android 8.0的Activity啟動流程可以得出Activity插件化的另一種方案：Hook IActivityManager，通過動态代理實作。

首先建立占坑Activity：

public class StubActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_stub);
    }
}
複制代碼

建立插件Activity：

public class TargetActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_target);
    }
}
複制代碼

并在AndroidManifest.xml中注冊占坑Activity：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.glh.haiproject01">

    <application
        android:name=".MyApplication"
        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"
        tools:ignore="AllowBackup,GoogleAppIndexingWarning">
        <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=".StubActivity" />
    </application>

</manifest>
複制代碼

在AndroidManifest.xml中沒有注冊插件Activity，這時如果啟動插件Activity會報錯。

接着開始Hook IActivityManager，建立代理類IActivityManagerProxy：

public class IActivityManagerProxy implements InvocationHandler {

    private Object mActivityManager;

    public IActivityManagerProxy(Object activityManager){
        this.mActivityManager=activityManager;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("startActivity".equals(method.getName())){
            //攔截startActivity
            Intent intent=null;
            int index=;
            for(int i=,length=args.length;i<length;i++){
                if(args[i] instanceof Intent){
                    index=i;
                    break;
                }
            }
            //擷取插件Activity的Intent
            intent= (Intent) args[index];
            //建立占坑Activity的Intent
            Intent subIntent=new Intent();
            subIntent.setClassName("com.glh.haiproject01","com.glh.haiproject01.StubActivity");
            //儲存插件Activity的Intent
            subIntent.putExtra(HookHelper.REQUEST_TARGET_INTENT_NAME,intent);
            //替換為占坑Activity
            args[index]=subIntent;
        }
        return method.invoke(mActivityManager,args);
    }
}

複制代碼

IActivityManagerProxy代理類的invoke非常簡單，就是将插件Activity的Intent替換為占坑Activity的Intent，并儲存插件Activity的Intent，友善後續還原。

private void hookIActivityManager(){
        Object defaultSingleton;
        if(Build.VERSION.SDK_INT==){
            //Android 8.0
            defaultSingleton=getIActivityManagerSingleton();
        }else{
            defaultSingleton=getDefault();
        }
        try {
            Class<?> singletonClazz=Class.forName("android.util.Singleton");
            Field instanceField=singletonClazz.getDeclaredField("mInstance");
            instanceField.setAccessible(true);
            //擷取defaultSingleton中IActivityManager類型的mInstance成員變量
            Object iActivityManager=instanceField.get(defaultSingleton);

            Class<?> iActivityManagerClazz=Class.forName("android.app.IActivityManager");
            Object proxy=Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                    new Class<?>[]{iActivityManagerClazz},new IActivityManagerProxy(iActivityManager));
            //替換為代理類IActivityManagerProxy
            instanceField.set(defaultSingleton,proxy);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    private Object getIActivityManagerSingleton(){
        try {
            Class<?> activityManagerClazz=Class.forName("android.app.ActivityManager");
            Field field=activityManagerClazz.getDeclaredField("IActivityManagerSingleton");
            field.setAccessible(true);
            return field.get(null);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    private Object getDefault(){
        try {
            Class<?> activityManagerClazz=Class.forName("android.app.ActivityManagerNative");
            Field field=activityManagerClazz.getDeclaredField("gDefault");
            field.setAccessible(true);
            return field.get(null);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
複制代碼

以上代碼主要就是将Singleton的IActivityManager類型的成員變量mInstance替換成通過動态代理對象。當我們向AMS請求啟動Activity時，會執行代理類IActivityManagerProxy的invoke方法進行狸貓換太子。

當AMS通過驗證後需要還原插件Activity的Intent，在Android 8.0和Android 7.0(其他版本源碼有可能不同)中，AMS通過Binder跨程序調用scheduleLaunchActivity，scheduleLaunchActivity方法在應用程式程序的Binder線程池中，通過mH發送LAUNCH_ACTIVITY消息（100）切換到主線程中建立并啟動Activity。

mH的類型是ActivityThread中的内部類H，H繼承自Handler并實作了handleMessage方法，在Handler源碼中，有這麼一段代碼：

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
複制代碼

當mCallback不為null時會調用handleMessage方法，mCallback類型是Callback接口，是以我們可以Hook Callback，用自定的Callback替換Handler的mCallback。

代理Callback：

public class CallBackProxy implements Handler.Callback {

    private Handler mHandler;

    public CallBackProxy(Handler handler){
        this.mHandler=handler;
    }

    @Override
    public boolean handleMessage(Message msg) {
        if(msg.what==){
            Object o=msg.obj;
            try {
                Field field=o.getClass().getDeclaredField("intent");
                field.setAccessible(true);
                //擷取占坑Activity的Intent
                Intent intent= (Intent) field.get(o);
                //擷取之前儲存的插件Activity的Intent
                Intent targetIntent=intent.getParcelableExtra(HookHelper.REQUEST_TARGET_INTENT_NAME);
                //将占坑的Activity替換為插件Activity
                intent.setComponent(targetIntent.getComponent());
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }
        mHandler.handleMessage(msg);
        return true;
    }
}
複制代碼

将Handler的mCallback替換為代理類CallBackProxy：

private  void hookHandler(){
        try {
            Class<?> activityThreadClazz=Class.forName("android.app.ActivityThread");
            Field currentActivityThreadField=activityThreadClazz.getDeclaredField("sCurrentActivityThread");
            currentActivityThreadField.setAccessible(true);
            Object currentActivityThread=currentActivityThreadField.get(null);

            Field handlerField=activityThreadClazz.getDeclaredField("mH");
            handlerField.setAccessible(true);
            Handler mH= (Handler) handlerField.get(currentActivityThread);

            Field callbackField=Handler.class.getDeclaredField("mCallback");
            callbackField.setAccessible(true);
            //Handler的mCallback替換為CallBackProxy
            callbackField.set(mH,new CallBackProxy(mH));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

複制代碼

至此，Hook IActivityManager方案已經完成，在主界面中啟動插件Activity：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.btn_startActivity).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(MainActivity.this,TargetActivity.class);
                startActivity(intent);
            }
        });
    }
}
複制代碼

運作效果：

Activity插件化原理第二種方案：Hook IActivityManager

Android 7.0-Activity啟動

Android 8.0-Activity啟動

繼續閱讀

傳說FreeBSD等比Linux更穩定，更“健壯”

無人機--飛控科普

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

android 主線程的相關問題

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method