Activity生命周期的回调，你应该知道得很多其它！--Android源代码剖析（下）

 
      转载请标明原文地址：http://blog.csdn.net/yalinfendou/article/details/46910811【yalinfendou的博客】

 
      接着上一篇继续去追踪Activity_B生命周期回调源代码。

 
      继续分析，在performPauseActivity方法中，回调了Activity的两个操作函数：

        一
个是用于保存状态的onSaveInstanceState()，还有一个就是onPause() 
，这里你应该了解onPause和onSaveInstanceState的调用顺序了,这里看来OnSaveInstanceState是先于onPause的调用的，可是打印的Log显示onSaveInstanceState在onPause之后，在onStop之前调用（不明确）。

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="">

 
      最后r.state置为true。

 
      当 AmS通知当前Activity暂停后,AmS会马上返回,而在目标进程中则是发送一个暂停的消息，处理完该暂停消息后，目标进程会调用AmS的 activityPaused(),报 告 AMS自己已经暂停完成，然后运行ActivityManagerNative.getDefault().activityPaused(token)

从而AMS将開始启动真正的Activity。

 
      前面说过。ActivityManagerNative.getDefault().activityPaused的动作运行者是ActivityManagerService.activityPaused

        ActivityManagerService.class

    public final void activityPaused(IBinder token) {
        final long origId = Binder.clearCallingIdentity();
        synchronized(this) {
            ActivityStack stack = ActivityRecord.getStackLocked(token);
            if (stack != null) {
                stack.activityPausedLocked(token, false);
            }
        }
        Binder.restoreCallingIdentity(origId);
    }

ActivityStack.class

 final void activityPausedLocked(IBinder token, boolean timeout) {
        if (DEBUG_PAUSE) Slog.v(
            TAG, "Activity paused: token=" + token + ", timeout=" + timeout);

        final ActivityRecord r = isInStackLocked(token);
        if (r != null) {
            mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
            if (mPausingActivity == r) {
                if (DEBUG_STATES) Slog.v(TAG, "Moving to PAUSED: " + r
                        + (timeout ?

" (due to timeout)" : " (pause complete)"));
                completePauseLocked(true);
            } else {
                EventLog.writeEvent(EventLogTags.AM_FAILED_TO_PAUSE,
                        r.userId, System.identityHashCode(r), r.shortComponentName,
                        mPausingActivity != null
                            ? mPausingActivity.shortComponentName : "(none)");
            }
        }
    }

ActivityStack.class

        private void completePauseLocked(boolean resumeNext) {
            ActivityRecord prev = mPausingActivity;
            if (DEBUG_PAUSE) Slog.v(TAG, "Complete pause: " + prev);

            if (prev != null) {
            	//...
            }

            if (resumeNext) {
                final ActivityStack topStack = mStackSupervisor.getFocusedStack();
                if (!mService.isSleepingOrShuttingDown()) {
                    mStackSupervisor.resumeTopActivitiesLocked(topStack, prev, null);
                } else {
                    mStackSupervisor.checkReadyForSleepLocked();
                    ActivityRecord top = topStack.topRunningActivityLocked(null);
                    if (top == null || (prev != null && top != prev)) {
                        // If there are no more activities available to run,
                        // do resume anyway to start something.  Also if the top
                        // activity on the stack is not the just paused activity,
                        // we need to go ahead and resume it to ensure we complete
                        // an in-flight app switch.
                        mStackSupervisor.resumeTopActivitiesLocked(topStack, null, null);
                    }
                }
            }

            if (prev != null) {
            	//...
            }

            // Notfiy when the task stack has changed
            mService.notifyTaskStackChangedLocked();
        }

