Android复习总结 —— Activity启动流程

yuPFeG1819
1,909 阅读12分钟

平时经常用Activity.startActivity()来跳转页面，那么它是如何启动Activity的呢？

网上关于这方面的资料有很多，跟随前人的脚步，趁着复习整理的机会深入探究一番。

本文中涉及到的源码均基于Android 10 （Android Q）。

如果有误，欢迎在评论区指出。

概述

避免上来就源码糊脸，看得一脸懵逼的情况，这里还是先上一张大致流程图，梳理清楚再去看源码就轻松多了。

基于Android 10，按照个人理解画的渣图。不同版本在细节上会有所差异，但总体流程基本是不变的。

Activity启动流程图

  • 首先提及几个基础概念：
  • ActivityThread：

App进程的实际入口。在main()方法中，会开启主线程Handler的Looper消息循环，处理系统消息。

  • ApplicationThread ：

与系统进程进行Binder通讯的IApplicationThread代理类。主要用于system_server进程对App进程的Binder代理调用，管理生命周期。

  • Instrumentation：

每个App进程唯一的生命周期管理具体执行类。Activity、Application的生命周期管理都是由该类通过callXXX()系列方法来实现的。

  • ActivityTaskManagerService：

用于管理活动及其容器(任务、堆栈、显示……)的系统服务。接受App进程发送的请求启动Activity的Binder代理调用。

  • ActivityManagerService：

在系统进程中管理Activity与其他组件运行状态的系统服务。接受App进程发送绑定Application的Binder代理调用。

  • ActivityStarter：

在系统进程中管理如何启动Activity的控制器

  • ActivityStack：

Activity所在的回退栈。控制Activity的回退顺序，在栈顶就是当前获取到焦点的Activity。

  • ActivityStackSupervisor：

系统内唯一，所有回退栈ActivityStack的管理类。

  • ClientLifecycleManager：

向App进程通过Binder发送具体生命周期状态事务的管理类。

  • 大致流程：

  1. startActivity()通过Binder通信向system_service进程的ActivityManagerService通知需要启动Activity

  2. system_service进程会先将当前处于焦点状态的Activity迁移至onPause状态。（Binder方式）

  3. 根据Activity启动模式，启动目标Activity。（如果是进程已存在则跳过4、5）

  4. 如果新Activity所在的进程不存在于系统内，会通过Socket消息通知Zygote进程。

    以Zygote进程为原型fork拷贝出新的进程，并以反射的方式调用ActivityThread.main方法。

  5. ActivityThread.attach方法内通过Binder通知system_service进程的ActivityManagerService对新进程进行绑定与初始化。

    然后ActivityManagerService再通知新进程创建Application并执行onCreate方法。

  6. 进程创建并启动完成后，调用realStartActivityLocked创建并启动Activity，通过Binder通知目标Activity所在进程执行生命周期事务，并最终调用Activity.onCreate方法，完成启动事务。

源码解析

从这里开始就涉及源码的调用，限于篇幅有限， 只保留重要核心代码。

1. 通知系统进程需要跳转

启动Activity最终都是通过Activity.startActivityForResult()来启动的。

这里以Android10为例，向上追溯：

//===========1. android.app.Activity==================
public void startActivity(Intent intent, @Nullable Bundle options) {
    if (options != null) {
        startActivityForResult(intent, -1, options);
    } else {
        startActivityForResult(intent, -1);
    }
}

public void startActivityForResult(...){
    ...
    //调用activity内部持有Instrumentation实例，启动activity
    Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(...);
    ...
}

//=============2. android.app.Instrumentation==================
public ActivityResult execStartActivity(...){
	...
    int result = ActivityTaskManager.getService().startActivity(...);    
    ...
}

//===========3. android.app.ActivityTaskManager===================
public static IActivityTaskManager getService() {
    return IActivityTaskManagerSingleton.get();
}

private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
    new Singleton<IActivityTaskManager>() {
    @Override
    protected IActivityTaskManager create() {
        //获取对应的Service（ActivityTaskManager）的Binder代理类。
        final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
        return IActivityTaskManager.Stub.asInterface(b);
    }
};

