码迷,mamicode.com
首页 > 移动开发 > 详细

Activity生命周期的回调,你应该知道得很多其它!--Android源代码剖析(下)

时间:2017-07-19 14:15:06      阅读:2399      评论:0      收藏:0      [点我收藏+]

标签:ash   dstat   nothing   indent   代码   multi   sdk   显示   second   

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

        继续分析,在performPauseActivity方法中,回调了Activity的两个操作函数:
        一 个是用于保存状态的onSaveInstanceState(),还有一个就是onPause()  ,这里你应该了解onPause和onSaveInstanceState的调用顺序了,这里看来OnSaveInstanceState是先于onPause的调用的,可是打印的Log显示onSaveInstanceState在onPause之后,在onStop之前调用(不明确)。

技术分享

        最后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()。

Activity生命周期的回调,你应该知道得很多其它!--Android源代码剖析(下)

标签:ash   dstat   nothing   indent   代码   multi   sdk   显示   second   

原文地址:http://www.cnblogs.com/llguanli/p/7204921.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!