ActivityManagerService分析流程

图片部分来自网络。

ActivityManagerService简称AMS， 是Android内核的核心功能之一,在系统启动SystemServer时启动此服务。

 AMS提供的功能主要包括以下几个方面：

   1. 对于Android四大组件（activity、service、broadcast、 content provider）的管理，包括启动，生命周期管理等

   2. 进程OOM adj以及LRU weight管理

首先将ActivityManagerService注册到ServiceManager中，其次将几个与系统性能调试相关的服务注册到ServiceManager。

查询并处理ApplicationInfo。首先调用PackageManagerService的接口，查询包名为android的应用程序的ApplicationInfo信息，对应于framework-res.apk。然后以该信息为参数调用ActivityThread上的installSystemApplicationInfo方法。

创建并处理ProcessRecord。调用ActivityManagerService上的newProcessRecordLocked，创建一个ProcessRecord类型的对象，并保存该对象的信息。

 SystemReady介绍

发送处理ACTION_PRE_BOOT_COMPLETED广播

清理提前启动的非persistent进程

读取Settings配置

调用goingCallback的run函数启动SystemUI，执行其他系统服务的systemReady方法，启动软件Watchdog。

启动persistent应用和Home应用，发送ACTION_BOOT_COMPLETED广播。

 

 

窗口切换过程中要解决的问题可以分为三类：

s 状态同步：AMS、WMS、InputManager状态的同步

Actvity启动时，Ams创建ActivityRecord对象，同时Wms也创建AppWindowToken对象；销毁Activity时也会删除AppWindowToken。Wms中包含InputManager对象，窗口的添加或删除，会同步到InputManager。

s 屏幕绘制：窗口切换动画和目标窗口显示。

指窗口进入、退出动画及动画结束后目标窗口的显示。

s 消息处理。

AMS创建了ActivityRecord对象后，同时会通知Wms创建AppWindowToken对象，AppWindowToken在Wms代表Activity。

Android OS中的Zygote进程的IPC采用的是Socket（套接字）机制，Android中的Kill Process采用的signal（信号）机制等等。而Binder更多则用在system_server进程与上层App层的IPC交互。

·  Java framework：作为Server端继承(或间接继承)于Binder类，Client端继承(或间接继承)于BinderProxy类。例如 ActivityManagerService(用于控制Activity、Service、进程等) 这个服务作为Server端，间接继承Binder类，而相应的ActivityManager作为Client端，间接继承于BinderProxy类。 当然还有PackageManagerService、WindowManagerService等等很多系统服务都是采用C/S架构；

·  Native Framework层：这是C++层，作为Server端继承(或间接继承)于BBinder类，Client端继承(或间接继承)于BpBinder。例如MediaPlayService(用于多媒体相关)作为Server端，继承于BBinder类，而相应的MediaPlay作为Client端，间接继承于BpBinder类。

 

应用进程与系统进程的通信

Activity的启动流程，不用关心在AMS里面这里跳到那里是干什么，还有ActivityStack以及它的那个SuperXX跳来跳去是在搞毛，需要了解的是：在Context里面，通过AMS的Client ActivityManagerNative发起Binder调用进入system_server进程，在AMS里面绕了一圈（处理Activity栈以及生命周期相关），然后通过IApplicationThread这个Binder调用回到App进程的Binder线程池，在线程池里面通过Handler发送Message到App主线程，最终通过ClassLoader加载Activity类，创建对象，回调对应的生命周期，整个过程结束。

 

· IApplicationThread: 作为系统进程请求应用进程的接口;

· IActivityManager: 作为应用进程请求系统进程的接口。

· 

 

* System private API for communicating with the application.  This is given to

 * the activity manager by an application  when it starts up, for the activity

 * manager to tell the application about things it needs to do.

frameworks/base/core/java/android/app/IApplicationThread.aidl 

 

 

在应用进程一侧：

最上层的有IApplicationThread的接口定义，