ActivityStackSupervisor.class

 boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,
                Bundle targetOptions) {
            if (targetStack == null) {
                targetStack = getFocusedStack();
            }
            // Do targetStack first.
            boolean result = false;
            if (isFrontStack(targetStack)) {
                result = targetStack.resumeTopActivityLocked(target, targetOptions);
            }
            for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
                final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
                for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
                    final ActivityStack stack = stacks.get(stackNdx);
                    if (stack == targetStack) {
                        // Already started above.
                        continue;
                    }
                    if (isFrontStack(stack)) {
                   //调用 ActivityStack.resumeTopActivityLocked(null)方法正式启动目标Activity
                        stack.resumeTopActivityLocked(null);
                    }
                }
            }
            return result;
        }  

ActivityStack.class

 final boolean resumeTopActivityLocked(ActivityRecord prev) {
        return resumeTopActivityLocked(prev, null);
    }

    final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {
        if (mStackSupervisor.inResumeTopActivity) {
            // Don't even start recursing.
            return false;
        }

        boolean result = false;
        try {
            // Protect against recursion.
            mStackSupervisor.inResumeTopActivity = true;
            if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {
                mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;
                mService.updateSleepIfNeededLocked();
            }
            result = resumeTopActivityInnerLocked(prev, options);
        } finally {
            mStackSupervisor.inResumeTopActivity = false;
        }
        return result;
    }

ActivityStack.class

        final boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
            if (ActivityManagerService.DEBUG_LOCKSCREEN) mService.logLockScreen("");
            //...
            if (next == null) {
            	//...
            }

            // If the top activity is the resumed one, nothing to do.
            if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
                        mStackSupervisor.allResumedActivitiesComplete()) {
            	//...
            }

            final TaskRecord nextTask = next.task;
            if (prevTask != null && prevTask.stack == this &&
                    prevTask.isOverHomeStack() && prev.finishing && prev.frontOfTask) {
            	//...
            }
          //...
            ActivityStack lastStack = mStackSupervisor.getLastStack();
            if (next.app != null && next.app.thread != null) {
            	//...

            } else {
                // Whoops, need to restart this activity!
                if (!next.hasBeenLaunched) {
                    next.hasBeenLaunched = true;
                } else {
                	//...
                }
                if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Restarting " + next);
                mStackSupervisor.startSpecificActivityLocked(next, true, true);
            }

            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
            return true;
        } 

假设上面不能直接resume已有的Activity对象。那么接下来就要推断目标Activity相应的进程是否存在。

        ActivityStackSupervisor.class

 void startSpecificActivityLocked(ActivityRecord r,
                boolean andResume, boolean checkConfig) {
            // Is this activity's application already running?
        	////获取目标Activity相应的进程对象ProcessRecord app
            ProcessRecord app = mService.getProcessRecordLocked(r.processName,
                    r.info.applicationInfo.uid, true);

            r.task.stack.setLaunchTime(r);
            //假设目标Activity所在的app进程已经开启，比方说直接从Activity_A打开Activity_B
            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了
                    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.
            }
          //假设目标Activity所在的app进程还未开启，假设是从Launcher启动一个新的APP，则会调用此句（不会运行上面的if）
            mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
                    "activity", r.intent.getComponent(), false, false, true);
        }

Activity_A打开Activity_B会运行if (app != null && app.thread != null) 中的realStartActivityLocked(r,
app, andResume, checkConfig)，由于已经目标Activity相应的进程已经开启了，事实上启动目标进程之后（mService.startProcessLocked）。还是会调用realStartActivityLocked，这里也顺便去看一看是怎么启动目标进程的。

 
      追踪ActivityManagerService.startProcessLocked，发现它会一步一步调用其重载函数（不贴代码了），最后调用关键的

Process.start(entryPoint,

                    app.processName, uid, uid, gids, debugFlags, mountExternal,

                    app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,

                    app.info.dataDir, entryPointArgs);

 
      通过Process.start启动一个新的应用进程，而且应用进程会从ActivityThread类 的 main()方法中開始运行。转了一圈，又回到了ActivityThread（上面说过：ActivityThread，该类为应用程序的主线程类，全部的APK程序都有且仅有一个ActivityThread类 ，程序的入口为该类中的static
