Android Activity启动流程一：从Intent到Activity创建

阳光穿透心脏的1/2处 2023-10-14 15:11 59阅读 0赞

> 关于作者：CSDN内容合伙人、技术专家， 从零开始做日活千万级APP。  
> 专注于分享各领域原创系列文章 ，擅长java后端、移动开发、人工智能等，希望大家多多支持。

#### 目录 ####

*  一、概览
 *  二、应用内启动源码流程 (startActivity)
 *   *  2.1 startActivity()
     *  2.2 startActivityAsUser()
     *  2.3 startActivityUnchecked()
     *  2.4 resumeFocusedStackTopActivityLocked()
     *  2.5 startSpecificActivityLocked -> realStartActivityLocked()
 *  三、 Activity实例化过程
 *  四、 setContentView
 *  五、 后续生命周期
 *  六、 推荐阅读

![在这里插入图片描述][f5ba2a630958460ab6a581523327cf4d.png]

学习前，建议有相关知识储备：  
[【Android 基础】 应用（Application）启动流程][Android _ _Application]

通过本文你可以学习到Activity启动流程。

## 一、概览 ##

Activity 是 android 四大组件之一，很有必要知道它的启动过程，我们在上一篇文章中介绍了 APP的启动流程，里面大概讲到了Activity的  
启动流程，在本文中，我们系统的再总结一下，当成一个记录。

Activity 的启动方式我们讲有两种，一种是在应用内部启动，另一种是外部启动，比如Launcher；

*  应用内启动  
    通过 startActivity、startActivityForResult等方式来启动 Activity

其流程我们总结下：

1、调用 Activity 的 startActivity 方法来启动目标 Activity  
2、接着就会调用到 Instrunmentation 的 execStartActivity 方法，然后调用到 AMS 的 startActivity 中去  
3、调用到 AMS 中后，会执行到ActivityStarter 的 execute 方法，接着就会进行一些校验和判断权限，包括进程检查，intent检查，权限检查、是否启用新栈等  
4、所有的信息存储在ActivityRecord中，ActivityRecord是Activity在system\_server进程中的镜像，Activity实例与ActivityRecord实例一一对应。ActivityRecord用来存储Activity的信息，如所在的进程名称，应用的包名，所在的任务栈的taskAffinity等  
5、中间再经过一系列调用，又回调到 ActivityThread 的 handleLaunchActivity 来启动 Activity。

借用一张网络图片  
![11][]

*  应用外启动  
    通过Launcher 进程启动，Launcher 就是我们桌面程序，当系统开机后， Launcher 也随之被启动。

1、fork并调用ActivityThread的main方法创建app进程  
2、然后从 ActivityThread 调用到AMS中的attachApplicationLocked，创建Application  
3、Application创建完后，调用ActivityStackSupervisor的attachApplicationLocked方法，最终调用到handleLaunchActivity，进行activity的创建

## 二、应用内启动源码流程 (startActivity) ##

我们就从源码出发，一起来看看startActivity后面的流程

### 2.1 startActivity() ###

Activity.java

@Override
        public void startActivity(Intent intent) {
        
            this.startActivity(intent, null);
        }
        
        @Override
        public void startActivity(Intent intent, @Nullable Bundle options) {
        
            if (options != null) {
        
                startActivityForResult(intent, -1, options);
            } else {
        
              startActivityForResult(intent, -1);
            }
        }
        
        public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
        
            startActivityForResult(intent, requestCode, null);
        }

public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
                @Nullable Bundle options) {
        
            if (mParent == null) {
        
                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());
                }
    
            } else {
        
                // 最终也是调用 execStartActivity 方法，源码如下
                if (options != null) {
        
                    mParent.startActivityFromChild(this, intent, requestCode, options);
                } else {
        
                    mParent.startActivityFromChild(this, intent, requestCode);
                }
            }
        }

public void startActivityFromChild(@NonNull Activity child, @RequiresPermission Intent intent,
                int requestCode, @Nullable Bundle options) {
        
            options = transferSpringboardActivityOptions(options);
            Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, child,
                    intent, requestCode, options);
            if (ar != null) {
        
                mMainThread.sendActivityResult(
                    mToken, child.mEmbeddedID, requestCode,
                    ar.getResultCode(), ar.getResultData());
            }
            cancelInputsAndStartExitTransition(options);
        }

