Activity.startActivity()分析：本地进程部分

    public void startActivity(Intent intent, Bundle options) {
        if (options != null) {
            startActivityForResult(intent, -1, options);
        } else {
            // Note we want to go through this call for compatibility with
            // applications that may have overridden the method.
            startActivityForResult(intent, -1);
        }
    }

这个方法多了一个int型的参数，这个参数其实是一个返回值，如果这个值大于0，则这个值会在此Activity退出时返回给调用他的Activity。当直接startActivity()时，这个值是-1，所以默认是不会返回的。

     public void startActivityForResult(Intent intent, int requestCode, Bundle options) {
        if (mParent == null) {
            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());
            }
            if (requestCode >= 0) {
                // If this start is requesting a result, we can avoid making
                // the activity visible until the result is received.  Setting
                // this code during onCreate(Bundle savedInstanceState) or onResume() will keep the
                // activity hidden during this time, to avoid flickering.
                // This can only be done when a result is requested because
                // that guarantees we will get information back when the
                // activity is finished, no matter what happens to it.
                mStartedActivity = true;
            }
        } else {
            if (options != null) {
                mParent.startActivityFromChild(this, intent, requestCode, options);
            } else {
                // Note we want to go through this method for compatibility with
                // existing applications that may have overridden it.
                mParent.startActivityFromChild(this, intent, requestCode);
            }
        }
    }

这个方法根据mParent是否为空来进行分支处理。这个变量声明为Activity mParent，他也是一个Activity,这个变量在Activity本地创建时会被赋值，具体是在Activity在attach的时候会被赋值。

final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config) {
        attachBaseContext(context);

        mFragments.attachActivity(this);
        
        mWindow = PolicyManager.makeNewWindow(this);<span style="white-space:pre">		</span>//这里申请一个surface
        mWindow.setCallback(this);
        mWindow.getLayoutInflater().setPrivateFactory(this);
        ...
        mParent = parent;
        ...
    }

这个方法attach()是在ActivityThread-->handleLaunchActivity-->performLaunchActivity中调用的，调用activity.attach(..., r.parent,...);这个r为一个ActivityClientRecord对象，是一个ActivityRecord的本地对象。mParent赋值具体原则是如果新建的Activity是ActivityTask的根Activity,则mParent为null,否则为ActivityTask的根Activity

如果mParent不为空，则调用startActivityFromChild()方法，否则调用mInstrumentation.execStartActivity(...);方法；而startActivityFromChild(..)方法的实现也是调用了mInstrumentation.execStartActivity(...)方法

    public void startActivityFromChild(Activity child, Intent intent, 
            int requestCode, Bundle 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());
        }
    }

 即startActivity方法最终都会调用mInstrumentation.execStartActivity(...)方法，最终调用AMS启动新的Activity的操作也是在这个方法中执行的。

/framework/base/core/java/android/app/Activity.java

/**
 * Base class for implementing application instrumentation code.  When running
 * with instrumentation turned on, this class will be instantiated for you
 * before any of the application code, allowing you to monitor all of the
 * interaction the system has with the application.  An Instrumentation
 * implementation is described to the system through an AndroidManifest.xml's
 * <instrumentation> tag.
 */
public class Instrumentation

这个类的对象会在Application之前创建对象，用于监督系统和Application直接的交互。

     public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        IApplicationThread whoThread = (IApplicationThread) contextThread;
        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    if (am.match(who, null, intent)) {
                        am.mHits++;
                        if (am.isBlocking()) {
                            return requestCode >= 0 ? am.getResult() : null;
                        }
                        break;
                    }
                }
            }
        }
        try {
            intent.migrateExtraStreamToClipData();
            intent.prepareToLeaveProcess();
            int result = ActivityManagerNative.getDefault()
                .startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, null, options);
            checkStartActivityResult(result, intent);
        } catch (RemoteException e) {
        }
        return null;
    }

可以知道他调用的是ActivityManagerNative里的startActivity方法。ActivityManagerNative是ActivityManagerService的本地代理类，由他代理和AMS之间的跨进程交互。这个类里面有很多的callActivityOnXx的方法，对应Activity的OnCreate等方法，即Activity的生命周期方法是在这个类里面调用的。ActivityManagerNative.startActivity方法会将调用者的进程信息，目标Activity的信息传递给AMS，一遍AMS去真正启动一个Activity组件。

2.4 ActivityManagerNative