Android应用程序（activity）启动过程（一）

最新推荐文章于 2023-07-23 09:00:00 发布

郭家远

最新推荐文章于 2023-07-23 09:00:00 发布

阅读量606

点赞数 2

分类专栏： Android 原理探索

本文链接：https://blog.csdn.net/guojiayuan002/article/details/82971589

版权

本文详细剖析了Android应用程序启动过程，特别是API 26环境下，从startActivity()开始，涉及Instrumentation、ActivityManager.getService().startActivity()、进程间通信(IActivityManager.aidl)、ActivityStackSupervisor和Activity生命周期回调方法(onPause、onStop、onDestroy)的执行顺序。通过源码分析，揭示了Activity启动时栈顶Activity如何执行onPause，以及后续的onStop和onDestroy过程。

摘要由CSDN通过智能技术生成

参考文章 Android应用程序启动过程源代码分析
本文基于 API 26 AS 3.0
主要讲栈顶activity的 onPause，onStop，onDestory

startActivity() ——> startActivityForResult()
在 startActivityForResult()方法中调用 Instrumentation类中的 public ActivityResult execStartActivity()方法，这个方法加上了{@hide}对外是不可见的，前两步比较简单，很容易看懂

execStartActivity方法传递的几个参数： this，为启动Activity的对象；
contextThread，为Binder对象，是主进程的context对象；
token，也是一个Binder对象，指向了服务端一个ActivityRecord对象；
target，为启动的Activity； intent，启动的Intent对象；
requestCode，请求码； options，参数；

在 execStartActivity() 中调用了ActivityManager.getService().startActivity()

int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);

    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);
                    // asInterface() 这里返回的其实就是Stub抽象类中的Proxy代理类
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
            };

public abstract class Singleton<T> {
    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

在一个单例中通过IPC 获得远端服务的IActivityManager接口，实际实现就是一个运行在客户端的Proxy代理类。（个人理解：IActivityManager.aidl文件，编译成java文件后内部生成一个Proxy代理类并且实现 IActivityManager ）
地址：platform_frameworks_base/blob/master/core/java/android/app/IActivityManager.aidl
通过Proxy代理类重写其中的startActivity()方法：
其中的in、out、inout 代表只能写入、读出、既能读又能写

    int startActivity(in IApplicationThread caller, in String callingPackage, in Intent intent,
            in String resolvedType, in IBinder resultTo, in String resultWho, int requestCode,
            int flags, in ProfilerInfo profilerInfo, in Bundle options);

最后通过mRemote.transact 将客户端消息发送给远端服务 第一次进程间通信

远端服务层

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {

从Proxy类的mRemote.transact()传递过来的参数，被传递到ActivityManagerService类的onTransact()方法来处理

 @Override
    public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
        if (code == SYSPROPS_TRANSACTION) {
            // We need to tell all apps about the system property change.
            ArrayList<IBinder> procs = new ArrayList<IBinder>();
            synchronized(this) {
                final int NP = mProcessNames.getMap().size();
                for (int ip=0; ip<NP; ip++) {
                    SparseArray<ProcessRecord> apps = mProcessNames.getMap().valueAt(ip);
                    final int NA = apps.size();
                    for (int ia=0; ia<NA; ia++) {
                        ProcessRecord app = apps.valueAt(ia);
                        if (app.thread != null) {
                            procs.add(app.thread.asBinder());
                        }
                    }
                }
            }

            int N = procs.size();
            for (int i=0; i<N; i++) {
                Parcel data2 = Parcel.obtain();
                try {
                    procs.get(i).transact(IBinder.SYSPROPS_TRANSACTION, data2, null,
                            Binder.FLAG_ONEWAY);
                } catch (RemoteException e) {
                }
                data2.recycle();
            }
        }
        try {
            return super.onTransact(code, data, reply, flags);
        } catch (RuntimeException e) {
            // The activity manager only throws security exceptions, so let's
            // log all others.
            if (!(e instanceof SecurityException)) {
                Slog.wtf(TAG, "Activity Manager Crash."
                        + " UID:" + Binder.getCallingUid()
                        + " PID:" + Binder.getCallingPid()
                        + " TRANS:" + code, e);
            }
            throw e;
        }
    }

最后还是要通过 return super.onTransact(code, data, reply, flags); Stub抽象类的onTransact方法来处理，猜测：在父类中调用startActivity(),然后在子类中Override，因为我找不到Proxy这个代理类的地址，所以贴不了代码

然后我在 ActivityManagerService 中找到重写的startActivity方法

@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,