Android Activity启动流程源码全解析（2）

最新推荐文章于 2024-05-23 08:30:00 发布

梦里梦到醒不来的梦里

最新推荐文章于 2024-05-23 08:30:00 发布

阅读量1.4k

点赞数 1

分类专栏： Android源码解惑 Android源码解析文章标签： android android源码 adnroid开发

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/ly502541243/article/details/52883212

版权

本文详细分析了Android Activity的启动流程，包括startPausingLocked的执行、已存在进程中的Activity如何通过scheduleResumeActivity启动，以及空Activity时如何通过startSpecificActivityLocked启动新进程并调用生命周期方法。通过源码追踪，揭示了Activity启动过程中的 Binder 通信和生命周期调用机制。

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

接上之前的分析

++Android Activity启动流程源码全解析（1）++

1.正在运行的Activity调用startPausingLocked

一个一个分析，先来看看startPausingLocked：

    final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,
            boolean dontWait) {
   
        ......
        if (prev.app != null && prev.app.thread != null) {
   
            if (DEBUG_PAUSE) Slog.v(TAG_PAUSE, "Enqueueing pending pause: " + prev);
            try {
   
                EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,
                        prev.userId, System.identityHashCode(prev),
                        prev.shortComponentName);
                mService.updateUsageStats(prev, false);
                prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                        userLeaving, prev.configChangeFlags, dontWait);
            } catch (Exception e) {
   
                Slog.w(TAG, "Exception thrown during pause", e);
                mPausingActivity = null;
                mLastPausedActivity = null;
                mLastNoHistoryActivity = null;
            }
        } else {
   
            mPausingActivity = null;
            mLastPausedActivity = null;
            mLastNoHistoryActivity = null;
        }  
        ......

执行Activity所在进程的schedulePauseActivity方法,prev.app.thread为IApplicationThread，这又是一个Binder，真实的执行方法是在ApplicationThread中（继承自IApplicationThread的子类ApplicationThreadNative），这两个类是服务端跟客户端通信，对应客户端和服务端通信是ActivityManagerProxy和ActivityManagerService，他们都继承自ActivityManagerNative

ApplicationThread是ActivityThread的私有内部类：

ApplicationThread.schedulePauseActivity

        public final void schedulePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport) {
   
            sendMessage(
                    finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                    token,
                    (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
                    configChanges);
        }
        
        private void sendMessage(int what, Object obj, int arg1, int arg2) {
   
            sendMessage(what, obj, arg1, arg2, false);
        }
        private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
   
            if (DEBUG_MESSAGES) Slog.v(
                TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
                + ": " + arg1 + " / " + obj);
            Message msg = Message.obtain();
            msg.what = what;
            msg.obj = obj;
            msg.arg1 = arg1;
            msg.arg2 = arg2;
            if (async) {
   
                msg.setAsynchronous(true);
            }
            mH.sendMessage(msg);
        }

熟悉的handler发送消息，自然想到处理消息是在handleMessage中：

 case PAUSE_ACTIVITY:
     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
     handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,
             (msg.arg1&2) != 0);
     maybeSnapshot();
     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
     break;
 case PAUSE_ACTIVITY_FINISHING:
     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
     handlePauseActivity((IBinder)msg.obj, true, (msg.arg1&1) != 0, msg.arg2,
             (msg.arg1&1) != 0);
     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

这两个消息都是调用的

handlePauseActivity

    private void handlePauseActivity(IBinder token, boolean finished,
            boolean userLeaving, int configChanges, boolean dontReport) {
   
        ActivityClientRecord r = mActivities.get(token);
        if (r != null) {
   
            if (userLeaving) {
   
                performUserLeavingActivity(r);
            }

            r.activity.mConfigChangeFlags |= configChanges;
            performPauseActivity(token, finished, r.isPreHoneycomb());

            if (r.isPreHoneycomb()) {
   
                QueuedWork.waitToFinish();
            }

            //通知activity manager已经pause
            if (!dontReport) {
   
                try {
   
                    ActivityManagerNative.getDefault().activityPaused(token);
                } catch (RemoteException ex) {
   
                }
            }
            mSomeActivitiesChanged = true;
        }
    }

来到performPauseActivity：

    final Bundle performPauseActivity(IBinder token, boolean finished,
            boolean saveState) {
   
        ActivityClientRecord r = mActivities.get(token);
        return r != null ? performPauseActivity(r, finished, saveState) : null;
    }
    final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,
            boolean saveState) {
   
        if (r.paused) {
   
            if (r.activity.mFinished) {
   
                //如果已经finish，直接返回
                return null;
            }
            RuntimeException e = new RuntimeException(
                    "Performing pause of activity that is not resumed: "
                    + r.intent.getComponent().toShortString());
            Slog.e(TAG, e.getMessage(), e);
        }
        if (finished) {
   
            r.activity.mFinished = true;
        }
        try {
   
            //保存状态
            if (!r.activity.mFinished && saveState) {
   
                callCallActivityOnSaveInstanceState(r);
            }
            r.activity.mCalled = false;
            //交给Instrumentation处理
            mInstrumentation.callActivityOnPause(r.activity);
            EventLog.writeEvent(LOG_AM_ON_PAUSE_CALLED, UserHandle.myUserId(),
                    r.activity.getComponentName().getClassName());