IActivityTaskManager.Stub的Binder代理实现类为ActivityTaskManagerService。 execStartActivity方法通过Binder机制跨进程调用system_server进程ActivityTaskManagerService.startActivity()方法。

关于Binder通信

Android IPC机制：Binder与Aidl

//====================system_server进程========================

//4. com.android.server.wm.ActivityTaskManagerService
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    ActivityStartController getActivityStartController() {
        return mActivityStartController;
    }
    
    public final int startActivity(...){
        return startActivityAsUser(...)
    }
    
    ...
    public int startActivityAsUser(...){
        //实际调用的是ActivityStarter.execute()方法
        return getActivityStartController().obtainStarter(...)
            ...
            .execute()
    }
}

//5. com.android.server.wm.ActivityStartController
ActivityStarter obtainStarter(Intent intent, String reason) {
    return mFactory.obtain().setIntent(intent).setReason(reason);
}

实际最终通过ActivityStarter.execute来管理Activity的启动。

而ActivityStarter中，通过当前获取到焦点的ActivityStack回退栈，会先将回退栈内的原本处于栈顶的Activity进入onPause状态，然后才会启动目标Activity。

ActivityStack即为通常所说的回退栈。

TaskRecord则为任务栈。

关于任务栈与回退栈：(各版本间对于任务栈和返回栈的处理也有很大差异)

老生常谈的 Activity 任务，返回栈

Android 复习笔记 —— 任务栈和返回栈

//====================system_server进程========================

//6. com.android.server.wm.ActivityStarter
class ActivityStarter {
    private final ActivityTaskManagerService mService;
    private final RootActivityContainer mRootActivityContainer;
    private final ActivityStackSupervisor mSupervisor;
    int execute() {
        ...
        return startActivity(...)    
    }
 
    private int startActivity(...){
        ...
        //创建新Activity在任务栈中的信息
        ActivityRecord r = new ActivityRecord(...)
        ...
        startActivityUnchecked(...)
        ...
    }
    
    private int startActivityUnchecked(....){
        ...
        mRootActivityContainer.resumeFocusedStacksTopActivities();   
        ...    
    }
}

//7. com.android.server.wm.RootActivityContainer
class RootActivityContainer extends ConfigurationContainer ... {
    boolean resumeFocusedStacksTopActivities(...){
        //获取当前获取到焦点的回退栈
        final ActivityStack focusedStack = display.getFocusedStack();
        if (focusedStack != null) {
            focusedStack.resumeTopActivityUncheckedLocked(...);
        }
    }
}

//8. com.android.server.wm.ActivityStack
class ActivityStack extends ConfigurationContainer {
    final ActivityTaskManagerService mService;
    
    boolean resumeTopActivityUncheckedLocked(...) {
        resumeTopActivityInnerLocked(...);
    }
    
    private boolean resumeTopActivityInnerLocked(...) {
        if (mResumedActivity != null) {
           	//将当前获取到焦点的activity,迁移至onPause状态
            pausing |= startPausingLocked(...);
        }
        ...
        //开启一个新的Activity，并执行到onResume状态
    	mStackSupervisor.startSpecificActivityLocked(...);
       
    }
    
    final boolean startPausingLocked(...){
        //通知客户端的生命周期管理类ClientLifecycleManager，将当前取得焦点的activty置于OnPause状态
        //PauseActivityItem是ActivityLifecycleItem的子类，表示要迁移的生命周期状态
        mService.getLifecycleManager().scheduleTransaction(...,PauseActivityItem.obtain(...));
    }
}

//9. com.android.server.wm.ActivityTaskManagerService
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    private final ClientLifecycleManager mLifecycleManager;
    ClientLifecycleManager getLifecycleManager() {
        return mLifecycleManager;
    }
}

2. 当前焦点Activity的onPause

在ActivityStack中，最终会通过ActivityTaskManagerService使用ClientLifecycleManager进行Binder代理调用。

//====================system_server进程========================

//10. com.android.server.wm.ClientLifecycleManager
// 用于与App进程通讯，管理App进程Activity的生命周期
class ClientLifecycleManager {
    void scheduleTransaction(@NonNull IApplicationThread client,...) ... {
        final ClientTransaction clientTransaction = transactionWithState(...);
        scheduleTransaction(clientTransaction);
    }
    
