Android Activity启动流程解析-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_32671919/article/details/83146305

ActivityManagerServices，简称AMS，服务端对象，负责系统中所有Activity的生命周期
ActivityThread，App的真正入口。当开启App之后，会调用main()开始运行，开启消息循环队列，这就是传说中的UI线程或者叫主线程。与ActivityManagerServices配合，一起完成Activity的管理工作
ApplicationThread，用来实现ActivityManagerService与ActivityThread之间的交互。在ActivityManagerService需要管理相关Application中的Activity的生命周期时，通过ApplicationThread的代理对象与ActivityThread通讯。
ApplicationThreadProxy，是ApplicationThread在服务器端的代理，负责和客户端的ApplicationThread通讯。AMS就是通过该代理与ActivityThread进行通信的。
Instrumentation，每一个应用程序只有一个Instrumentation对象，每个Activity内都有一个对该对象的引用。Instrumentation可以理解为应用进程的管家，ActivityThread要创建或暂停某个Activity时，都需要通过Instrumentation来进行具体的操作。
ActivityStack，Activity在AMS的栈管理，用来记录已经启动的Activity的先后关系，状态信息等。通过ActivityStack决定是否需要启动新的进程。
ActivityRecord，ActivityStack的管理对象，每个Activity在AMS对应一个ActivityRecord，来记录Activity的状态以及其他的管理信息。其实就是服务器端的Activity对象的映像。
TaskRecord，AMS抽象出来的一个“任务”的概念，是记录ActivityRecord的栈，一个“Task”包含若干个ActivityRecord。AMS用TaskRecord确保Activity启动和退出的顺序。如果你清楚Activity的4种launchMode，那么对这个概念应该不陌生。

一个ActivityRecord对应一个Activity，保存了一个Activity的所有信息;但是一个Activity可能会有多个ActivityRecord,因为Activity可以被多次启动，这个主要取决于其启动模式。
一个TaskRecord由一个或者多个ActivityRecord组成，这就是我们常说的任务栈，具有后进先出的特点。
ActivityStack则是用来管理TaskRecord的，包含了多个TaskRecord。

TaskRecord ActivityRecord ActivityStack之间的关系 https://www.jianshu.com/p/94816e52cd77

1,Launcher中

(1) startActivitySafely()-->

(2) startActivity()-->

(3) startActivityForResult-->

(4) Instrumentation.execStartActivity()-->

(5) ActivityManagerNative.getDefault().startActivity()；这个方法执行的是ActivityManagerService的代理类ActivityManagerProxy.startActivity();将Lanucher的信息和intent（包含要启动的activity的信息）传递给AMS

2,ActivityManagerService中

(6) startActivity()-->

(7) mMainStack.startActivityMayWait()--> (注：mMainStack为ActivityStack)

通过PackageManager去PackageMangerService中解析intent的内容，获取要开启的Activity的信息

3,ActivityStack中 ActivityStack是ActivityManagerService的成员变量

(8) startActivityLocked()-->获取Luncher的ProcessRecord,ActivityRecord,pid,uid；为将要启动的Activity创建ActivityRecord；到这里AMS获取了源Activity和目标Activity的信息即ActivityRecord

(9) startActivityUnCheckedLocked()--> 为目标Activity创建一个专属任务将它保存在目标Activity的ActivityRecord的task中，新创建的task交给AMS管理

startActivityLocked()--> 调用startActivityLocked的重载方法将目标Activity放在ActivityStack所描述的堆栈的栈顶

(10) resumeTopActivityLocked()-->

(11) startPausingLocked()-->

(12) Luncher进程的ApplicationThreadProxy.schedulePauseActivity()-->通过进程间通信，使用Luncher所在进程的ApplicationThread的代理类ApplicationThreadProxy向Luncher发送一个终止通知，Luncher处理完终止通知，向AMS发送一个启动目标Activity的通知

4，Luncher中，处理AMS发出的SCHEDULE_PAUSE_ACTIVITY_TRANSATION的进程间通信请求

(13) ApplicationThread的schedulePauseActivity()-->

(14) ApplicationThread的queueOrSendMesssage()-->向Luncher主线程的消息队列发送一个PAUSE_ACTIVITY的消息

(15) ActivityThread H中的handleMessage()-->

(16) 在H的handleMessage中调用handlePauseActivity()-->调用成员函数performPauseActivity()，向Luncher发送一个中止通知，即调用Luncher的onPause()

(17) ActivityManagerNative.getDefaule().activityPaused()--> 告诉AMS Luncher已经进入pause状态

