android四大组件之一-activity实现原理分析（已废弃）

前言：

这篇文章是很早期的文章，写的并不好，建议看下面这篇：

android四大组件之一-Activity实现原理分析_失落夏天的博客-CSDN博客

内容主体：

整理下，这样写还是不太好的。
先总体分为几个流程，activity,Instrumentation,ActivityManagerService,ActivityStarter,ActivityThread这几大部分。
其中activity,Instrumentation,ActivityThread属于用户进程，其余的属于系统进程。
 

一Activity中的启动
在activity中，无论何种方式调用startActivity，最终都会调用到
startActivityForResult();方法

二Instrumentation部分最终调用方法：
int result = ActivityManager.getService()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);其中whoThread是当前用户进程的ActivityThread的binder的引用。对应的实现类是ActivityThread.ApplicationThread。
而ActivityManager.getService()获得的是ActivityManagerService的binder引用对象，ActivityManagerService是实现类。
则最终会通过跨进程binder调用，调用到ActivityManagerService中的startActivity的方法。

三ActivityManagerService部分
这里面会有层层调用，由于不是核心，所以略过，值列出来调用顺序
ActivityManagerService.startActivity
ActivityManagerService.startActivityAsUser四ActivityStarter和ActivityStack部分
非核心逻辑的部分，略过只保留方法调用堆栈
ActivityStarter.startActivityMayWait
ActivityStarter.startActivityLocked
ActivityStarter.startActivity
ActivityStarter.startActivity
ActivityStarter.startActivityUnchecked(控制完整的启动流程的核心逻辑，主要包含下面几个流程)
ActivityStarter.getReusableIntentActivity(); 获取栈中是否存在对应的activity，如果存在，一个逻辑，我们这里先按照主流程走下去，假设stack中不存在对应的activity，后续回过头来在看。
ActivityStackSupervisor.resumeFocusedStackTopActivityLocked
ActivityStack.resumeTopActivityUncheckedLocked
ActivityStack.resumeTopActivityInnerLocked
ActivityStackSupervisor.pauseBackStacks//首先会暂停上一个activity。这里判断上一个的条件就是当前前台运行的PS：这里插一句，如果手机不是很好的，桌面快速连续点开两个APP，你会发现第一个APP先被启动，然后第二个APP也会启动，并盖住第一个APP。那么被暂停的就是第一个APP的activity，而不是启动的桌面activity。

ActivityStackSupervisor.startSpecificActivityLocked//在ActivityStack.resumeTopActivityInnerLocked中被调用，启动activity的主流程
ActivityStackSupervisor.realStartActivityLocked

realStartActivityLocked这个方法中：

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {

        //app对应的是一个用户进程,thead指的就是上面的ApplicationThread的binder引用，所以通过这个binder通知到ApplicationThread调用scheduleLaunchActivity方法，正式回归用户进程。

            app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                    System.identityHashCode(r), r.info,
              ...
        return true;
    }

五ActivityThread部分

ApplicationThread.scheduleLaunchActivity方法：

@Override
        public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
                ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
                CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
                int procState, Bundle state, PersistableBundle persistentState,
                List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
                boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {

            updateProcessState(procState, false);

            ActivityClientRecord r = new ActivityClientRecord();

            r.token = token;
            r.ident = ident;
            r.intent = intent;
            r.referrer = referrer;
            r.voiceInteractor = voiceInteractor;
            r.activityInfo = info;
            r.compatInfo = compatInfo;
            r.state = state;
            r.persistentState = persistentState;

            r.pendingResults = pendingResults;
            r.pendingIntents = pendingNewIntents;

            r.startsNotResumed = notResumed;
            r.isForward = isForward;

            r.profilerInfo = profilerInfo;

            r.overrideConfig = overrideConfig;
            updatePendingConfiguration(curConfig);
             //包装activity对象，post到主线程，准备启动
            sendMessage(H.LAUNCH_ACTIVITY, r);
        }

最终会调用到ActivityThread的handleLaunchActivity方法

 private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        //这里包含activity的初始化以及onCreate,onStart方法
        Activity a = performLaunchActivity(r, customIntent);

        if (a != null) {
            r.createdConfig = new Configuration(mConfiguration);
            reportSizeConfigurations(r);
            Bundle oldState = r.state;
            //这里会调用resume方法
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
                ...
            
        if (!r.activity.mFinished && r.startsNotResumed) {
                //这里没看懂，后续补充
                performPauseActivityIfNeeded(r, reason);
        }
            ...
        } else {
            //异常情况则结束
            try {
                ActivityManager.getService()
                    .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
        }
    }