    void scheduleTransaction(ClientTransaction transaction)...{
        //通过Binder通讯，通过代理类ApplicationThread切换至App进程内的方法
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();
    }
}

//11. android.app.servertransaction.ClientTransaction
public class ClientTransaction implements Parcelable, ObjectPoolItem {
    private IApplicationThread mClient;
    ...
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }
}

IApplicationThread的代理实现类ApplicationThread为切换回App进程调用ActivityThread.scheduleTransaction。

//=============================App进程==================================

//12. android.app.ActivityThread.ApplicationThread
// android.app.ActivityThread，是ClientTransactionHandler的唯一子类实现
public final class ActivityThread extends ClientTransactionHandler {
    //主线程的Handler
    final H mH = new H();
    //专用于处理主线程Handler内部EXECUTE_TRANSACTION消息的系统进程事务处理类
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
    
    //scheduleTransaction方法是在父类ClientTransactionHandler的方法，子类没有重写
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        //发送给主线程Handler消息
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }
    
    private void sendMessage(...) {
        ...
        Message msg = Message.obtain();
        ...
        mH.sendMessage(msg);
    }
    
    // ApplicationThread是ActivityThread的私有内部类，作为Binder通讯的IApplicationThread代理实现类，用于系统进程调用App进程方法
    private class ApplicationThread extends IApplicationThread.Stub { 
		@Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }
    }
    
    //主线程的handler类
    class H extends Handler {
        //处理来自系统服务的消息
        public void handleMessage(Message msg) {
            switch (msg.what) {
            	...
                case EXECUTE_TRANSACTION:
                        final ClientTransaction transaction = (ClientTransaction) msg.obj;
                        mTransactionExecutor.execute(transaction);
                       break;
            	...        
            }
        }
    }
   
}

实际上，Binder通讯调用是在App进程中的主线程Handler发送信息EXECUTE_TRANSACTION，交由android.app.servertransaction.TransactionExecutor来处理系统生命周期事务，执行之前发送的请求的表示onPause状态的android.app.servertransaction.PauseActivityItem类的execute()方法。

//13.android.app.servertransaction.TransactionExecutor
public class TransactionExecutor {
    public void execute(ClientTransaction transaction) {
        ...
        executeCallbacks(transaction);
        executeLifecycleState(transaction);
    }
    
    private void executeLifecycleState(ClientTransaction transaction) {
        //获取到当前生命周期事务请求
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
        ...
        // Execute the final transition with proper parameters.
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        ...
    }
}

//14. android.app.servertransaction.PauseActivityItem
public class PauseActivityItem extends ActivityLifecycleItem {
	@Override
    public void execute(ClientTransactionHandler client, IBinder token,...) {
        ...
        //调用App进程中的handlePauseActivity  
        client.handlePauseActivity(token, ...);
        ...
    }
}

进而调用作为ClientTransactionHandler实现类的ActivityThread的handlePauseActivity()方法

在每个App进程中，都只存在一个**ActivityThread作为应用进程的主入口**，其中持有一个Instrumentation的实例，用于跟踪管理进程内Activity和Application的生命周期。

//15. ===========android.app.ActivityThread==================

public final class ActivityThread extends ClientTransactionHandler {
    final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
    //用于具体管理进程内Application和Activity的生命周期
    Instrumentation mInstrumentation;
    
    @Override
    public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
            int configChanges, PendingTransactionActions pendingActions, String reason) {
        ActivityClientRecord r = mActivities.get(token);
        if (r != null) {
            ...
            performPauseActivity(r, finished, reason, pendingActions);
            ...
        }
    }

    private Bundle performPauseActivity(ActivityClientRecord r,...) {
        ...
        final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();
        if (shouldSaveState) {
            //调用Activity的onSaveInstanceState()
            callActivityOnSaveInstanceState(r);
        }
        performPauseActivityIfNeeded(r, reason);
        ...
    }

    private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
        //由Instrumentation将Activity生命周期迁移至onPause()状态
        mInstrumentation.callActivityOnPause(r.activity);
    }
}


//16. android.app.Instrumentation
public class Instrumentation {
    public void callActivityOnPause(Activity activity) {
        activity.performPause();
    }
}