上面代码中，最终都会调用了 execStartActivity 方法，该方法会返回一个启动结果。我们一起来看看  
frameworks/base/core/java/android/app/Instrumentation.java

/**
         *
         * @param who              用来启动 Activity 的对象
         * @param contextThread Binder 对象，具有跨进程通信的能力，传入的是 ApplicationThread
         * @param token  Binder 对象，指向了服务端一个 ActivityRecord 对象
         * @param target 当前的 Activity
         * @param intent  Intent 对象
         * @param requestCode  请求码
         */
        public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, String target,
            Intent intent, int requestCode, Bundle options) {
        
            
            IApplicationThread whoThread = (IApplicationThread) contextThread;
            
            try {
        
                intent.migrateExtraStreamToClipData();
                intent.prepareToLeaveProcess(who);
                
                
                // 这里的service 就是 ActivityManagerService， 具体可以跟代码看到 
                // 这么一句 ： ServiceManager.getService(Context.ACTIVITY_SERVICE);
                
                int result = ActivityManager.getService()
                    .startActivity(whoThread, who.getBasePackageName(), intent,
                            intent.resolveTypeIfNeeded(who.getContentResolver()),
                            token, target, requestCode, 0, null, options);
                checkStartActivityResult(result, intent);
            } catch (RemoteException e) {
        
                
            }
            return null;
        }

通过 Binder 调用 AMS 启动 Activity，我们接着往下看

### 2.2 startActivityAsUser() ###

ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
    
    
        @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());
        }
    
        public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
                                             Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
                                             int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
                                             boolean validateIncomingUser) {
        
            enforceNotIsolatedCaller("startActivity");
      
            // 首先 检查调用者权限
            userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
                    Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
      
            // TODO: Switch to user app stacks here.
            return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
                    .setCaller(caller)
                    .setCallingPackage(callingPackage)
                    .setResolvedType(resolvedType)
                    .setResultTo(resultTo)
                    .setResultWho(resultWho)
                    .setRequestCode(requestCode)
                    .setStartFlags(startFlags)
                    .setProfilerInfo(profilerInfo)
                    .setActivityOptions(bOptions)
                    .setMayWait(userId)
                    .execute();
    
        }
        
        最后调用的是 ActivityStarter.execute();

上面代码最终调用到了 startActivityAsUser 方法，在内部将所有点的参数都交给了 ActivityStarter

### 2.3 startActivityUnchecked() ###

ActivityStarter 该类包含了启动的所有逻辑，比如 Intent 解析以及任务栈等。

ActivityStarter.java

int execute() {
        
            try {
        
                if (mRequest.mayWait) {
        
                    return startActivityMayWait(mRequest.caller, ...);
                } else {
        
                    // todo 
                    return startActivity(mRequest.caller, ...);  
                }
            } finally {
        
                onExecutionComplete();
            }
        }
    
       private int startActivity(IApplicationThread caller, Intent intent, ...) {
        
            
            // 再次检查调用者权限，包括进程检查，intent检查，权限检查等
            boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, ...);
            abort |= !mService.mIntentFirewall.checkStartActivity(intent, ...);
    
    
            // 每个 Activity 都会对应一个 ActivityRecord 对象
            ActivityRecord r = new ActivityRecord(mService, ...);
    
    
            // todo 
            result = startActivityUnchecked(r, sourceRecord ...);
       }
    
    
        // Note: This method should only be called from {@link startActivity}.
        private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord ...) {
        
    
            //设置初始化状态
            setInitialState(r, options, inTask, ...);
            
            //判断启动模式，并且在 mLaunchFlags 上追加对应标记
            computeLaunchingTaskFlags();
            
            //设置 Activity 的栈
            computeSourceStack();
            
            //设置 LaunchFlags 到 intent 上
            mIntent.setFlags(mLaunchFlags);
    
            //决定是否用新的栈
            ActivityRecord reusedActivity = getReusableIntentActivity();
            
            ...
    
            // Should this be considered a new task?
            int result = START_SUCCESS;
            if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
                 && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
        
              newTask = true;
              // 创建一个新的task来启动
              result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
            } else
    
    
            // todo 
            mSupervisor.resumeFocusedStackTopActivityLocked();    
        
        }