接下来就是启动方法performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        //通过classloader加载对应的activity，反射实例化activity
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            ...
        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

            ...
            //1.最先调用的是activity的attach方法
                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);

                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                checkAndBlockForNetworkAccess();
                activity.mStartedActivity = false;
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }

                activity.mCalled = false;
                if (r.isPersistable()) {
                    //2调用的是onCreate方法
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                if (!activity.mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + r.intent.getComponent().toShortString() +
                        " did not call through to super.onCreate()");
                }
                r.activity = activity;
                r.stopped = true;
                //3.调用onStart方法，注意，在这之前调用finish方法的话，就不会调用onStart了。
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
               ...
            //记录activity对象
            mActivities.put(r.token, r);

        } catch (SuperNotCalledException e) {
            throw e;

        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to start activity " + component
                    + ": " + e.toString(), e);
            }
        }

        return activity;
    }

handlerLaunchActivity之后接下来则会调用到handleResumeActivity方法。

final void handleResumeActivity(IBinder token,
            boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        ActivityClientRecord r = mActivities.get(token);
       //会调用到activity的onRsume方法
        r = performResumeActivity(token, clearHide, reason);

           ...
            if (!willBeVisible) {
                try {
                    willBeVisible = ActivityManager.getService().willActivityBeVisible(
                            a.getActivityToken());
                } catch (RemoteException e) {
                    throw e.rethrowFromSystemServer();
                }
            }
            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;
//这里会把activity的decor注册到WindowManger上，在这之前哪怕子线程操作UI，也不会触发界面绘制，也就不会出现子线程不能更新UI的异常。
                        wm.addView(decor, l);
                    } else {
                     ...
 if (!r.onlyLocalRequest) {
                r.nextIdle = mNewActivities;
                mNewActivities = r;
                if (localLOGV) Slog.v(
                    TAG, "Scheduling idle handler for " + r);
//这里会触发一个IdleHandler，该IdleHandler的特点就是会在CPU空闲时执行
                Looper.myQueue().addIdleHandler(new Idler());
            }
            ...
    }