//18. android.app.Activity
public class Activity extends ContextThemeWrapper ...{
    final void performPause() {
        ...
        //子类实现的onPause()生命周期
        onPause();
        ...
    }
}

最后由ActivityThread内部的Instrumentation类，通过callActivityOnPause()系列方法来迁移Activity的生命周期。

3. 新Activity启动

在当前获取到焦点的Activity进入onPause状态后，就到新Activity启动入栈的流程。

这也是在Activity.onPause()不要做耗时操作的原因，从onPause到新Activity启动的整个流程是串行的，执行完onPause才会启动新Activity。

前面提到的ActivityStack.resumeTopActivityInnerLocked()方法内，通过ActivityStackSupervisor.startSpecificActivityLocked(...)方法启动新Activity。

//17. com.android.server.wm.ActivityStackSupervisor
public class ActivityStackSupervisor implements RecentTasks.Callbacks {
    void startSpecificActivityLocked(ActivityRecord r,...) {
        //获取新activity所在的进程是否存在
        final WindowProcessController wpc = mService.getProcessController(r.processName, 		
        																r.info.applicationInfo.uid);
        if(wps != null){
            ...
            //1.新Activity处于已有的进程内，正常启动
            realStartActivityLocked(...);
            ...
            return
        }
        ...
        //2.如果新activity的进程不存在，则先通过ActivityManagerInternal.startProcess()方法创建新进程
        final Message msg = PooledLambda.obtainMessage(
            ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
            r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
        mService.mH.sendMessage(msg);    
    } 
}

进程已存在

如果Activity所在的进程已存在（同进程），则直接调用realStartActivityLocked()方法启动Activity。

// com.android.server.wm.ActivityStackSupervisor
public class ActivityStackSupervisor implements RecentTasks.Callbacks {
    boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,...) throws RemoteException {
        //创建启动Activity的事务
        final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.appToken);
        clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),...);
        ...                              
        //启动Activity后，顺序执行到onResume状态                              
        ActivityLifecycleItem lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());         
        ...
        clientTransaction.setLifecycleStateRequest(lifecycleItem);
        //执行事务
        mService.getLifecycleManager().scheduleTransaction(clientTransaction);                              
    }
}

这里出现了熟悉的getLifecycleManager().scheduleTransaction()方法。

按照前面将当前Activity切换到onPause状态时，执行Activity生命周期事务的方式，这里会通过Binder机制调用App进程内的TransactionExecutor.execute()方法，并最终执行传递过去的ActivityLifecycleItem子类实现的execute()方法。所以，这里只需要关注android.app.servertransaction.LaunchActivityItem类与android.app.servertransaction.ResumeActivityItem类的execute的实现即可。

// android.app.servertransaction.LaunchActivityItem
public class LaunchActivityItem extends ClientTransactionItem {
	
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        ActivityClientRecord r = new ActivityClientRecord(token, mIntent,...);
        //执行ActivityThread方法
        client.handleLaunchActivity(r, pendingActions, null);
    }
    
}

// android.app.servertransaction.ResumeActivityItem
public class ResumeActivityItem extends ActivityLifecycleItem {
    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        //执行ActivityThread方法
        client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,"RESUME_ACTIVITY");
    }
    
    @Override
    public int getTargetState() {
        //目标生命周期是onResume
        return ON_RESUME;
    }
}


// android.app.servertransaction.TransactionExecutor
public class TransactionExecutor {
    public void execute(ClientTransaction transaction) {
        ...
        //遍历执行事务中添加回调事务并执行
        executeCallbacks(transaction);
        //执行生命周期迁移请求
        executeLifecycleState(transaction);    
        ...
    }
    
    public void executeCallbacks(ClientTransaction transaction) {
        //会获取到Activity事务中的CallBack列表
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        ...
        for (int i = 0; i < callbacks.size(); ++i) {
            final ClientTransactionItem item = callbacks.get(i);
            ...
            //执行回调中的事务（这里就是创建Activity和onCreate()）    
            item.execute(mTransactionHandler, token, mPendingActions);
            item.postExecute(mTransactionHandler, token, mPendingActions);
            ...
        }   
    }
    