5，AMS中

(18) activityPaused()-->

(19) AMS的activityPaused()-->

(20) ActivityStack的completePauseLocked()-->获取Luncher的ActivityRecord，将成员变量state设置为Activity.state.PAUSED

(21) ActivityStack的 resumeTopActivityLocked()--> 获取目标activity的ActivityRecord

(22) ActivityStackSupervisor的 startSpecificActivityLocked()--> 判断目标activity所需要的进程是否存在，若存在调用realStartActivityLocked()，否则调用AMS的startProcessLocked(),这里讨论进程不存在的时候

(23) AMS的startProcessLocked()--> 创建ProcessRecord，将它保存在AMS的成员变量中，调用Process.start()启动进程，并指定进程的入口函数是ActivityThread的main()函数

6，ActivityThread中

(24) main()--> 创建ActivityThread,同时创建ActivityThread的内部类ApplicaticonThread；创建mainLooper；执行attachApplication()方法；在attachApplication()中进行进程间通信

(25) ActivityManagerNative.getDefult().attachApplication(mApplication)-->将ApplicationThread传给AMS

7，AMS中

(26) attachApplication()-->

(27) attachApplicationLocked()-->bindApplication();// client端handleBindApplication(),初始化application，执行attachBaseContext(),执行onCreat();初始化Instrumentation

(28) ActivityStack的realStartActivityLocked()-->

(29) ApplicationThreadProxy.scheduleLunchActivity()--> 进程间通信

8，目标进程中

(30) ApplicationThread的scheduleLunchActivity()--> 将目标activity信息封装成ActivityClientRecord

(31) ApplicationThread的queueOrSendMesssage()-->向ActivityThread的消息队列发送一个LUNCH_ACTIVITY的消息

(32) ActivityThread H中的handleMessage()--> 获取一个loadedApk（包含了apk的所有资源）对象，将它保存在ActivityClientRecord对象的成员变量packageInfo中

(33) 在H的handleMessage()-->

(34) perfomLunchActivity()--> 创建activity，执行activity.attach() 初始化phonewindow 设置windowManager

执行instrumentation.callActivityOnGreat()

(35) activity onGreat()

(36) perfoemLunchActivity() 中调用handleResumeActivity() 将DecorView 添加到PhoneWindw中,调用requestLayout()方法，最终调用ViewRootImpl的requestLayout();调用performTraveals()-->执行view的 measure layout draw

10.0版本分析

client端

Activity.startActivity(Intent intent)
Activity.startActivityForResult(intent, -1);
Instrumentation.execStartActivity(this, mMainThread.getApplicationThread(),                                          mToken, this,intent, requestCode, options);

public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        ...  
             int result = ActivityTaskManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
             checkStartActivityResult(result, intent);
...
        return null;
    }

ActivityTaskManagerService端

startActivity();
startActivityAsUser();

 public final int startActivityAsUser(...) {
       ...
//调用ActivityStarter.execute()
        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();

    }

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

ActivityStarter.execute()

int execute() {
        try {
            if (mRequest.mayWait) {
                return startActivityMayWait(...);
            } else {
                return startActivity(...);
            }
        } finally {
            onExecutionComplete();
        }
    }

ActivityStarter.startActivityMayWait(...)解析intent信息，获取ActivityInfo和ResolveInfo

ActivityStarter.startActivityt(...)//ActivityRecord r = new ActivityRecord(...);放在stack top

ActivityStarter.startActivityUnchecked()

做了很多事情.........

ActivityStackSupervisor.resumeFocusedStackTopActivityLocked()//没做什么事
(ActivityStack)targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);//没做什么事
ActivityStack.resumeTopActivityInnerLocked()
startPausingLocked(userLeaving, false, next, false);

    final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
            ActivityRecord resuming, boolean pauseImmediately) {
        ...             mService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
                        prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
                                prev.configChangeFlags, pauseImmediately));
            ...
    }

ClientTransaction中

 public void schedule() throws RemoteException {
        //mClient是IApplicationThread
        mClient.scheduleTransaction(this);
    }

跨进程调用到ApplicationThread到scheduleTransaction(this);

@Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            //会调用到ActivityThread父类中,别忘了transaction中的item是PauseActivityItem
            ActivityThread.this.scheduleTransaction(transaction);
        }

void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }
H中
 case EXECUTE_TRANSACTION:
       final ClientTransaction transaction = (ClientTransaction) msg.obj;
            //TransactionExecutor
             mTransactionExecutor.execute(transaction);