main()函数）。

 
      ActivityThread.class

        public static void main(String[] args) {
            SamplingProfilerIntegration.start();
            Looper.prepareMainLooper();
            ActivityThread thread = new ActivityThread();
            thread.attach(false);
    		//...
    		 Looper.loop();
    		//...
    		}

调用prepareMainLooper()在 U I线程创建一个消息队列(MessageQueue)。Looper.loop()让消息循环。

 
      H (Handler)和ApplicationThread则是在ActivityThread的初始化的时候创建的

    final ApplicationThread mAppThread = new ApplicationThread();
    final Looper mLooper = Looper.myLooper();
    final H mH = new H();

前面说过，ApplicationThread它是一个Binder对象，负责接收远程AmS的 IPC 调用，接收到调用后。则通
过Handler把消息发送到消息队列，U I主线程会异步地从消息队列中取出消息并运行对应操作。比方
start、 stop、pause 等 。

 
      跟踪main方法中的thread.attach(false)

        private void attach(boolean system) {
            sCurrentActivityThread = this;
            mSystemThread = system;
            if (!system) {
             //...
                try {
                    mgr.attachApplication(mAppThread);
                } catch (RemoteException ex) {
                    // Ignore
                }
                //...
            } else {
            	  //...
            }

            //...
            ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
            	  //...
            });
        }

能够看到，这里 mgr.attachApplication(mAppThread)把ActivityThread初始化时创建的mAppThread作为參数传递过去

        再耐心地继续跟踪：

        ActivityManagerService.class

	 @Override
    public final void attachApplication(IApplicationThread thread) {
        synchronized (this) {
            int callingPid = Binder.getCallingPid();
            final long origId = Binder.clearCallingIdentity();
            attachApplicationLocked(thread, callingPid);
            Binder.restoreCallingIdentity(origId);
        }
    }

ActivityManagerService.class

        private final boolean attachApplicationLocked(IApplicationThread thread,
                int pid) {

            // Find the application record that is being attached...  either via
            // the pid if we are running in multiple processes, or just pull the
            // next app record if we are emulating process with anonymous threads.
            ProcessRecord app;
            if (pid != MY_PID && pid >= 0) {
                synchronized (mPidsSelfLocked) {
                    app = mPidsSelfLocked.get(pid);
                }
            } else {
                app = null;
            }

            if (app == null) {
            	//...
                return false;
            }

          //...

            if (localLOGV) Slog.v(
                TAG, "New app record " + app
                + " thread=" + thread.asBinder() + " pid=" + pid);
            try {
            	 //...
            	//通过thread.bindApplication调用ActivityThread.handleBindApplication,Binder机制
                thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,
                        profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,
                        app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace,
                        isRestrictedBackupMode || !normalMode, app.persistent,
                        new Configuration(mConfiguration), app.compat,
                        getCommonServicesLocked(app.isolated),
                        mCoreSettingsObserver.getCoreSettingsLocked());
                updateLruProcessLocked(app, false, null);
                app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();
            } catch (Exception e) {
                //...
                return false;
            }
            //...
            // See if the top visible activity is waiting to run in this process...
            if (normalMode) {
                try {
                    if (mStackSupervisor.attachApplicationLocked(app)) {
                        didSomething = true;
                    }
                } catch (Exception e) {
                    Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
                    badApp = true;
                }
            }
            //...
            return true;
        }