上面代码中会进行一些校验和判断权限，包括进程检查，intent检查，权限检查等

### 2.4 resumeFocusedStackTopActivityLocked() ###

ActivityStackSupervisor.java

boolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack...) {
        
    
    
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
    
            return false;
          }

resumeTopActivityUncheckedLocked -> resumeTopActivityInnerLocked -> startSpecificActivityLocked()  
ActivityStack.java

@GuardedBy("mService")
        boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        
            if (mStackSupervisor.inResumeTopActivity) {
        
    
                Activity 存在则resume
                transaction.setLifecycleStateRequest( ResumeActivityItem.obtain(next.app.repProcState,。。。);
                mService.getLifecycleManager().scheduleTransaction(transaction);
    
                不存在则调用下面这个
                result = resumeTopActivityInnerLocked(prev, options);
    
            } finally {
        
            }
    
            return result;
        }
    
        @GuardedBy("mService")
        private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        
    
                mStackSupervisor.startSpecificActivityLocked(next, true, false);
                
                return true;
        }

### 2.5 startSpecificActivityLocked -> realStartActivityLocked() ###

ActivityStackSupervisor.java  
startSpecificActivityLocked -> realStartActivityLocked(); 到这个地方，我们就可以看到真的开始启动 activity，  
后面就跟Application 里面一样了

void startSpecificActivityLocked(ActivityRecord r ...) {
        
            if (app != null && app.thread != null) {
        
              try {
        
                // 真的开始启动 activity  ,看下面的方法
                realStartActivityLocked(r, app, andResume, checkConfig);
                return;
              } catch (RemoteException e) {
        
              }
      
            }
        }
    
        真的开始启动 activity
        final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
                boolean andResume, boolean checkConfig) throws RemoteException {
        
    
            // Create activity launch transaction.
            final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
                    r.appToken);
                    clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                    System.identityHashCode(r), r.info,
                    // TODO: Have this take the merged configuration instead of separate global
                    // and override configs.
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
                    r.persistentState, results, newIntents, mService.isNextTransitionForward(),
                    profilerInfo));
                
            // Schedule transaction.
            mService.getLifecycleManager().scheduleTransaction(clientTransaction);
        }

ActivityManagerService

ClientLifecycleManager getLifecycleManager() {
        
            return mLifecycleManager;
        }

ClientLifecycleManager

通过代码，我们可以看到，获取的client就是 ActivityThread，IApplicationThread是一个AIDL文件
        void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        
            final IApplicationThread client = transaction.getClient();
            transaction.schedule();
            
        }

ClientTransaction

/** Target client. */
        private IApplicationThread mClient;
        
        public void schedule() throws RemoteException {
        
            mClient.scheduleTransaction(this);
        }

ClientTransactionHandler

//ActivityThread中没有复写scheduleTransaction，会执行到父类的方法
        //public final class ActivityThread extends ClientTransactionHandler
        //ClientTransactionHandler.java
        public abstract class ClientTransactionHandler {
        
        
            void scheduleTransaction(ClientTransaction transaction) {
        
                transaction.preExecute(this);
                //发送消息
                sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
            }
        }

ActivityThread.java

case EXECUTE_TRANSACTION:
            final ClientTransaction transaction = (ClientTransaction) msg.obj;
            mTransactionExecutor.execute(transaction);
            break;

这里其实就是执行LaunchActivityItem的execute方法，  
其赋值的地方在realStartActivityLocked()方法，大家可以回头看看，前面有这么一句代码  
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),

TransactionExecutor.java

public void execute(ClientTransaction transaction) {
        
            final IBinder token = transaction.getActivityToken();
    
            executeCallbacks(transaction);
    
            executeLifecycleState(transaction);
            mPendingActions.clear();
            log("End resolving transaction");
        }
    
        /** Cycle through all states requested by callbacks and execute them at proper times. */
        @VisibleForTesting
        public void executeCallbacks(ClientTransaction transaction) {
        
            
            final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    
            final IBinder token = transaction.getActivityToken();
            ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
    
            final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
            
            final int size = callbacks.size();
            for (int i = 0; i < size; ++i) {
        
                final ClientTransactionItem item = callbacks.get(i);
                
                item.execute(mTransactionHandler, token, mPendingActions);
                item.postExecute(mTransactionHandler, token, mPendingActions);
                
            }
        }