public void execute(ClientTransaction transaction) {
        ...

        executeCallbacks(transaction);

        executeLifecycleState(transaction);
        ...
    }

public void executeCallbacks(ClientTransaction transaction) {
        
  //item是PauseActivityItem
  item.execute(mTransactionHandler, token, mPendingActions);
  item.postExecute(mTransactionHandler, token, mPendingActions);
            
}

 @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
       //client是ActivityThread
        client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
                "PAUSE_ACTIVITY_ITEM");
        
    }

 public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
            int configChanges, PendingTransactionActions pendingActions, String reason) {
        ActivityClientRecord r = mActivities.get(token);
            performPauseActivity(r, finished, reason, pendingActions);

        }
    }

mInstrumentation.callActivityOnPause(r.activity);
activity.performPause();

原来的activity已经pause了，接下来继续分析启动activity的流程
//判断进程是否存在，不存在启动进程
mStackSupervisor.startSpecificActivityLocked(r, andResume, false);

void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
        // Is this activity's application already running?
        final WindowProcessController wpc =
                mService.getProcessController(r.processName, r.info.applicationInfo.uid);

        boolean knownToBeDead = false;
        if (wpc != null && wpc.hasThread()) {
            try {
                realStartActivityLocked(r, wpc, andResume, checkConfig);
                return;
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception when starting activity "
                        + r.intent.getComponent().flattenToShortString(), e);
            }

            // If a dead object exception was thrown -- fall through to
            // restart the application.
            knownToBeDead = true;
        }

        // Suppress transition until the new activity becomes ready, otherwise the keyguard can
        // appear for a short amount of time before the new process with the new activity had the
        // ability to set its showWhenLocked flags.
        if (getKeyguardController().isKeyguardLocked()) {
            r.notifyUnknownVisibilityLaunched();
        }

       
            final Message msg = PooledLambda.obtainMessage(
//创建新的进程ActivityManagerInternal的实现类是activityMangerServive内部类LocalService
                    ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
                    r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
            mService.mH.sendMessage(msg);
        
    }

ams

final ProcessRecord startProcessLocked(...) {
        return startProcessLocked(...);
    }

//启动进程这块儿有待确认，下面的逻辑不是10.0的
startProcessLocked(...);
Process.start()
zygoteProcess.start()
zygoteProcess.startViaZygote()
zygoteProcess.zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(),argsForZygote)
到zygot进程，fork出app进程

进程启动参考这个app进程启动

执行ActivityThread.main

    public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();

        ...
        ActivityThread thread = new ActivityThread();
        thread.attach(false, startSeq);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        ...
        Looper.loop();

      ...
    }

    private void attach(boolean system, long startSeq) {
        sCurrentActivityThread = this;
        mSystemThread = system;
        if (!system) {
           ...
            final IActivityManager mgr = ActivityManager.getService();
            try {
                mgr.attachApplication(mAppThread, startSeq);
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
            
        } 

        ...
    }

AMS中

attachApplication
attachApplicationLocked
IApplicationThread.bindApplication
mStackSupervisor.attachApplicationLocked(app)

ApplicationThread中

        public final void bindApplication(...) {

            ...
            sendMessage(H.BIND_APPLICATION, data);
        }

public void handleMessage(Message msg) {
           
            switch (msg.what) {
                case BIND_APPLICATION:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
                    AppBindData data = (AppBindData)msg.obj;
                    handleBindApplication(data);
                    
                    break;
...
}

    private void handleBindApplication(AppBindData data) {
        

       ...
            mInstrumentation = new Instrumentation();
            mInstrumentation.basicInit(this);
        

        
     
                mInstrumentation.onCreate(data.instrumentationArgs);
            
                mInstrumentation.callApplicationOnCreate(app);
            ...
    }

mStackSupervisor.attachApplicationLocked(app)

    boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
        ...
                        try {
                            if (realStartActivityLocked(hr, app, true, true)) {
                                didSomething = true;
                            }
                        ...
        }
        return didSomething;
    }

    boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {

       ...
                // Create activity launch transaction.
          final ClientTransaction clientTransaction = ClientTransaction.obtain(
                        proc.getThread(), r.appToken);

//重点
          clientTransaction.addCallback(LaunchActivityItem.obtain(...);
          if (andResume) {
//执行onresume会调用到
                lifecycleItem =ResumeActivityItem.obtain(dc.isNextTransitionForward());
                } else {
                    lifecycleItem = PauseActivityItem.obtain();
                }
          clientTransaction.setLifecycleStateRequest(lifecycleItem);
                // Schedule transaction.
                mService.getLifecycleManager().scheduleTransaction(clientTransaction);

                ...

        return true;
    }

ams getLifecycleManager()返回ClientLifecycleManager

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        ...
        transaction.schedule();
        ...
    }

public void schedule() throws RemoteException {
//mClient是IApplicationThread
        mClient.scheduleTransaction(this);
    }

@Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//会调用到ActivityThread 父类的的方法
            ActivityThread.this.scheduleTransaction(transaction);
        }