通过thread.bindApplication调用ActivityThread.handleBindApplication,Binder机制

 
      ActivityThread.class

        private void handleBindApplication(AppBindData data) {
            mBoundApplication = data;
            mConfiguration = new Configuration(data.config);
            mCompatConfiguration = new Configuration(data.config);

           //...

            if (data.instrumentationName != null) {
                InstrumentationInfo ii = null;
                try {
                    ii = appContext.getPackageManager().
                        getInstrumentationInfo(data.instrumentationName, 0);
                } catch (PackageManager.NameNotFoundException e) {
                }
                if (ii == null) {
                    throw new RuntimeException(
                        "Unable to find instrumentation info for: "
                        + data.instrumentationName);
                }

                mInstrumentationPackageName = ii.packageName;
                mInstrumentationAppDir = ii.sourceDir;
                mInstrumentationSplitAppDirs = ii.splitSourceDirs;
                mInstrumentationLibDir = ii.nativeLibraryDir;
                mInstrumentedAppDir = data.info.getAppDir();
                mInstrumentedSplitAppDirs = data.info.getSplitAppDirs();
                mInstrumentedLibDir = data.info.getLibDir();

                ApplicationInfo instrApp = new ApplicationInfo();
                instrApp.packageName = ii.packageName;
                instrApp.sourceDir = ii.sourceDir;
                instrApp.publicSourceDir = ii.publicSourceDir;
                instrApp.splitSourceDirs = ii.splitSourceDirs;
                instrApp.splitPublicSourceDirs = ii.splitPublicSourceDirs;
                instrApp.dataDir = ii.dataDir;
                instrApp.nativeLibraryDir = ii.nativeLibraryDir;
                LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
                        appContext.getClassLoader(), false, true, false);
                ContextImpl instrContext = ContextImpl.createAppContext(this, pi);

                try {
                    java.lang.ClassLoader cl = instrContext.getClassLoader();
                   //Instrumentation的初始化,一个应用程序中仅仅有一个Instrumentation对象，每一个Activity内部都有一个该对象的引用,初始化完毕之后。帮助管理Activity生命周期的回调。
                    mInstrumentation = (Instrumentation)
                        cl.loadClass(data.instrumentationName.getClassName()).newInstance();
                } catch (Exception e) {
                    throw new RuntimeException(
                        "Unable to instantiate instrumentation "
                        + data.instrumentationName + ": " + e.toString(), e);
                }

                mInstrumentation.init(this, instrContext, appContext,
                       new ComponentName(ii.packageName, ii.name), data.instrumentationWatcher,
                       data.instrumentationUiAutomationConnection);
                //...

            } else {
            	mInstrumentation = new Instrumentation();
            }

            if ((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0) {
                dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();
            }

            // Allow disk access during application and provider setup. This could
            // block processing ordered broadcasts, but later processing would
            // probably end up doing the same disk access.
            final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
            try {
            	 //...

                // Do this after providers, since instrumentation tests generally start their
                // test thread at this point, and we don't want that racing.
                try {
                   //App
                	mInstrumentation.onCreate(data.instrumentationArgs);
                }
                catch (Exception e) {
                    throw new RuntimeException(
                        "Exception thrown in onCreate() of "
                        + data.instrumentationName + ": " + e.toString(), e);
                }

                try {
                  //回调Application的onCreate方法
                	mInstrumentation.callApplicationOnCreate(app);
                } catch (Exception e) {
                    if (!mInstrumentation.onException(app, e)) {
                        throw new RuntimeException(
                            "Unable to create application " + app.getClass().getName()
                            + ": " + e.toString(), e);
                    }
                }
            } finally {
                StrictMode.setThreadPolicy(savedPolicy);
            }
        }

 
      前面提到的Instrumentation就是在里面初始化的。初始化完毕之后，帮助管理Activity生命周期的回调。

 
      再接着分析ActivityManagerService.attachApplicationLocked方法中的mStackSupervisor.attachApplicationLocked(app)

    boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
        final String processName = app.processName;
        boolean didSomething = false;
        for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
            ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;
            for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {
                final ActivityStack stack = stacks.get(stackNdx);
                if (!isFrontStack(stack)) {
                    continue;
                }
                ActivityRecord hr = stack.topRunningActivityLocked(null);
                if (hr != null) {
                    if (hr.app == null && app.uid == hr.info.applicationInfo.uid
                            && processName.equals(hr.processName)) {
                        try {
                            //调用了realStartActivityLocked
                        	if (realStartActivityLocked(hr, app, true, true)) {
                                didSomething = true;
                            }
                        } catch (RemoteException e) {
                            Slog.w(TAG, "Exception in new application when starting activity "
                                  + hr.intent.getComponent().flattenToShortString(), e);
                            throw e;
                        }
                    }
                }
            }
        }
        if (!didSomething) {
            ensureActivitiesVisibleLocked(null, 0);
        }
        return didSomething;
    }