往下一层，同样有“代理(Proxy)”和“桩(Stub)”，连类名都如出一辙;

再下一层，具体业务的实现类是ApplicationThread是ActivityThread的一个内部类，ApplicationThread负责响应系统进程发起的请求，这些请求大部分都是需要调度在应用进程的主线程执行，而ActivityThread是应用进程的主线程，通过Handle往主线程抛消息，ApplicationThread就轻松将具体执行任务的工作转交给了主线程。

“代理(Proxy)”和“桩(Stub)”是Binder接口实现时成对出现的概念。可以对应到一个生活中的例子：银行的取款机就像是银行的业务代理(Proxy)，客户只需要通过取款机，就能方便地完成存、取款等业务。对于客户来说，银行实际是什么样子，钱存在哪，都不重要了，只要有取款机在就够了。对于取款机这个代理而言，它需要连接银行的服务器(Stub)，完成数据传递。

上面的类图中，用两种不同的颜色对类进行了区分。除了Binder的标准实现，还示意了几个不同的类依赖关系：

· ProcessRecord类和ActivityRecord类的对象是运行在系统进程之中，它们都由AMS管理;

· ProcessRecord依赖于客户端进程中的ApplicationThread对象，而客户端进程中的Activity依赖于ActivityRecord。

这种依赖关系的构建，是在启动一个全新的Activity时，利用IActivityManager和IApplicationThread完成了数据绑定操作。绑定成功以后，相当于应用进程和系统进程相互打了个招呼，知道了彼此的存在，后续就可以进行更加深入友好的交流。

https://blog.csdn.net/ccjhdopc/article/details/72551767

 

系统进程维护的是ActivityRecord，应用进程维护的是Activity，两者之间的映射关系就是利用Token来维系的。应用进程的Activity在创建的时候，就被赋予了一个Token，拿着这个Token就能完成后续与系统进程的通信。在发生Activity切换时，应用进程会将上一个Activity的Token(AMS.startActivity()的输入参数resultTo)传递给系统进程，系统进程会根据这个Token找到ActivityRecord，对其完成调度后，再通知应用进程：Activity状态发生了变化。

Token就像一个令牌，揣着这个令牌，就是游走江湖的身份象征。Activity出生的时候，管理者(AMS)就会登记Activity的真实身份(ActivityRecord)，并颁发一个令牌(Token)给Activity。以后这个Activity要有什么行为，都要交出令牌，让管理者核实一下真实身份。

 

 

窗口切换过程中要解决的问题可以分为三类：

 

 

s 状态同步：AMS、WMS、InputManager状态的同步

Actvity启动时，Ams创建ActivityRecord对象，同时Wms也创建AppWindowToken对象；销毁Activity时也会删除AppWindowToken。Wms中包含InputManager对象，窗口的添加或删除，会同步到InputManager。

s 屏幕绘制：窗口切换动画和目标窗口显示。

指窗口进入、退出动画及动画结束后目标窗口的显示。

s 消息处理。

AMS创建了ActivityRecord对象后，同时会通知Wms创建AppWindowToken对象，AppWindowToken在Wms代表Activity。

 

Activity启动流程

 

 

 

1. 点击桌面App图标，Launcher进程采用Binder IPC向system_server进程发起startActivity请求；

2. system_server进程接收到请求后，向zygote进程发送创建进程的请求；

3. Zygote进程fork出新的子进程，即App进程；

4. App进程，通过Binder IPC向sytem_server进程发起attachApplication请求；

5. system_server进程在收到请求后，进行一系列准备工作后，再通过binder IPC向App进程发送scheduleLaunchActivity请求；

6. App进程的binder线程（ApplicationThread）在收到请求后，通过handler向主线程发送LAUNCH_ACTIVITY消息；

7. 主线程在收到Message后，通过发射机制创建目标Activity，并回调Activity.onCreate()等方法。

 

Activity启动发起后，通过Binder最终交由system进程中的AMS来完成，则启动流程如下图

 

 

 