void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }

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

public void execute(ClientTransaction transaction) {
        ...
        //一会儿执行到increase
        executeCallbacks(transaction);
        //一会儿回执行到on resume
        executeLifecycleState(transaction);
       ...
    }

public void executeCallbacks(ClientTransaction transaction) {
        ...
//item是LaunchActivityItem
            item.execute(mTransactionHandler, token, mPendingActions);
            ...
    }

@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, mAssistToken);
//client实现类是ActivityThread
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
        
    }

public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
       ...

        final Activity a = performLaunchActivity(r, customIntent);

       ...

        return a;
    }

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ...
//创建activity
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            ...
//创建PhoneWindow
                activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.configCallback,
                        r.assistToken);

                ...
                //回执行到activity的oncreate
                mInstrumentation.callActivityOnCreate(activity, r.state);

        return activity;
    }

接下来分析executeLifecycleState(transaction);

private void executeLifecycleState(ClientTransaction transaction) {
        //记不记得realStartActivityLocked中：lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
        //所以ActivityLifecycleItem是ResumeActivityItem
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();

        final IBinder token = transaction.getActivityToken();
        final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
        
        // Cycle to the state right before the final requested state.
        //这个方法会执行到activity到onStart()
        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);

        // Execute the final transition with proper parameters.
        //这个方法会执行到onResume()
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        //告诉服务端执行了onResume()
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
    }

cycleToPath()->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);//state = 2，执行ON_START 的case
            switch (state) {
               ...
                case ON_START:
                    //别忘了mTransactionHandler的儿子是ApplicationHandler
                    mTransactionHandler.handleStartActivity(r, mPendingActions);
                    break;
                ...
                
            }
        }
    }

 public void handleStartActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions) {
        final Activity activity = r.activity;
        
        // Start
        activity.performStart("handleStartActivity");
        r.setState(ON_START);
        
    }

接下来分析TransactionExecutor.lifecycleItem.execute(mTransactionHandler, token, mPendingActions);

ResumeActivityItem.execute(mTransactionHandler, token, mPendingActions);
//ClientTransactionHandler到实现类ActivityThread
client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,

public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
            String reason) {
        //执行onResume()
        final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
       

        final Activity a = r.activity;

        
        final int forwardBit = isForward
                ? WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

        
        if (r.window == null && !a.mFinished && willBeVisible) {
            r.window = r.activity.getWindow();
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            ViewManager wm = a.getWindowManager();
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;
            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;
            if (r.mPreserveWindow) {
                a.mWindowAdded = true;
                r.mPreserveWindow = false;
                // Normally the ViewRoot sets up callbacks with the Activity
                // in addView->ViewRootImpl#setView. If we are instead reusing
                // the decor view we have to notify the view root that the
                // callbacks may have changed.
                ViewRootImpl impl = decor.getViewRootImpl();
                if (impl != null) {
                    impl.notifyChildRebuilt();
                }
            }
            if (a.mVisibleFromClient) {
                if (!a.mWindowAdded) {
                    a.mWindowAdded = true;
                    //将decorView添加到windowManager
                    wm.addView(decor, l);
                } else {
                    // The activity will get a callback for this {@link LayoutParams} change
                    // earlier. However, at that time the decor will not be set (this is set
                    // in this method), so no action will be taken. This call ensures the
                    // callback occurs with the decor set.
                    a.onWindowAttributesChanged(l);
                }
            }

            // If the window has already been added, but during resume
            // we started another activity, then don't yet make the
            // window visible.
        } else if (!willBeVisible) {
            if (localLOGV) Slog.v(TAG, "Launch " + r + " mStartedActivity set");
            r.hideForNow = true;
        }

        // Get rid of anything left hanging around.
        cleanUpPendingRemoveWindows(r, false /* force */);

        // The window is now visible if it has been added, we are not
        // simply finishing, and we are not starting another activity.
        if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
            ...
            if (r.activity.mVisibleFromClient) {
                r.activity.makeVisible();
            }
        }

        //执行上个activity的onStop()
        Looper.myQueue().addIdleHandler(new Idler());
    }