看到没有，这里仍然调用了realStartActivityLocked。再反复一下：

假设目标进程还处于活动状态，所以仅仅须要让目标进程再创建一个指定Activity的对象并运行之就可以，调用realStartActivityLocked，否则。假设目标进程还不存在，则须要首先启动目标进程。最后还是要调用realStartActivityLocked

 
      还是得继续追踪ActivityStackSupervisor中的realStartActivityLocked

 
      ActivityStackSupervisor.class

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

            r.startFreezingScreenLocked(app, 0);
            if (false) Slog.d(TAG, "realStartActivity: setting app visibility true");
            //setAppVisibility(true/false), 其作 用 是 告 诉WMS指定的窗体能否够被显示,这里为true。表示能够被显示
            mWindowManager.setAppVisibility(r.appToken, true);
             //...
            try {
               //...
                app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_TOP);
                //调用ApplicationThread.scheduleLaunchActivity
                app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
                        System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
                        r.compat, r.launchedFromPackage, r.task.voiceInteractor, app.repProcState,
                        r.icicle, r.persistentState, results, newIntents, !andResume,
                        mService.isNextTransitionForward(), profilerInfo);

                if ((app.info.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
                	//...
                }

            } catch (RemoteException e) {
                if (r.launchFailed) {
                    // This is the second time we failed -- finish activity
                    // and give up.
                    Slog.e(TAG, "Second failure launching "
                          + r.intent.getComponent().flattenToShortString()
                          + ", giving up", e);
                    mService.appDiedLocked(app);
                    stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,
                            "2nd-crash", false);
                    return false;
                }

                // This is the first time we failed -- restart process and
                // retry.
                app.activities.remove(r);
                throw e;
            }

          //...

            // Launch the new version setup screen if needed.  We do this -after-
            // launching the initial activity (that is, home), so that it can have
            // a chance to initialize itself while in the background, making the
            // switch back to it faster and look better.
            if (isFrontStack(stack)) {
                mService.startSetupActivityLocked();
            }

            // Update any services we are bound to that might care about whether
            // their client may have activities.
            mService.mServices.updateServiceConnectionActivitiesLocked(r.app);

            return true;
        }  

setAppVisibility(true/false), 其作 用是告诉WMS指定的窗体能否够被显示,这里为true，表示能够被显示。

 
      继续追踪ApplicationThread.scheduleLaunchActivity。还记得前面调用过ApplicationThread.schedulePauseActivity吧。

 
      ApplicationThread.class

        public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
                ActivityInfo info, Configuration curConfig, 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;

            updatePendingConfiguration(curConfig);

            sendMessage(H.LAUNCH_ACTIVITY, r);
        }

说明：scheduleLaunchActivity()方 法依据參数构造出一个本地ActivityRecord数据类 ，ActivityThread内部会为每个Activity创
建 一 个 ActivityRecord对象，并使用这些数据对象来管理Activity。

        最后通过