ActivityManagerService调用关系

 

 

ActivityRecord,TaskRecord,ActivityStack关系

 

ActivityRecord：Activity记录对象

TaskRecord：应用Activity记录任务栈

其中包含了

/** List of all activities in the task arranged in history order */

final ArrayList<ActivityRecord> mActivities;

/** Current stack. Setter must always be used to update the value. */

private ActivityStack mStack;



ActivityStack：管理TaskRecord

/**

 * The back history of all previous (and possibly still

 * running) activities.  It contains #TaskRecord objects.

 */

private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();

/**

* List of running activities, sorted by recent usage.

* The first entry in the list is the least recently used.

* It contains HistoryRecord objects.

*/

 final ArrayList<ActivityRecord> mLRUActivities = new ArrayList<>();

ActivityStack从名称来看是跟栈相关的类，其实它是一个管理类，用来管理系统所有Activity的各种状态。它由ActivityStackSupervisor来进行管理的，而ActivityStackSupervisor在AMS中的构造方法中被创建。 

ActivityStackSupervisor中有多种ActivityStack实例。

ActivityStack中通过枚举存储了Activity的所有的状态，

 

在配置文件AndroidManifest.xml文件中，process属性的默认值是package的名称，每一个应用程序都一个uid，uid和process组合起来就可以为每一个应用程序创建一个ProcessRecord.

 

一般地，对于没有分屏功能以及虚拟屏的情况下，ActivityStackSupervisor与ActivityDisplay都是系统唯一；

ActivityDisplay主要有Home Stack和App Stack这两个栈；

每个ActivityStack中可以有若干个TaskRecord对象；

每个TaskRecord包含若干个ActivityRecord对象；

在ActivityStack中
    /**
     * The back history of all previous (and possibly still
     * running) activities.  It contains #TaskRecord objects.
     */
    private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();

    final ActivityRecord topActivity() {
        for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
            ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;          
            for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
                final ActivityRecord r = activities.get(activityNdx);
                if (!r.finishing) {
                    return r;
                }
            }
        }
        return null;
    }

每个ActivityRecord记录一个Activity信息。

每一个ActivityRecord都会有一个Activity与之对应，一个Activity可能会有多个ActivityRecord，因为Activity可以被多次实例化，取决于其launchmode。一系列相关的ActivityRecord组成了一个TaskRecord，TaskRecord是存在于ActivityStack中，ActivityStackSupervisor是用来管理这些ActivityStack的。

ActivityStack并不是开机就创建的，而是在需要时才创建

 

以O代码为例一个应用的启动流程

App.startActivity()-->

Activity.startActivityForResult() ->  

Instrumentation.execStartActivity() ->

ActivityManager.getService().startActivity(..)-->

ActivityManagerService.startActivity()-->

ActivityManagerService.startActivityAsUser()-->

ActivityStackSupervisor是APP的栈的管理类，管理四大组件的栈的问题。而ActivityStarter就是每一个被管理的任务栈。分Task任务来管理，一个任务里面可能多个栈，别说当前正在使用、已停止的栈、历史栈。
ActivityStackSupervisor里面记录了一大堆Activity的记录

ActivityStarter类主要负责处理Activity的Intent和Flags, 还有关联相关的Stack和TaskRecord

ActivityStarter封装了一个activity启动的过程（包括上下文环境)

此时从ActivityManagerService跳转进入ActivityStarter中继续执行：

ActivityStarter.startActivityMayWait() -->获取Activity的启动信息，包括ResolveInfo和ActivityInfo，以及获取CallingPid和CallingUid

ActivityStarter.startActivityLocked() -->

ActivityStarter.startActivity() -->创建一个ActivityRecord

.....       
      ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
                callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
                resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
                mSupervisor, options, sourceRecord);
...
..
        return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true,
                options, inTask, outActivity);
 