到这里就调用到我们熟悉的handleLaunchActivity了  
LaunchActivityItem.java

@Override
        public void execute(ClientTransactionHandler client, IBinder token,
                PendingTransactionActions pendingActions) {
        
            ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
                    mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
                    mPendingResults, mPendingNewIntents, mIsForward,
                    mProfilerInfo, client);
            client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
        }

最后调用到ActivityThread

## 三、 Activity实例化过程 ##

ActivityThread.java

/**
         * Extended implementation of activity launch. Used when server requests a launch or relaunch.
         */
        @Override
        public Activity handleLaunchActivity(ActivityClientRecord r,
                PendingTransactionActions pendingActions, Intent customIntent) {
        
    
            final Activity a = performLaunchActivity(r, customIntent);
            
            return a;
        }
    
        Activity实例化过程
        
        /**  Core implementation of activity launch. */
        private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        
    
            Activity activity = null;
            try {
        
                // 通过ClassLoader去加载需要启动的activity， 反射实例化Activity对象
                java.lang.ClassLoader cl = appContext.getClassLoader();
                activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
            } catch (Exception e) {
        
            }
    
            // 在该方法内部创建window，并设置window回调，
            activity.attach(appContext, this, getInstrumentation() ...);
            
                
            theme
            
            //当实例化Activity对象后，继续执行callActivityOnCreate， 继而调用Activity的onCreate，
            // 这样就完成了Activity生命周期的第一个回调onCreate方法
            if (r.isPersistable()) {
        
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
        
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
        }

下面的代码比较简单，就不贴了  
frameworks/base/core/java/android/app/Instrumentation.java

## 四、 setContentView ##

这里内容太多，我们另外写一篇文章。

## 五、 后续生命周期 ##

接下来就是执行 Activity 其他生命周期函数  
ActivityThread.java

@Override
        public void handleStartActivity(ActivityClientRecord r,
                PendingTransactionActions pendingActions) {
        
            final Activity activity = r.activity;
    
            // Restore instance state
            if (pendingActions.shouldRestoreInstanceState()) {
        
                if (r.isPersistable()) {
        
                    if (r.state != null || r.persistentState != null) {
        
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                r.persistentState);
                    }
                } else if (r.state != null) {
        
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                }
            }
            
            // Call postOnCreate()
            if (pendingActions.shouldCallOnPostCreate()) {
        
                activity.mCalled = false;
                if (r.isPersistable()) {
        
                    mInstrumentation.callActivityOnPostCreate(activity, r.state,
                            r.persistentState);
                } else {
        
                    mInstrumentation.callActivityOnPostCreate(activity, r.state);
                }
            }
        }
    
    
        @Override
        public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
                String reason) {
        
            
        }

写在最后：  
在应用进程创建 activity 后，activity 将执行以下操作：

1.  初始化值。
2.  调用构造函数。
3.  根据 activity 的当前生命周期状态，相应地调用回调方法，如 Activity.onCreate()。  
    通常，onCreate() 方法对加载时间的影响最大，因为它执行工作的开销最高：加载和渲染视图，以及初始化运行 activity 所需的对象。

## 六、 推荐阅读 ##

[Java 专栏][Java]

[SQL 专栏][SQL]

[数据结构与算法][Link 1]

[Android学习专栏][Android]

[f5ba2a630958460ab6a581523327cf4d.png]: https://img-blog.csdnimg.cn/f5ba2a630958460ab6a581523327cf4d.png
[Android _ _Application]: http://t.csdn.cn/jduK3
[11]: https://img-blog.csdnimg.cn/img_convert/855fffad0eb1efb1ad9cbee5185daa7b.png
[Java]: https://blog.csdn.net/fumeidonga/category_12311533.html
[SQL]: http://t.csdn.cn/4i3TW
[Link 1]: http://t.csdn.cn/9gGNy
[Android]: http://t.csdn.cn/A0aTR