sendMessage(H.LAUNCH_ACTIVITY, r)去掉用handleLaunchActivity()。在handleLaunchActivity里面再调用到
performLaunchActivity()和 handleResumeActivity()

        H类前面已经解释过了，再来看看 handleLaunchActivity

 
      ActivityThread.class

        private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
            // If we are getting ready to gc after going to the background, well
            // we are back active so skip it.
            unscheduleGcIdler();
            mSomeActivitiesChanged = true;

            if (r.profilerInfo != null) {
                mProfiler.setProfiler(r.profilerInfo);
                mProfiler.startProfiling();
            }

            // Make sure we are running with the most recent config.
            handleConfigurationChanged(null, null);

            if (localLOGV) Slog.v(
                TAG, "Handling launch of " + r);

            // Initialize before creating the activity
            WindowManagerGlobal.initialize();
           //得到一个Activity实例,在里面会运行onCreate方法
            Activity a = performLaunchActivity(r, customIntent);

            if (a != null) {
                r.createdConfig = new Configuration(mConfiguration);
                Bundle oldState = r.state;
                // 调用目标activity的onResume,追踪源代码会发现 目标activity的onStart在里面会先于onResume调用
                handleResumeActivity(r.token, false, r.isForward,
                        !r.activity.mFinished && !r.startsNotResumed);

                if (!r.activity.mFinished && r.startsNotResumed) {
                    // The activity manager actually wants this one to start out
                    // paused, because it needs to be visible but isn't in the
                    // foreground.  We accomplish this by going through the
                    // normal startup (because activities expect to go through
                    // onResume() the first time they run, before their window
                    // is displayed), and then pausing it.  However, in this case
                    // we do -not- need to do the full pause cycle (of freezing
                    // and such) because the activity manager assumes it can just
                    // retain the current state it has.
                    try {
                        r.activity.mCalled = false;
                        //这里再次去居然再次调用了callActivityOnPause？事实上在前面的performPauseActivity方法中已经调用了此方法，Activity_A已经运行了OnPause
                        mInstrumentation.callActivityOnPause(r.activity);
                        // We need to keep around the original state, in case
                        // we need to be created again.  But we only do this
                        // for pre-Honeycomb apps, which always save their state
                        // when pausing, so we can not have them save their state
                        // when restarting from a paused state.  For HC and later,
                        // we want to (and can) let the state be saved as the normal
                        // part of stopping the activity.
                        if (r.isPreHoneycomb()) {
                            r.state = oldState;
                        }
                        if (!r.activity.mCalled) {
                            throw new SuperNotCalledException(
                                "Activity " + r.intent.getComponent().toShortString() +
                                " did not call through to super.onPause()");
                        }

                    } catch (SuperNotCalledException e) {
                        throw e;

                    } catch (Exception e) {
                        if (!mInstrumentation.onException(r.activity, e)) {
                            throw new RuntimeException(
                                    "Unable to pause activity "
                                    + r.intent.getComponent().toShortString()
                                    + ": " + e.toString(), e);
                        }
                    }
                    r.paused = true;
                }
            } else {
                // If there was an error, for any reason, tell the activity
                // manager to stop us.
                try {
                    ActivityManagerNative.getDefault()
                        .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);
                } catch (RemoteException ex) {
                    // Ignore
                }
            }
        }

继续追踪performLaunchActivity

 
      ActivityThread.class

        private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
            // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
        	//...
            Activity activity = null;
            try {
                java.lang.ClassLoader cl = r.packageInfo.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);
                }
            } catch (Exception e) {
                if (!mInstrumentation.onException(activity, e)) {
                    throw new RuntimeException(
                        "Unable to instantiate activity " + component
                        + ": " + e.toString(), e);
                }
            }

            try {
                Application app = r.packageInfo.makeApplication(false, mInstrumentation);
                 //...
                if (activity != null) {
                     //...
                	 //在这里最终開始调用目标Activity的OnCreate方法了
                	if (r.isPersistable()) {
                        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnCreate(activity, r.state);
                    }
                	//...
                    if (!r.activity.mFinished) {
                    	//这里调用Activity_B的nRestoreInstanceState方法，获取保存在Bundle中的信息
                    	if (r.isPersistable()) {
                            if (r.state != null || r.persistentState != null) {
                                mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                        r.persistentState);
                            }
                        } else if (r.state != null) {
                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                        }
                    }
                  //...
                }
              //...

            } catch (SuperNotCalledException e) {
                throw e;

            } catch (Exception e) {
            	//...
            }

            return activity;
        }