    private void executeLifecycleState(ClientTransaction transaction) {
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
        ...
        //补齐当前Activity生命周期到目标生命周期的缺失状态  
        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);    
	    //执行迁移到目标生命周期的事务
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
    }
    
    private void cycleToPath(ActivityClientRecord r, ..., ClientTransaction transaction) {
        ...
        //获取缺少的生命周期int数组（所有生命周期都有一个int值表示）
        final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);    
        performLifecycleSequence(r, path, transaction);    
    }
    
    private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
            ClientTransaction transaction) {
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
            state = path.get(i);
            switch (state) {
                ...
                //这里ResumeActivityItem的目标状态是onResume，所以缺少了一个onStart，
                //内部调用onStart()方法
                case ON_START:
                    mTransactionHandler.handleStartActivity(r, mPendingActions);
                    break;
                ...    
        }
    }
}

其内部分别调用ActivityThread.handleLaunchActivity和ActivityThread.handleResumeActivity()方法。

而且在执行ResumeActivityItem的事务时，会将调用cycleToPath()方法，将缺少的生命周期（onStart()）补齐。

关于onStart在补齐生命周期的调用为个人猜测，如果不对，恳请各位大佬告知。

//android.app.ActivityThread
public final class ActivityThread extends ClientTransactionHandler {
    
	public Activity handleLaunchActivity(ActivityClientRecord r,
        PendingTransactionActions pendingActions, Intent customIntent) {
        ...
        //创建Activity实例，并执行初始化和onCreate()方法
        final Activity a = performLaunchActivity(r, customIntent);
        ...
        return a;
    }
    
    @Override
    public void handleStartActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions) {
        final Activity activity = r.activity;
        activity.performStart("handleStartActivity");
        //设置Activity生命周期状态为onStart
        r.setState(ON_START);
    }
    
    public void handleResumeActivity(IBinder token, boolean finalStateRequest, ...) {
    	...
        final ActivityClientRecord r = performResumeActivity(...);
        ...
    }
    
    
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ...
        Activity activity = null;
        ...
        //由Instrumentation创建Activity的实例    
        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);    
        ...
        //初始化Activity内部对象    
        activity.attach(...); 
        ...
        //由Instrumentation来控制Activity生命周期    
        mInstrumentation.callActivityOnCreate(...);
        ...
        return activity;
    }
    
    
    public ActivityClientRecord performResumeActivity(IBinder token,...) {
        final ActivityClientRecord r = mActivities.get(token);
        ...
        //执行Activity的onResume()方法    
        r.activity.performResume(r.startsNotResumed, reason);
        return r;
    }
}

handleXXX()系列方法的最后都是交由Instrumentation来通过callActivityOnXXX()系列方法来实际迁移Activity的到指定生命周期。

// android.app.Instrumentation
public class Instrumentation {
    
    public Activity newActivity(ClassLoader cl, String className, Intent intent) ... {
        String pkg = intent != null && intent.getComponent() != null
                ? intent.getComponent().getPackageName() : null;
        //通过ClassLoader反射创建Activity的实例
        return getFactory(pkg).instantiateActivity(cl, className, intent);
    }
      
    public void callActivityOnCreate(Activity activity, Bundle icicle) {
        ...
        activity.performCreate(icicle);
        ...
    }
    
    public void callActivityOnStart(Activity activity) {
        activity.onStart();
    }
    
    public void callActivityOnResume(Activity activity) {
        ...
        activity.onResume();
        ...
    }
}

// android.app.Activity
public class Activity ...{
    private Instrumentation mInstrumentation;
    
    final void performCreate(Bundle icicle,...) {
        onCreate(icicle);
    }
    
    final void performStart(String reason) {
        mInstrumentation.callActivityOnStart(this);
    }
    
    final void performResume(boolean followedByPause, String reason) {
        performRestart(true /* start */, reason);
        ...
        
        mInstrumentation.callActivityOnResume(this);
        ...
    }
    
    //子类中的onCreate()方法，必须要调用super.onCreate()
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        ...
    }
    
    //子类中的onStart()方法，必须要调用super.onStart()
    protected void onStart() {
        ...
    }
    
    //子类中的onResume()方法，必须要调用super.onReusume()
    protected void onResume() {
        ...
    }
}

进程不存在