而在ActivityRecord.java中创建一个Token

 

    ActivityRecord(ActivityManagerService _service, ProcessRecord _caller, int _launchedFromPid,
            int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
            ActivityInfo aInfo, Configuration _configuration,
            ActivityRecord _resultTo, String _resultWho, int _reqCode,
            boolean _componentSpecified, boolean _rootVoiceInteraction,
            ActivityStackSupervisor supervisor, ActivityOptions options,
            ActivityRecord sourceRecord) {
        service = _service;
        appToken = new Token(this);
        info = aInfo;
        ...
        ...
        ...
  }
同时Token是ActivityRecord的一个内部类
static class Token extends IApplicationToken.Stub {
        private final WeakReference<ActivityRecord> weakActivity;

        Token(ActivityRecord activity) {
            weakActivity = new WeakReference<>(activity);
        }
        private static ActivityRecord tokenToActivityRecordLocked(Token token) {
            if (token == null) {
                return null;
            }
            ActivityRecord r = token.weakActivity.get();
            if (r == null || r.getStack() == null) {
                return null;
            }
            return r;
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder(128);
            sb.append("Token{");
            sb.append(Integer.toHexString(System.identityHashCode(this)));
            sb.append(' ');
            sb.append(weakActivity.get());
            sb.append('}');
            return sb.toString();
        }
    }

ActivityStarter.startActivity()参数方法不同-->

ActivityStarter.startActivityUnchecked() --->设置TaskRecord, 完成后执行ActivityStackSupervisor类的resumeFocusedStackTopActivityLocked方法

在ActivityStarter.java中
   
    private ActivityStack mSourceStack;
    private ActivityStack mTargetStack;
 
   // Note: This method should only be called from {@link startActivity}.
    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity) {

....
.....
        mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,mOptions);
        if (mDoResume) {
            final ActivityRecord topTaskActivity =
                    mStartActivity.getTask().topRunningActivityLocked();
            if (!mTargetStack.isFocusable()
                    || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                    && mStartActivity != topTaskActivity)) {
                // If the activity is not focusable, we can't resume it, but still would like to
                // make sure it becomes visible as it starts (this will also trigger entry
                // animation). An example of this are PIP activities.
                // Also, we don't want to resume activities in a task that currently has an overlay
                // as the starting activity just needs to be in the visible paused state until the
                // over is removed.
                mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
                // Go ahead and tell window manager to execute app transition for this activity
                // since the app transition will not be triggered through the resume channel.
                mWindowManager.executeAppTransition();
            } else {
                // If the target stack was not previously focusable (previous top running activity
                // on that stack was not visible) then any prior calls to move the stack to the
                // will not update the focused stack.  If starting the new activity now allows the
                // task stack to be focusable, then ensure that we now update the focused stack
                // accordingly.
                if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                    mTargetStack.moveToFront("startActivityUnchecked");
                }
                mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                        mOptions);
        } else {
            mTargetStack.addRecentActivityLocked(mStartActivity);
        }
        mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack);
        mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredLaunchStackId,
                preferredLaunchDisplayId, mTargetStack.mStackId);

        return START_SUCCESS;
    }

        在如上的

                mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition,mOptions);

ActivityStatck的startActivityLocked中调用ActivityRecord.createWindowContainer创建new AppWindowContainerController

/**
 * Controller for the app window token container. This is created by activity manager to link
 * activity records to the app window token container they use in window manager.
 *
 * Test class: {@link AppWindowContainerControllerTests}
 */
public class AppWindowContainerController
        extends WindowContainerController<AppWindowToken, AppWindowContainerListener> {
...
...
    public AppWindowContainerController(TaskWindowContainerController taskController,
            IApplicationToken token, AppWindowContainerListener listener, int index,
            int requestedOrientation, boolean fullscreen, boolean showForAllUsers, int configChanges,
            boolean voiceInteraction, boolean launchTaskBehind, boolean alwaysFocusable,
            int targetSdkVersion, int rotationAnimationHint, long inputDispatchingTimeoutNanos,
            Configuration overrideConfig, Rect bounds) {
        this(taskController, token, listener, index, requestedOrientation, fullscreen,
                showForAllUsers,
                configChanges, voiceInteraction, launchTaskBehind, alwaysFocusable,
                targetSdkVersion, rotationAnimationHint, inputDispatchingTimeoutNanos,
                WindowManagerService.getInstance(), overrideConfig, bounds);
    }
...
...

}