Instrumentation.callActivityOnCreate会调用activity.performCreate(icicle, persistentState)，activity.performCreate又会其调用onCreate方法（不贴代码了）。

 
      到这里。Activity_B已经运行了onCreate方法，已经走完了Activity_A的onPause-->Activity_B的onCreate生命周期回调的流程。

 
      performLaunchActivity()方法返回后。运行ActivityThread.handleResumeActivity 

 
      ActivityThread.class

        final void handleResumeActivity(IBinder token,
                boolean clearHide, boolean isForward, boolean reallyResume) {
            // If we are getting ready to gc after going to the background, well
            // we are back active so skip it.
            unscheduleGcIdler();
            mSomeActivitiesChanged = true;

            // TODO Push resumeArgs into the activity for consideration
          //在performResumeActivity里面调用了目标Activity_B的 onStart和onResume()方法。后面会追踪源代码
            ActivityClientRecord r = performResumeActivity(token, clearHide);

            if (r != null) {
                final Activity a = r.activity;
                 //...

                if (!r.activity.mFinished && willBeVisible
                        && r.activity.mDecor != null && !r.hideForNow) {
                	//...
                    if (r.activity.mVisibleFromClient) {
                       //过r.activity.makeVisible()调用目标Activity_B的 makeVisible()函数，该函数其内部又会辗转和WmS进行各种调用，并终于导致Activity包括 的DecorView显示到屏幕上
                    	r.activity.makeVisible();
                    }
                }

                if (!r.onlyLocalRequest) {
                    r.nextIdle = mNewActivities;
                    mNewActivities = r;
                    if (localLOGV) Slog.v(
                        TAG, "Scheduling idle handler for " + r);
                   //创建一个Idler对象，并加入到线程消息队列中，
                    Looper.myQueue().addIdleHandler(new Idler());
                }
              //...

            } else {
            	//...
            }
        }  

 
      追踪performResumeActivity

 
      ActivityThread.class

        public final ActivityClientRecord performResumeActivity(IBinder token,
                boolean clearHide) {
            ActivityClientRecord r = mActivities.get(token);
            if (localLOGV) Slog.v(TAG, "Performing resume of " + r
                    + " finished=" + r.activity.mFinished);
            if (r != null && !r.activity.mFinished) {
                if (clearHide) {
                    r.hideForNow = false;
                    r.activity.mStartedActivity = false;
                }
                try {
                	//...
                    r.activity.performResume();

                  //...
                } catch (Exception e) {
                	//...
                }
            }
            return r;
        }

        继续看performResume 

        Activity.class

        final void performResume() {
           //目标Activity的OnRestart和Onstart都在里面
        	performRestart();

            mFragments.execPendingActions();

            mLastNonConfigurationInstances = null;

            mCalled = false;
            // mResumed is set by the instrumentation
            // 调用了目标Activity的 onOnResume方法
            mInstrumentation.callActivityOnResume(this);
            if (!mCalled) {
                throw new SuperNotCalledException(
                    "Activity " + mComponent.toShortString() +
                    " did not call through to super.onResume()");
            }

            // Now really resume, and install the current status bar and menu.
            mCalled = false;

            mFragments.dispatchResume();
            mFragments.execPendingActions();

            onPostResume();
            if (!mCalled) {
                throw new SuperNotCalledException(
                    "Activity " + mComponent.toShortString() +
                    " did not call through to super.onPostResume()");
            }
        }

还是得继续看performRestart

        final void performRestart() {
            mFragments.noteStateNotSaved();

            if (mStopped) {
                mStopped = false;
                if (mToken != null && mParent == null) {
                    WindowManagerGlobal.getInstance().setStoppedState(mToken, false);
                }

              //...

                mCalled = false;
                //这里调用OnRestart方法
                mInstrumentation.callActivityOnRestart(this);
                if (!mCalled) {
                    throw new SuperNotCalledException(
                        "Activity " + mComponent.toShortString() +
                        " did not call through to super.onRestart()");
                }
                //目标Activity的onStart在这里面
                performStart();
            }
        }

        final void performStart() {
            //...
        	// 目标Activity的onStart在这里运行
            mInstrumentation.callActivityOnStart(this);
            if (!mCalled) {
                throw new SuperNotCalledException(
                    "Activity " + mComponent.toShortString() +
                    " did not call through to super.onStart()");
            }
            //...
        }

        Instrumentation.class

  public void callActivityOnStart(Activity activity) {
        activity.onStart();
    }