如果新Activity属于其他进程，且目标进程不存在，则会先通过ActivityManagerService的内部类，LocalService.startProcessLocked()来创建新进程。

// android.app.ActivityManagerInternal
public abstract class ActivityManagerInternal {
    
	public abstract void startProcess(String processName,...);
}

//com.android.server.am.ActivityManagerService.LocalService，是ActivityManagerInternal的唯一子类
//属于ActivityManagerService的内部类
public class ActivityManagerService extends IActivityManager.Stub{
    /**
     * 管理系统中所有的进程
     */
    final ProcessList mProcessList = new ProcessList();
    
    public final class LocalService extends ActivityManagerInternal {
        @Override
        public void startProcess(String processName,...) {
            ...
            synchronized (ActivityManagerService.this) {
                startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
                                   new HostingRecord(hostingType, hostingName),
                                   false /* allowWhileBooting */, false /* isolated */,
                                   true /* keepIfLarge */);
            }
            ...
        }

        final ProcessRecord startProcessLocked(String processName,...) {
            //通过ProcessList创建新进程
            return mProcessList.startProcessLocked(processName,...);
        }
	}
}

// com.android.server.am.ProcessList
public final class ProcessList {
    ActivityManagerService mService;
    
    boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,...) {
        ...
        // Start the process.  It will either succeed and return a result containing
        // the PID of the new process, or else throw a RuntimeException.
        //android.app.ActivityThread的类全名，是新进程的一个主入口
        final String entryPoint = "android.app.ActivityThread";	
        return startProcessLocked(hostingRecord,entryPoint,...);
    }
    
    boolean startProcessLocked(HostingRecord hostingRecord,String entryPoint,ProcessRecord app, ..) {
        ...
        final Process.ProcessStartResult startResult = startProcess(app.hostingRecord,entryPoint, ...);
        ...
    }
                                        
                                        
    private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,...){
        ...
        final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
		//通过socket连接方式，发送消息通知Zygote进程，fork出新进程
        startResult = appZygote.getProcess().start(entryPoint, app.processName,...)
         ...           
    }
}

最终是由system_service进程通过socket通讯，通知Zygote进程fork新的进程，并在Zygote进程内，通过ClassLoader反射调用android.app.ActivityThread类的main()方法。

本文主要针对应用层的部分进行研究，更加深入的部分可以参见Zygote进程fork流程中关于fork具体流程的解析

Zygote进程是如何fork一个APP进程

系统在创建Zygote进程后，在main()方法中，会启动SystemService进程，然后一直轮询等待接收子进程的socket通讯。

PS：Zygote进程是所有App、Laucher进程的父进程，其他进程均由Zygote进程fork拷贝而来。

  • SystemService进程与Zygote进程通讯使用socket原因：

    fork进程不允许在多线程环境内使用，而Binder通信是属于多线程的操作（Binder代理对象调用是处于Binder线程，需要通过Handler切换回主线程）。

    如果父进程Binder线程有锁，然后子进程的主线程一直在等其子线程(从父进程拷贝过来的子进程)的资源，但是其实父进程内的子线程并没有被拷贝过来，就会造成死锁。

//android.app.ActivityThread
public final class ActivityThread extends ClientTransactionHandler {
    public static void main(String[] args) {
        ...
    	ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);
        ...
	}
    
    private void attach(boolean system, long startSeq) {
        if (!system) {
            //属于新创建的APP进程
            ...
            //获取系统进程中ActivityManagerService的Binder代理类，调用系统进程的attachApplication()方法
            final IActivityManager mgr = ActivityManager.getService();
            mgr.attachApplication(mAppThread, startSeq);
            ...
        }else{
            //属于系统进程
            ...
        }
        
    }
}

IActivityManager的代理实现类就是ActivityManagerService，通过Binder切换到system_service进程

//======================调用system_service进程中的方法==============================
// com.android.server.am.ActivityManagerService
public class ActivityManagerService extends IActivityManager.Stub{
    public ActivityTaskManagerInternal mAtmInternal;
    
    @Override
    public final void attachApplication(IApplicationThread thread, long startSeq) {
        synchronized (this) {
            attachApplicationLocked(thread, callingPid, callingUid, startSeq);
            ...
        }
    }
    