而在AppWindowContainerController的构造函数中实例化AppWindowToken 

 AppWindowToken atoken = mRoot.getAppWindowToken(mToken.asBinder());
            final Task task = taskController.mContainer;
            if (task == null) {
                throw new IllegalArgumentException("AppWindowContainerController: invalid "
                        + " controller=" + taskController);
            }
            atoken = createAppWindow(mService, token, voiceInteraction, task.getDisplayContent(),
                    inputDispatchingTimeoutNanos, fullscreen, showForAllUsers, targetSdkVersion,
                    requestedOrientation, rotationAnimationHint, configChanges, launchTaskBehind,
                    alwaysFocusable, this, overrideConfig, bounds);

    AppWindowToken 

/**
 * Version of WindowToken that is specifically for a particular application (or
 * really activity) that is displaying windows.
 */
public class AppWindowToken extends WindowToken implements WindowManagerService.AppFreezeListener {
...
...
    AppWindowToken(WindowManagerService service, IApplicationToken token, boolean voiceInteraction,
            DisplayContent dc, long inputDispatchingTimeoutNanos, boolean fullscreen,
            boolean showForAllUsers, int targetSdk, int orientation, int rotationAnimationHint,
            int configChanges, boolean launchTaskBehind, boolean alwaysFocusable,
            AppWindowContainerController controller, Configuration overrideConfig, Rect bounds) {
        this(service, token, voiceInteraction, dc, fullscreen, overrideConfig, bounds);
        setController(controller);
        mInputDispatchingTimeoutNanos = inputDispatchingTimeoutNanos;
        mShowForAllUsers = showForAllUsers;
        mTargetSdk = targetSdk;
        mOrientation = orientation;
        layoutConfigChanges = (configChanges & (CONFIG_SCREEN_SIZE | CONFIG_ORIENTATION)) != 0;
        mLaunchTaskBehind = launchTaskBehind;
        mAlwaysFocusable = alwaysFocusable;
        mRotationAnimationHint = rotationAnimationHint;

        // Application tokens start out hidden.
        hidden = true;
        hiddenRequested = true;
    }
...
...

}

ActivityStackSupervisor.resumeFocusedStackTopActivityLocked --->

    boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
...
...
        if (targetStack != null && isFocusedStack(targetStack)) {
            return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
        }
        final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
        if (r == null || r.state != RESUMED) {
            mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
        } else if (r.state == RESUMED) {
            // Kick off any lingering app transitions form the MoveTaskToFront operation.
            mFocusedStack.executeAppTransition(targetOptions);
        }
 
        return false;
 
}

ActivityStack.resumeTopActivityUncheckedLocked--->

    /**
     * Ensure that the top activity in the stack is resumed.
     *
     * @param prev The previously resumed activity, for when in the process
     * of pausing; can be null to call from elsewhere.
     * @param options Activity options.
     *
     * @return Returns true if something is being resumed, or false if
     * nothing happened.
     *
     * NOTE: It is not safe to call this method directly as it can cause an activity in a
     *       non-focused stack to be resumed.
     *       non-focused stack to be resumed.
     *       Use {@link ActivityStackSupervisor#resumeFocusedStackTopActivityLocked} to resume the
     *       right activity for the current system state.
     */
    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
        if (mStackSupervisor.inResumeTopActivity) {
            // Don't even start recursing.
            return false;
        }
        boolean result = false;
        try {
            // Protect against recursion.
            mStackSupervisor.inResumeTopActivity = true;
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        ....
        return result;
    }