第六部分暂停栈顶ac

 private class Idler implements MessageQueue.IdleHandler {
        @Override
        public final boolean queueIdle() {
            ActivityClientRecord a = mNewActivities;//对应的时栈顶的activity的记录
            ...
            if (a != null) {
                mNewActivities = null;
                IActivityManager am = ActivityManager.getService();
                ActivityClientRecord prev;
                ...
                    if (a.activity != null && !a.activity.mFinished) {
                        try {
                            //如果未结束，则通过binder机制跨进程调用activityManager的activityIdle方法
                            am.activityIdle(a.token, a.createdConfig, stopProfiling);
                ...
        }
    }

下面是ActivityManagerService的activityIdle方法

@Override
    public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) {
        final long origId = Binder.clearCallingIdentity();
        synchronized (this) {
            //根据token获取到对应的ActivityStack
            ActivityStack stack = ActivityRecord.getStackLocked(token);
            if (stack != null) {
                //这里调用activityIdleInternalLocked方法
                ActivityRecord r =
                        mStackSupervisor.activityIdleInternalLocked(token, false /* fromTimeout */,
                                false /* processPausingActivities */, config);
                if (stopProfiling) {
                    if ((mProfileProc == r.app) && (mProfileFd != null)) {
                        try {
                            mProfileFd.close();
                        } catch (IOException e) {
                        }
                        clearProfilerLocked();
                    }
                }
            }
        }
        Binder.restoreCallingIdentity(origId);
    }

ActivityStackSupervisor的activityIdleInternalLocked方法如下：

 final ActivityRecord activityIdleInternalLocked(final IBinder token, boolean fromTimeout,
            boolean processPausingActivities, Configuration config) {
        ...
        //获取应该暂停的ActivityRecord的结合
        final ArrayList<ActivityRecord> stops = processStoppingActivitiesLocked(r,
                true /* remove */, processPausingActivities);
        NS = stops != null ? stops.size() : 0;
        if ((NF = mFinishingActivities.size()) > 0) {
            finishes = new ArrayList<>(mFinishingActivities);
            mFinishingActivities.clear();
        }

        if (mStartingUsers.size() > 0) {
            startingUsers = new ArrayList<>(mStartingUsers);
            mStartingUsers.clear();
        }

        //根据ActivityStack中标记的状态，对应的取暂停或者结束对应的Activity
        for (int i = 0; i < NS; i++) {
            r = stops.get(i);
            final ActivityStack stack = r.getStack();
            if (stack != null) {
                if (r.finishing) {
                    stack.finishCurrentActivityLocked(r, ActivityStack.FINISH_IMMEDIATELY, false);
                } else {
                    stack.stopActivityLocked(r);//这里会调用触发上一个activity的onStop操作
                }
            }
        }

        //如果有未结束的activity，也会去执行一边触发destroy操作
        // Finish any activities that are scheduled to do so but have been
        // waiting for the next one to start.
        for (int i = 0; i < NF; i++) {
            r = finishes.get(i);
            final ActivityStack stack = r.getStack();
            if (stack != null) {
                activityRemoved |= stack.destroyActivityLocked(r, true, "finish-idle");
            }
        }

        if (!booting) {
            // Complete user switch
            if (startingUsers != null) {
                for (int i = 0; i < startingUsers.size(); i++) {
                    mService.mUserController.finishUserSwitch(startingUsers.get(i));
                }
            }
        }

        mService.trimApplications();
        //dump();
        //mWindowManager.dump();

        if (activityRemoved) {
            resumeFocusedStackTopActivityLocked();
        }

        return r;
    }

启动流程结束------

OK，在看下resume的流程。

 private ActivityRecord getReusableIntentActivity() {
        //FLAG_ACTIVITY_MULTIPLE_TASK对应standard的启动方式，standard/singleTask/singleInstance返回的是true。
        boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
                (mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
                || mLaunchSingleInstance || mLaunchSingleTask;
        
        putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;
        ActivityRecord intentActivity = null;
        if (mOptions != null && mOptions.getLaunchTaskId() != -1) {
            final TaskRecord task = mSupervisor.anyTaskForIdLocked(mOptions.getLaunchTaskId());
            intentActivity = task != null ? task.getTopActivity() : null;
        } else if (putIntoExistingTask) {
            if (mLaunchSingleInstance) {
                //对应的是singleInstance启动方法，独占一个stack
               intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info, false);
            } else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
                
                intentActivity = mSupervisor.findActivityLocked(mIntent, mStartActivity.info,
                        !mLaunchSingleTask);
            } else {
                
                intentActivity = mSupervisor.findTaskLocked(mStartActivity, mSourceDisplayId);
            }
        }
        return intentActivity;
    }

如果走到一个if else分支，则标号就为13、14和13、14、15这样。

1、Activity.startActivityForResult()
2、Instrumentation.execStartActivity(
    this, mMainThread.getApplicationThread(), mToken, this,
    intent, requestCode, options);
3、ActivityManagerService.startActivity(IApplicationThread caller, String callingPackage,Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,int startFlags, ProfilerInfo profilerInfo, Bundle bOptions);
PS：ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
4、ActivityManagerService.startActivityAsUser
5、ActivityStarter.startActivityMayWait
6、ActivityStarter.startActivityLocked
7、ActivityStarter.startActivity
8、ActivityStarter.startActivity
9、ActivityStarter.startActivityUnchecked(控制完整的启动流程的核心逻辑，主要包含下面几个流程)
10、ActivityStarter.getReusableIntentActivity(); 获取栈中是否存在对应的activity，如果存在，一个逻辑，
11、ActivityStarter.setTargetStackAndMoveToFrontIfNeeded(reusedActivity);把已存在的挪到头部
12、

10、ActivityStackSupervisor.resumeFocusedStackTopActivityLocked
11、ActivityStack.resumeTopActivityUncheckedLocked
12、ActivityStack.resumeTopActivityInnerLocked
13、ActivityStackSupervisor.pauseBackStacks(暂停上一个activity,调用处2369行)
14、ActivityStack.startPausingLocked
15、ActivityRecord.ProcessRecord.IApplicationThread.schedulePauseActivity->调用的是ActivityThread.ApplicationThread中的方法
16、ActivityThread.sendMessage发消息通知
17、ActivityThread.handlePauseActivity(H.PAUSE_ACTIVITY)
18、ActivityThread.performPauseActivity
19、ActivityThread.callCallActivityOnSaveInstanceState->Instrumentation.callActivityOnSaveInstanceState->Activity.performSaveInstanceState
20、ActivityThread.performPauseActivityIfNeeded
21、Instrumentation.callActivityOnPause
22、Activity.performPause



13、ActivityStack类2508行，这里的next.app是空的，所以需要走下面的方法创建一个
13、ActivityStackSupervisor.startSpecificActivityLocked
14、ActivityStackSupervisor.realStartActivityLocked
15、ActivityThread.ApplicationThread.scheduleLaunchActivity(app.thread.scheduleLaunchActivity)
16、ActivityThread.sendMessage(H.LAUNCH_ACTIVITY)
17、ActivityThread.handleLaunchActivity
18、ActivityThread.performLaunchActivity
19、Instrumentation.newActivity(反射new一个Activity)
20、Activity.attach
21、Instrumentation.callActivityOnCreate()
22、Activity.performCreate
23、Instrumentation.callActivityOnRestoreInstanceState
24、Activity.performRestoreInstanceState
25、ActivityThread.handleResumeActivity（接上面第18步）
26、Activity.performResume
27、ActivityThread.performPauseActivityIfNeeded()
28、Activity.performPause