看到了activity.onStart()

public void callActivityOnResume(Activity activity) {
        activity.mResumed = true;
        activity.onResume();

        if (mActivityMonitors != null) {
            synchronized (mSync) {
                final int N = mActivityMonitors.size();
                for (int i=0; i<N; i++) {
                    final ActivityMonitor am = mActivityMonitors.get(i);
                    am.match(activity, activity, activity.getIntent());
                }
            }
        }
    }

        看到了activity.onResume()

        至此。从已经走到了Activity_B生命周期的onResume方法。

源代码分析已经完毕了Activity_A.onPause()--Activity_B.onCreate()--Activity_B.onStart()--Activity_B.onResume()，期间还看到了Activity的onSaveInstanceState()，OnRestoreInstanceState()。OnRestart()方法。

        还有最后Activity_A的onStop方法没有看到，继续看源代码吧！

        回到ActivityThread的handleResumeActivity方法。里面的r.activity.makeVisible()去调用目标Activity_B的
makeVisible()函数，该函数其内部又会辗转和WmS进行各种调用。并最终导致Activity包括
的DecorView显示到屏幕上（有待研究）。

        handleResumeActivity方法中另一句Looper.myQueue().addIdleHandler(new
Idler())，创建一个Idler对象，并加入到线程消息队列中。而 Idler类的内部处理函数则是调用WmS的 activityldle()方法在该函数的内部则会辗转调用到stopActivityLocked()方法。

 
      ActivityStack.class

            final void stopActivityLocked(ActivityRecord r) {
                 //...
                if (r.app != null && r.app.thread != null) {
                    adjustFocusedActivityLocked(r, "stopActivity");
                    r.resumeKeyDispatchingLocked();
                    try {
                    	//...
                    	//这里调用setAppVisibility(r.appToken, false)隐藏Activity_A
                        if (!r.visible) {
                            mWindowManager.setAppVisibility(r.appToken, false);
                        }
                        //这里则是调用ActivityThread.scheduleStopActivity
                        r.app.thread.scheduleStopActivity(r.appToken, r.visible, r.configChangeFlags);
                       //...
                        Message msg = mHandler.obtainMessage(STOP_TIMEOUT_MSG, r);
                        mHandler.sendMessageDelayed(msg, STOP_TIMEOUT);
                    } catch (Exception e) {
                    	//...
                    }
                }
            }

又回到了ActivityThread

 
      ActivityThread.class

 public final void scheduleStopActivity(IBinder token, boolean showWindow,
                int configChanges) {
           sendMessage(
                showWindow ?

H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
                token, 0, configChanges);
        }

告知H，运行
handleStopActivity，又会调用ActivityThread的performStopActivityInner，接着运行r.activity.performStop()调用Activity的performStop

 
      Activity.class

            final void performStop() {
                mDoReportFullyDrawn = false;
                //...

                if (!mStopped) {
                    //...
                	//这里Activity_A的OnStop方法
                	mInstrumentation.callActivityOnStop(this);
                    if (!mCalled) {
                        throw new SuperNotCalledException(
                            "Activity " + mComponent.toShortString() +
                            " did not call through to super.onStop()");
                    }

                    //...
                    mStopped = true;
                }
                mResumed = false;
            }  

Instrumentation.class

    public void callActivityOnStop(Activity activity) {
        activity.onStop();
    }

最后调用了activity.onStop()

   
    至此，从Activity_A到Activity_B，分别经历的生命周期运行过程和顺序
走通了！！。！

Activity_A.onPause()--Activity_B.onCreate()--Activity_B.onStart()--Activity_B.onResume()--Activity_A.onStop()。