ActivityStack.resumeTopActivityInnerLocked---->该进程已经存在执行scheduleResumeActivity，不存在则新创建startSpecificActivityLocked

    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
 
...
...
        // Find the next top-most activity to resume in this stack that is not finishing and is
        // focusable. If it is not focusable, we will fall into the case below to resume the
        // top activity in the next focusable task.
        final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
...
...
        ActivityStack lastStack = mStackSupervisor.getLastStack();
        if (next.app != null && next.app.thread != null) {
                    ....
                    ....
                    next.app.pendingUiClean = true;
                    next.app.forceProcessStateUpTo(mService.mTopProcessState);
                    next.clearOptionsLocked();
                    next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,
                            mService.isNextTransitionForward(), resumeAnimOptions);
                    .....
 
        }else{
            ....
            mStackSupervisor.startSpecificActivityLocked(next, true, true);
            ....
        }
...
}

 

ActivityStackSupervisor.startSpecificActivityLocked--->

    void startSpecificActivityLocked(ActivityRecord r,
            boolean andResume, boolean checkConfig) {
        // Is this activity's application already running?
        ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                r.info.applicationInfo.uid, true);

        r.getStack().setLaunchTime(r);
        if (app != null && app.thread != null) {
            try {
                if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                        || !"android".equals(r.info.packageName)) {
                    // Don't add this if it is a platform component that is marked
                    // to run in multiple processes, because this is actually
                    // part of the framework so doesn't make sense to track as a
                    // separate apk in the process.
                    app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
                            mService.mProcessStats);
                }
                realStartActivityLocked(r, app, 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.
        }

        mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
                "activity", r.intent.getComponent(), false, false, true);
    }

这里会判断进程是否存在，由于我们是在原有进程中启动一个新的activity，所以会调用 realStartActivityLocked()方法。

ActivityStackSupervisor.realStartActivityLocked()

    final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
 
...
...
        final TaskRecord task = r.getTask();
        final ActivityStack stack = task.getStack();
...
...
                app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                        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, !andResume,
                        mService.isNextTransitionForward(), profilerInfo);
...
....
 
   }

 public IApplicationThread thread;  // the actual proc...  may be null only if
                                // 'persistent' is true (in which case we
                                // are in the process of launching the app)

ActivityThread.scheduleLaunchActivity()

        // we use token to identify this activity without having to send the
        // activity itself back to the activity manager. (matters more with ipc)
        @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.overrideConfig = overrideConfig;
            updatePendingConfiguration(curConfig);

            sendMessage(H.LAUNCH_ACTIVITY, r);
}

sendMessage，最后调用到mH.sendMessage(msg);
mH为H类的一个实例，H就是Handler的一个子类，发送消息之后，查看H类的handleMessage()方法

                case LAUNCH_ACTIVITY: {
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                } break;

继续执行ActivityThread.handleLaunchActivity

    private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
...
...
       Activity a = performLaunchActivity(r, customIntent);
...
...
       if (a != null) {
            ....
            handleResumeActivity(r.token, false, r.isForward,
                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
...
             if (!r.activity.mFinished && r.startsNotResumed) {
 
                performPauseActivityIfNeeded(r, reason);
             }
            .....
       }else{
            // If there was an error, for any reason, tell the activity manager to stop us.
            try {
                ActivityManager.getService()
                    .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
 
       }
...
...
}

ActivityThread.performLaunchActivity 这里会收集要启动的Activity的相关信息，主要是package和component信息，然后通过ClassLoader将要启动的Activity类加载出来。

    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
   ....
....
        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }
        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }
....
        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }
...
        ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
...
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
...
...
        if (activity != null) {
....
 
                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 (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
...
...
                r.activity = activity;
                r.stopped = true;
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
...
...
 
 
        }
...
...
    }