    private final boolean attachApplicationLocked(IApplicationThread thread,int pid,...) {
        ...
        //1.通过Binder通讯，调用App进程中的方法，绑定APP进程的Application
        thread.bindApplication(processName, appInfo, providers,...);
        
        ...
        //2.正常启动Activity的情况，创建初始Activity
        didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
    }  
}

这里会先后执行启动Application和启动初始Activity两步。

  1. 启动Application

利用Binder机制，调用IApplicationThread的代理实现类ActivityThread.ApplicationThread的方法，最终依次调用Application.attach()和Application.onCreate()方法

//=============== App进程=======================
// android.app.ActivityThread.ApplicationThread
private class ApplicationThread extends IApplicationThread.Stub {
    public final void bindApplication(String processName, ApplicationInfo appInfo,...){
        ...
        AppBindData data = new AppBindData();
        ...
        //发送给主线程Handler，BIND_APPLICATION消息   
        sendMessage(H.BIND_APPLICATION, data);    
    }
}

// android.app.ActivityThread.H
class H extends Handler {
    public void handleMessage(Message msg) {
        ...
        switch (msg.what) {
            case BIND_APPLICATION:
                ...
                AppBindData data = (AppBindData)msg.obj;
                handleBindApplication(data);
                ...
                break;
                ...
        }
    }
}

//android.app.ActivityThread
public final class ActivityThread extends ClientTransactionHandler {
    
    private void handleBindApplication(AppBindData data) {
        ...
        mInstrumentation = new Instrumentation();
        ...
        Application app;
        ...
        //创建AndroidManifest.xml内配置的Application
        app = data.info.makeApplication(data.restrictedBackupMode, null);
        ...
        //初始化AndroidManifest.xml内配置的ContentProvider
        installContentProviders(app, data.providers);
        ...
        //执行Application的onCreate()方法   
        mInstrumentation.callApplicationOnCreate(app);    
    }
}

// android.app.LoadedApk
public final class LoadedApk {
    public Application makeApplication(boolean forceDefaultAppClass,Instrumentation instrumentation) {
        ...
        Application app = mActivityThread.mInstrumentation.newApplication(...);
        ...
        return app    
    }
}


// android.app.Instrumentation
public class Instrumentation {
    //初始化Application
    static public Application newApplication(Class<?> clazz, Context context)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Application app = (Application)clazz.newInstance();
        app.attach(context);
        return app;
    }
    
    
    public void callApplicationOnCreate(Application app) {
        app.onCreate();
    }
}
  1. 启动初始Activity

执行完Application的初始化，就会调用ActivityTaskManagerInternal.attachApplication()去启动Application内的初始Activity

// com.android.server.wm.ActivityTaskManagerService.LocalService 是 ActivityTaskManagerInternal的唯一子类实现。
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    RootActivityContainer mRootActivityContainer;
    final class LocalService extends ActivityTaskManagerInternal {
        public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
            synchronized (...) {
                return mRootActivityContainer.attachApplication(wpc);
            }
        }
    }
}

// com.android.server.wm.RootActivityContainer
class RootActivityContainer extends ConfigurationContainer ...{
    boolean attachApplication(WindowProcessController app) throws RemoteException {
        
        ...
        //熟悉的调用，其实这里就与同进程内启动新Activity相同了
        mStackSupervisor.realStartActivityLocked(activity, app,...)
        ...
    }
}

这里又出现了熟悉的mStackSupervisor.realStartActivityLocked()方法，后续就与同进程下启动Activity相同了。

后记

网上介绍启动流程有很多，但最好的方式还是跟随文章自己去看遍源码，才能更好的梳理清楚整个流程与细节。

PS：

这篇文章其实之前就写好了的，然后在研究View绘制的时候，尝试更新到了Android 11 (Android R)就被一波背刺，粗略看了下（是看不懂的源码.jpg），感觉变化还挺多的。

后续有时间再来详细理解一遍新的变化，同时尝试更新下关于与Android 11的细节差异。

参考资料：

init进程zygote进程SystemServer进程启动流程

Android10.0应用进程创建过程以及Zygote的fork流程

Android 10 startActivity 源码分析

系统启动之Zygote进程

avatar
文章
阅读
粉丝