Instrumentation.newActivity--->新的Activity类是通过类加载器方式即通过反射的方式生成的

    /**
     * Perform instantiation of the process's {@link Activity} object.  The
     * default implementation provides the normal system behavior.
     * 
     * @param cl The ClassLoader with which to instantiate the object.
     * @param className The name of the class implementing the Activity
     *                  object.
     * @param intent The Intent object that specified the activity class being
     *               instantiated.
     * 
     * @return The newly instantiated Activity object.
     */
    public Activity newActivity(ClassLoader cl, String className,
            Intent intent)
            throws InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        return (Activity)cl.loadClass(className).newInstance();
    }

Instrumentation.callActivityOnCreate--->

    final void performCreate(Bundle icicle) {
        performCreate(icicle, null);
    }

    /**
     * Perform calling of an activity's {@link Activity#onCreate}
     * method.  The default implementation simply calls through to that method.
     * @param activity The activity being created.
     * @param icicle The previously frozen state (or null) to pass through to onCreate().
     */
    public void callActivityOnCreate(Activity activity, Bundle icicle) {
        prePerformCreate(activity);
        activity.performCreate(icicle);
        postPerformCreate(activity);
    }

Activity.performCreate -->

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
...
...
        if (persistentState != null) {
            onCreate(icicle, persistentState);
        } else {
            onCreate(icicle);
        }
...
...
 
}

ActivityManagerService中ActivityStackSupervisor，ActivityStack与ActivityRecord关系

ActivityStack stack = mStackSupervisor.getFocusedStack();
if (stack != null) {
    ActivityRecord topActivityRecord = stack.topActivity();
     if (topActivityRecord != null) {...

    }

}

具体调用流程：

1.App.startActivity()-->

2.Activity.startActivityForResult() ->  

3.Instrumentation.execStartActivity() ->

4.ActivityManager.getService().startActivity(..)-->

5.ActivityManagerService.startActivity()-->

6.ActivityManagerService.startActivityAsUser()-->

7.ActivityStarter.startActivityMayWait() -->获取Activity的启动信息，包括ResolveInfo和ActivityInfo，以及获取CallingPid和CallingUid

8.ActivityStarter.startActivityLocked() -->

9.ActivityStarter.startActivity() -->创建一个ActivityRecord，而ActivityRecord中创建Token

10.ActivityStarter.startActivity()-->构造参数不与上不同

11.ActivityStarter.startActivityUnchecked() --->设置TaskRecord, 完成后执行ActivityStackSupervisor类，里面还包括实例化AppWindowToken （ActivityStatck的startActivityLocked中调用ActivityRecord.createWindowContainer创建new AppWindowContainerController,而在AppWindowContainerController的构造函数中实例化AppWindowToken ）

12.ActivityStackSupervisor.resumeFocusedStackTopActivityLocked --->

13.ActivityStack.resumeTopActivityUncheckedLocked--->

14.ActivityStack.resumeTopActivityInnerLocked---->该进程已经存在执行scheduleResumeActivity，不存在则新创建

15.ActivityStackSupervisor.startSpecificActivityLocked--->这里会判断进程是否存在，由于我们是在原有进程中启动一个新的activity，所以会调用 realStartActivityLocked()方法。
16.ActivityStackSupervisor.realStartActivityLocked()-->

public IApplicationThread thread;  // the actual proc...  may be null only if
                                // 'persistent' is true (in which case we
                                // are in the process of launching the app)

17.ActivityThread.scheduleLaunchActivity()--->实例化一个ActivityClientRecord r；然后 r.token = token;从这个流程中可以知道Activity.mToken保存的是AMS侧对应的ActivityRecord.appToken的Binder代理对象

18.ActivityThread.handleLaunchActivity() -->

19.ActivityThread.performLaunchActivity()---> 这里会收集要启动的Activity的相关信息，主要是package和component信息，然后通过ClassLoader将要启动的Activity类加载出来，并且创建了Activity，之后执行了Activity.attch方法。

20.Instrumentation.callActivityOnCreate--->

21.Activity.performCreate -->

22.Activity.onCreate()