• 在Android开发中,程序猿接触最多的就是Activity,其中必须会使用到的一个方法就是Activity的onCreate()方法,但是这个方法并不是程序的入口调用函数,他只是Activity的生命周期函数调用的第一个方法,而真正的程序入口在ActivityThread类的main方法.

  • 我们看下ActivityThread的main做了那些逻辑处理

1.    public static void main(String[] args) {

2.        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");

3.        SamplingProfilerIntegration.start();

5.        // CloseGuard defaults to true and can be quite spammy.  We

6.        // disable it here, but selectively enable it later (via

7.        // StrictMode) on debug builds, but using DropBox, not logs.

8.        CloseGuard.setEnabled(false);

10.        Environment.initForCurrentUser();

12.        // Set the reporter for event logging in libcore

13.        EventLogger.setReporter(new EventLoggingReporter());

15.        // Make sure TrustedCertificateStore looks in the right place for CA certificates

16.        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());

17.        TrustedCertificateStore.setDefaultUserDirectory(configDir);

19.        Process.setArgV0("");

21.         //1.主线程Looper


22.        Looper.prepareMainLooper();

24.         //2.实例化ActivityThread对象,并调用attach()方法


25.        ActivityThread thread = new ActivityThread();

26.        thread.attach(false);

28.        if (sMainThreadHandler == null) {

29.            sMainThreadHandler = thread.getHandler();

30.        }

32.        if (false) {

33.            Looper.myLooper().setMessageLogging(new

34.                    LogPrinter(Log.DEBUG, "ActivityThread"));

35.        }

37.        // End of event ActivityThreadMain.

38.        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

39.         //3.开启主线程Loooper轮询


40.        Looper.loop();

42.        throw new RuntimeException("Main thread loop unexpectedly exited");

43.    }

接着看thread.attach()方法的实现

1.    private void attach(boolean system) {

2.        sCurrentActivityThread = this;

3.        mSystemThread = system;

4.     


5.         //system为false代表不是系统应用


6.        if (!system) {

7.            ViewRootImpl.addFirstDrawHandler(new Runnable() {

8.                @Override

9.                public void run() {

10.                    ensureJitEnabled();

11.                }

12.            });

13.            android.ddm.DdmHandleAppName.setAppName("",

14.                                                    UserHandle.myUserId());

15.            RuntimeInit.setApplicationObject(mAppThread.asBinder());

16.     


17.             //这个方法我们在上一篇博客中讲到过获取的AMS对象,然后调用了AMS的attachApplication()方法


18.            final IActivityManager mgr = ActivityManagerNative.getDefault();

19.            try {

20.                mgr.attachApplication(mAppThread);

21.            } catch (RemoteException ex) {

22.                throw ex.rethrowFromSystemServer();

23.            }

24.            // Watch for getting close to heap limit.

25.            BinderInternal.addGcWatcher(new Runnable() {

26.                @Override public void run() {

27.                    if (!mSomeActivitiesChanged) {

28.                        return;

29.                    }

30.                    Runtime runtime = Runtime.getRuntime();

31.                    long dalvikMax = runtime.maxMemory();

32.                    long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();

33.                    if (dalvikUsed > ((3*dalvikMax)/4)) {

34.                        if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)

35.                                + " total=" + (runtime.totalMemory()/1024)

36.                                + " used=" + (dalvikUsed/1024));

37.                        mSomeActivitiesChanged = false;

38.                        try {

39.                            mgr.releaseSomeActivities(mAppThread);

40.                        } catch (RemoteException e) {

41.                            throw e.rethrowFromSystemServer();

42.                        }

43.                    }

44.                }

45.            });

46.        } else {

47.            // Don't set application object here -- if the system crashes,

48.            // we can't display an alert, we just want to die die die.

49.            android.ddm.DdmHandleAppName.setAppName("system_process",

50.                    UserHandle.myUserId());

51.            try {

52.                mInstrumentation = new Instrumentation();

53.                ContextImpl context = ContextImpl.createAppContext(

54.                        this, getSystemContext().mPackageInfo);

55.                mInitialApplication = context.mPackageInfo.makeApplication(true, null);

56.                mInitialApplication.onCreate();

57.            } catch (Exception e) {

58.                throw new RuntimeException(

59.                        "Unable to instantiate Application():" + e.toString(), e);

60.            }

61.        }

63.        // add dropbox logging to libcore

64.        DropBox.setReporter(new DropBoxReporter());

66.        ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {

67.            @Override

68.            public void onConfigurationChanged(Configuration newConfig) {

69.                synchronized (mResourcesManager) {

70.                    // We need to apply this change to the resources

71.                    // immediately, because upon returning the view

72.                    // hierarchy will be informed about it.

73.                    if (mResourcesManager.applyConfigurationToResourcesLocked(newConfig, null)) {

74.                        updateLocaleListFromAppContext(mInitialApplication.getApplicationContext(),

75.                                mResourcesManager.getConfiguration().getLocales());

77.                        // This actually changed the resources!  Tell

78.                        // everyone about it.

79.                        if (mPendingConfiguration == null ||

80.                                mPendingConfiguration.isOtherSeqNewer(newConfig)) {

81.                            mPendingConfiguration = newConfig;

83.                            sendMessage(H.CONFIGURATION_CHANGED, newConfig);

84.                        }

85.                    }

86.                }

87.            }

88.            @Override

89.            public void onLowMemory() {

90.            }

91.            @Override

92.            public void onTrimMemory(int level) {

93.            }

94.        });

95.    }

接着看AMS的attachApplication()方法-->调用的是attachApplicationLocked()

1.    private final boolean attachApplicationLocked(IApplicationThread thread,

2.            int pid) {

4.        // Find the application record that is being attached...  either via

5.        // the pid if we are running in multiple processes, or just pull the

6.        // next app record if we are emulating process with anonymous threads.

7.        ProcessRecord app;

8.        if (pid != MY_PID && pid >= 0) {

9.            synchronized (mPidsSelfLocked) {

10.                app = mPidsSelfLocked.get(pid);

11.            }

12.        } else {

13.            app = null;

14.        }

16.        if (app == null) {

17.            Slog.w(TAG, "No pending application record for pid " + pid

18.                    + " (IApplicationThread " + thread + "); dropping process");

19.            EventLog.writeEvent(EventLogTags.AM_DROP_PROCESS, pid);

20.            if (pid > 0 && pid != MY_PID) {

21.                Process.killProcessQuiet(pid);

22.                //TODO: killProcessGroup(app.info.uid, pid);

23.            } else {

24.                try {

25.                    thread.scheduleExit();

26.                } catch (Exception e) {

27.                    // Ignore exceptions.

28.                }

29.            }

30.            return false;

31.        }

33.        // If this application record is still attached to a previous

34.        // process, clean it up now.

35.        if (app.thread != null) {

36.            handleAppDiedLocked(app, true, true);

37.        }

39.        // Tell the process all about itself.

41.        if (DEBUG_ALL) Slog.v(

42.                TAG, "Binding process pid " + pid + " to record " + app);

44.        final String processName = app.processName;

45.        try {

46.            AppDeathRecipient adr = new AppDeathRecipient(

47.                    app, pid, thread);

48.            thread.asBinder().linkToDeath(adr, 0);

49.            app.deathRecipient = adr;

50.        } catch (RemoteException e) {

51.            app.resetPackageList(mProcessStats);

52.            startProcessLocked(app, "link fail", processName);

53.            return false;

54.        }

56.        EventLog.writeEvent(EventLogTags.AM_PROC_BOUND, app.userId, app.pid, app.processName);

58.        app.makeActive(thread, mProcessStats);

59.        app.curAdj = app.setAdj = app.verifiedAdj = ProcessList.INVALID_ADJ;

60.        app.curSchedGroup = app.setSchedGroup = ProcessList.SCHED_GROUP_DEFAULT;

61.        app.forcingToForeground = null;

62.        updateProcessForegroundLocked(app, false, false);

63.        app.hasShownUi = false;

64.        app.debugging = false;

65.        app.cached = false;

66.        app.killedByAm = false;

68.        // We carefully use the same state that PackageManager uses for

69.        // filtering, since we use this flag to decide if we need to install

70.        // providers when user is unlocked later

71.        app.unlocked = StorageManager.isUserKeyUnlocked(app.userId);

73.        mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);

75.        boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);

76.        List providers = normalMode ? generateApplicationProvidersLocked(app) : null;

78.        if (providers != null && checkAppInLaunchingProvidersLocked(app)) {

79.            Message msg = mHandler.obtainMessage(CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG);

80.            msg.obj = app;

81.            mHandler.sendMessageDelayed(msg, CONTENT_PROVIDER_PUBLISH_TIMEOUT);

82.        }

84.        if (!normalMode) {

85.            Slog.i(TAG, "Launching preboot mode app: " + app);

86.        }

88.        if (DEBUG_ALL) Slog.v(

89.            TAG, "New app record " + app

90.            + " thread=" + thread.asBinder() + " pid=" + pid);

91.        try {

92.            int testMode = IApplicationThread.DEBUG_OFF;

93.            if (mDebugApp != null && mDebugApp.equals(processName)) {

94.                testMode = mWaitForDebugger

95.                    ? IApplicationThread.DEBUG_WAIT

96.                    : IApplicationThread.DEBUG_ON;

97.                app.debugging = true;

98.                if (mDebugTransient) {

99.                    mDebugApp = mOrigDebugApp;

100.                    mWaitForDebugger = mOrigWaitForDebugger;

101.                }

102.            }

103.            String profileFile = app.instrumentationProfileFile;

104.            ParcelFileDescriptor profileFd = null;

105.            int samplingInterval = 0;

106.            boolean profileAutoStop = false;

107.            if (mProfileApp != null && mProfileApp.equals(processName)) {

108.                mProfileProc = app;

109.                profileFile = mProfileFile;

110.                profileFd = mProfileFd;

111.                samplingInterval = mSamplingInterval;

112.                profileAutoStop = mAutoStopProfiler;

113.            }

114.            boolean enableTrackAllocation = false;

115.            if (mTrackAllocationApp != null && mTrackAllocationApp.equals(processName)) {

116.                enableTrackAllocation = true;

117.                mTrackAllocationApp = null;

118.            }

120.            // If the app is being launched for restore or full backup, set it up specially

121.            boolean isRestrictedBackupMode = false;

122.            if (mBackupTarget != null && mBackupAppName.equals(processName)) {

123.                isRestrictedBackupMode = mBackupTarget.appInfo.uid >= Process.FIRST_APPLICATION_UID

124.                        && ((mBackupTarget.backupMode == BackupRecord.RESTORE)

125.                                || (mBackupTarget.backupMode == BackupRecord.RESTORE_FULL)

126.                                || (mBackupTarget.backupMode == BackupRecord.BACKUP_FULL));

127.            }

129.            if (app.instrumentationClass != null) {

130.                notifyPackageUse(app.instrumentationClass.getPackageName(),

131.                                 PackageManager.NOTIFY_PACKAGE_USE_INSTRUMENTATION);

132.            }

133.            if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Binding proc "

134.                    + processName + " with config " + mConfiguration);

135.            ApplicationInfo appInfo = app.instrumentationInfo != null

136.                    ? app.instrumentationInfo : app.info;

137.            app.compat = compatibilityInfoForPackageLocked(appInfo);

138.            if (profileFd != null) {

139.                profileFd = profileFd.dup();

140.            }

141.            ProfilerInfo profilerInfo = profileFile == null ? null

142.                    : new ProfilerInfo(profileFile, profileFd, samplingInterval, profileAutoStop);

143.     


144.             //1.这是个重要方法,根据名字就可以知道该方法的作用就是将ApplicationThread绑定到AMS上.


145.            thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,

146.                    profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,

147.                    app.instrumentationUiAutomationConnection, testMode,

148.                    mBinderTransactionTrackingEnabled, enableTrackAllocation,

149.                    isRestrictedBackupMode || !normalMode, app.persistent,

150.                    new Configuration(mConfiguration), app.compat,

151.                    getCommonServicesLocked(app.isolated),

152.                    mCoreSettingsObserver.getCoreSettingsLocked());

153.            updateLruProcessLocked(app, false, null);

154.            app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();

155.        } catch (Exception e) {

156.            // todo: Yikes!  What should we do?  For now we will try to

157.            // start another process, but that could easily get us in

158.            // an infinite loop of restarting processes...

159.            Slog.wtf(TAG, "Exception thrown during bind of " + app, e);

161.            app.resetPackageList(mProcessStats);

162.            app.unlinkDeathRecipient();

163.            startProcessLocked(app, "bind fail", processName);

164.            return false;

165.        }

167.        // Remove this record from the list of starting applications.

168.        mPersistentStartingProcesses.remove(app);

169.        if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG_PROCESSES,

170.                "Attach application locked removing on hold: " + app);

171.        mProcessesOnHold.remove(app);

173.        boolean badApp = false;

174.        boolean didSomething = false;

176.        // See if the top visible activity is waiting to run in this process...

177.        if (normalMode) {

178.            try {

179.     


180.                 //2.第二个重要方法就是调用了AcitvityStackSupervisor的attachApplicationLocked()方法


181.                if (mStackSupervisor.attachApplicationLocked(app)) {

182.                    didSomething = true;

183.                }

184.            } catch (Exception e) {

185.                Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);

186.                badApp = true;

187.            }

188.        }

190.        // Find any services that should be running in this process...

191.        if (!badApp) {

192.            try {

193.                didSomething |= mServices.attachApplicationLocked(app, processName);

194.            } catch (Exception e) {

195.                Slog.wtf(TAG, "Exception thrown starting services in " + app, e);

196.                badApp = true;

197.            }

198.        }

200.        // Check if a next-broadcast receiver is in this process...

201.        if (!badApp && isPendingBroadcastProcessLocked(pid)) {

202.            try {

203.                didSomething |= sendPendingBroadcastsLocked(app);

204.            } catch (Exception e) {

205.                // If the app died trying to launch the receiver we declare it 'bad'

206.                Slog.wtf(TAG, "Exception thrown dispatching broadcasts in " + app, e);

207.                badApp = true;

208.            }

209.        }

211.        // Check whether the next backup agent is in this process...

212.        if (!badApp && mBackupTarget != null && mBackupTarget.appInfo.uid == app.uid) {

213.            if (DEBUG_BACKUP) Slog.v(TAG_BACKUP,

214.                    "New app is backup target, launching agent for " + app);

215.            notifyPackageUse(mBackupTarget.appInfo.packageName,

216.                             PackageManager.NOTIFY_PACKAGE_USE_BACKUP);

217.            try {

218.                thread.scheduleCreateBackupAgent(mBackupTarget.appInfo,

219.                        compatibilityInfoForPackageLocked(mBackupTarget.appInfo),

220.                        mBackupTarget.backupMode);

221.            } catch (Exception e) {

222.                Slog.wtf(TAG, "Exception thrown creating backup agent in " + app, e);

223.                badApp = true;

224.            }

225.        }

227.        if (badApp) {

228.            app.kill("error during init", true);

229.            handleAppDiedLocked(app, false, true);

230.            return false;

231.        }

233.        if (!didSomething) {

234.            updateOomAdjLocked();

235.        }

237.        return true;

238.    }

1.    @Override

2.    public final void attachApplication(IApplicationThread thread) {

3.        synchronized (this) {

4.            int callingPid = Binder.getCallingPid();

5.            final long origId = Binder.clearCallingIdentity();

6.            attachApplicationLocked(thread, callingPid);

7.            Binder.restoreCallingIdentity(origId);

8.        }

9.    }

在ActivityManagerService的attachApplication()方法中接着调用了attachApplicationLocked()为绑定Application加锁，接着调用了ApplicationThread的bindApplication()方法，将Application绑定到AMS上，最后调用的ActivityStackSupervisor的attachApplicationLocked()方法，我们接着看在该方法中处理了那些逻辑

1.    boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {

2.        final String processName = app.processName;

3.        boolean didSomething = false;

4.        for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {

5.            ArrayList stacks = mActivityDisplays.valueAt(displayNdx).mStacks;

6.            for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {

7.                final ActivityStack stack = stacks.get(stackNdx);

8.                if (!isFocusedStack(stack)) {

9.                    continue;

10.                }

11.                ActivityRecord hr = stack.topRunningActivityLocked();

12.                if (hr != null) {

13.                    if (hr.app == null && app.uid == hr.info.applicationInfo.uid

14.                            && processName.equals(hr.processName)) {

15.                        try {


16.                         //真正我们要看的方法就是这个方法

17.                            if (realStartActivityLocked(hr, app, true, true)) {

18.                                didSomething = true;

19.                            }

20.                        } catch (RemoteException e) {

21.                            Slog.w(TAG, "Exception in new application when starting activity "

22.                                  + hr.intent.getComponent().flattenToShortString(), e);

23.                            throw e;

24.                        }

25.                    }

26.                }

27.            }

28.        }

29.        if (!didSomething) {

30.            ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);

31.        }

32.        return didSomething;

33.    }

realStartActivityLocked()看方法名字也知道该方法的作用是真正启动Activity的方法

1.    final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,

2.            boolean andResume, boolean checkConfig) throws RemoteException {

4.        if (!allPausedActivitiesComplete()) {

5.            // While there are activities pausing we skipping starting any new activities until

6.            // pauses are complete. NOTE: that we also do this for activities that are starting in

7.            // the paused state because they will first be resumed then paused on the client side.

8.            if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG_PAUSE,

9.                    "realStartActivityLocked: Skipping start of r=" + r

10.                    + " some activities pausing...");

11.            return false;

12.        }

14.        if (andResume) {


15.          //冻结未尚未启动的其他activity


16.            r.startFreezingScreenLocked(app, 0);


17.          //标示当前app要位于前台显示

18.            mWindowManager.setAppVisibility(r.appToken, true);

20.            // 搜集启动较慢的app信息

21.            r.startLaunchTickingLocked();

22.        }

24.        // 检查配置信息

25.        if (checkConfig) {

26.            Configuration config = mWindowManager.updateOrientationFromAppTokens(

27.                    mService.mConfiguration,

28.                    r.mayFreezeScreenLocked(app) ? r.appToken : null);

29.            // Deferring resume here because we're going to launch new activity shortly.

30.            // We don't want to perform a redundant launch of the same record while ensuring

31.            // configurations and trying to resume top activity of focused stack.

32.            mService.updateConfigurationLocked(config, r, false, true );

33.        }

35.             //设置相关参数信息

36.        r.app = app;

37.        app.waitingToKill = null;

38.        r.launchCount++;

39.        r.lastLaunchTime = SystemClock.uptimeMillis();

41.        if (DEBUG_ALL) Slog.v(TAG, "Launching: " + r);

43.        int idx = app.activities.indexOf(r);

44.        if (idx

45.            app.activities.add(r);

46.        }

47.        mService.updateLruProcessLocked(app, true, null);

48.        mService.updateOomAdjLocked();

50.        final TaskRecord task = r.task;

51.        if (task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE ||

52.                task.mLockTaskAuth == LOCK_TASK_AUTH_LAUNCHABLE_PRIV) {

53.            setLockTaskModeLocked(task, LOCK_TASK_MODE_LOCKED, "mLockTaskAuth==LAUNCHABLE", false);

54.        }

56.        final ActivityStack stack = task.stack;

57.        try {

58.            if (app.thread == null) {

59.                throw new RemoteException();

60.            }

61.            List results = null;

62.            List newIntents = null;

63.            if (andResume) {

64.                results = r.results;

65.                newIntents = r.newIntents;

66.            }

67.            if (DEBUG_SWITCH) Slog.v(TAG_SWITCH,

68.                    "Launching: " + r + " icicle=" + r.icicle + " with results=" + results

69.                    + " newIntents=" + newIntents + " andResume=" + andResume);

70.            if (andResume) {

71.                EventLog.writeEvent(EventLogTags.AM_RESTART_ACTIVITY,

72.                        r.userId, System.identityHashCode(r),

73.                        task.taskId, r.shortComponentName);

74.            }

75.            if (r.isHomeActivity()) {

76.                // 是否是桌面activity，是的话将其添加到栈底

77.                mService.mHomeProcess = task.mActivities.get(0).app;

78.            }

79.            mService.notifyPackageUse(r.intent.getComponent().getPackageName(),

80.                                      PackageManager.NOTIFY_PACKAGE_USE_ACTIVITY);

81.            r.sleeping = false;

82.            r.forceNewConfig = false;

83.            mService.showUnsupportedZoomDialogIfNeededLocked(r);

84.            mService.showAskCompatModeDialogLocked(r);

85.            r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo);

86.            ProfilerInfo profilerInfo = null;

87.            if (mService.mProfileApp != null && mService.mProfileApp.equals(app.processName)) {

88.                if (mService.mProfileProc == null || mService.mProfileProc == app) {

89.                    mService.mProfileProc = app;

90.                    final String profileFile = mService.mProfileFile;

91.                    if (profileFile != null) {

92.                        ParcelFileDescriptor profileFd = mService.mProfileFd;

93.                        if (profileFd != null) {

94.                            try {

95.                                profileFd = profileFd.dup();

96.                            } catch (IOException e) {

97.                                if (profileFd != null) {

98.                                    try {

99.                                        profileFd.close();

100.                                    } catch (IOException o) {

101.                                    }

102.                                    profileFd = null;

103.                                }

104.                            }

105.                        }

107.                        profilerInfo = new ProfilerInfo(profileFile, profileFd,

108.                                mService.mSamplingInterval, mService.mAutoStopProfiler);

109.                    }

110.                }

111.            }

113.            if (andResume) {

114.                app.hasShownUi = true;

115.                app.pendingUiClean = true;

116.            }

117.            app.forceProcessStateUpTo(mService.mTopProcessState);


118.          //所有信息准备完毕了，开始启动activity


119.            app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,

120.                    System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),

121.                    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,

122.                    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,

123.                    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);

125.            if ((app.info.privateFlags&ApplicationInfo.PRIVATE_FLAG_CANT_SAVE_STATE) != 0) {

126.                // This may be a heavy-weight process!  Note that the package

127.                // manager will ensure that only activity can run in the main

128.                // process of the .apk, which is the only thing that will be

129.                // considered heavy-weight.

130.                if (app.processName.equals(app.info.packageName)) {

131.                    if (mService.mHeavyWeightProcess != null

132.                            && mService.mHeavyWeightProcess != app) {

133.                        Slog.w(TAG, "Starting new heavy weight process " + app

134.                                + " when already running "

135.                                + mService.mHeavyWeightProcess);

136.                    }

137.                    mService.mHeavyWeightProcess = app;

138.                    Message msg = mService.mHandler.obtainMessage(

139.                            ActivityManagerService.POST_HEAVY_NOTIFICATION_MSG);

140.                    msg.obj = r;

141.                    mService.mHandler.sendMessage(msg);

142.                }

143.            }

145.        } catch (RemoteException e) {

146.            if (r.launchFailed) {

147.                // This is the second time we failed -- finish activity

148.                // and give up.

149.                Slog.e(TAG, "Second failure launching "

150.                      + r.intent.getComponent().flattenToShortString()

151.                      + ", giving up", e);

152.                mService.appDiedLocked(app);

153.                stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED, null,

154.                        "2nd-crash", false);

155.                return false;

156.            }

158.            // This is the first time we failed -- restart process and

159.            // retry.

160.            app.activities.remove(r);

161.            throw e;

162.        }

164.        r.launchFailed = false;

165.        if (stack.updateLRUListLocked(r)) {

166.            Slog.w(TAG, "Activity " + r + " being launched, but already in LRU list");

167.        }

169.        if (andResume) {

170.            // As part of the process of launching, ActivityThread also performs

171.            // a resume.

172.            stack.minimalResumeActivityLocked(r);

173.        } else {

174.            // This activity is not starting in the resumed state... which should look like we asked

175.            // it to pause+stop (but remain visible), and it has done so and reported back the

176.            // current icicle and other state.

177.            if (DEBUG_STATES) Slog.v(TAG_STATES,

178.                    "Moving to PAUSED: " + r + " (starting in paused state)");

179.            r.state = PAUSED;

180.        }

182.        // Launch the new version setup screen if needed.  We do this -after-

183.        // launching the initial activity (that is, home), so that it can have

184.        // a chance to initialize itself while in the background, making the

185.        // switch back to it faster and look better.

186.        if (isFocusedStack(stack)) {

187.            mService.startSetupActivityLocked();

188.        }

190.        // Update any services we are bound to that might care about whether

191.        // their client may have activities.

192.        if (r.app != null) {

193.            mService.mServices.updateServiceConnectionActivitiesLocked(r.app);

194.        }

196.        return true;

197.    }

最后调用了ApplicationThread的scheduleLaunchActivity()

1.        @Override

2.        public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,

3.                ActivityInfo info, Configuration curConfig, Configuration overrideConfig,

4.                CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,

5.                int procState, Bundle state, PersistableBundle persistentState,

6.                List pendingResults, List pendingNewIntents,

7.                boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {

9.            updateProcessState(procState, false);

11.            ActivityClientRecord r = new ActivityClientRecord();

13.            r.token = token;

14.            r.ident = ident;

15.            r.intent = intent;

16.            r.referrer = referrer;

17.            r.voiceInteractor = voiceInteractor;

18.            r.activityInfo = info;

19.            r.compatInfo = compatInfo;

20.            r.state = state;

21.            r.persistentState = persistentState;

23.            r.pendingResults = pendingResults;

24.            r.pendingIntents = pendingNewIntents;

26.            r.startsNotResumed = notResumed;

27.            r.isForward = isForward;

29.            r.profilerInfo = profilerInfo;

31.            r.overrideConfig = overrideConfig;

32.            updatePendingConfiguration(curConfig);

34.                     //所有信息进行封装后，通过handler发送消息的方式来启动

35.            sendMessage(H.LAUNCH_ACTIVITY, r);

36.        }

1.        public void handleMessage(Message msg) {

2.            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));

3.            switch (msg.what) {

4.                case LAUNCH_ACTIVITY: {

5.                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");

6.                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;

8.                    r.packageInfo = getPackageInfoNoCheck(

9.                            r.activityInfo.applicationInfo, r.compatInfo);

10.                    handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");

11.                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

12.                } break;

Handler接收到消息通知后，调用handleLaunchActivity()方法启动activity

1.   private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {

2.        // If we are getting ready to gc after going to the background, well

3.        // we are back active so skip it.

4.        unscheduleGcIdler();

5.        mSomeActivitiesChanged = true;

7.        if (r.profilerInfo != null) {

8.            mProfiler.setProfiler(r.profilerInfo);

9.            mProfiler.startProfiling();

10.        }

12.        // Make sure we are running with the most recent config.

13.        handleConfigurationChanged(null, null);

15.        if (localLOGV) Slog.v(

16.            TAG, "Handling launch of " + r);

18.        // 在初始化activity前进行处理

19.        WindowManagerGlobal.initialize();

21.               //真正执行activity的方法

22.         Activity a = performLaunchActivity(r, customIntent);

24.        if (a != null) {

25.            r.createdConfig = new Configuration(mConfiguration);

26.            reportSizeConfigurations(r);

27.            Bundle oldState = r.state;

28.            handleResumeActivity(r.token, false, r.isForward,

29.                    !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);

31.            if (!r.activity.mFinished && r.startsNotResumed) {

32.                // The activity manager actually wants this one to start out paused, because it

33.                // needs to be visible but isn't in the foreground. We accomplish this by going

34.                // through the normal startup (because activities expect to go through onResume()

35.                // the first time they run, before their window is displayed), and then pausing it.

36.                // However, in this case we do -not- need to do the full pause cycle (of freezing

37.                // and such) because the activity manager assumes it can just retain the current

38.                // state it has.

39.                performPauseActivityIfNeeded(r, reason);

41.                // We need to keep around the original state, in case we need to be created again.

42.                // But we only do this for pre-Honeycomb apps, which always save their state when

43.                // pausing, so we can not have them save their state when restarting from a paused

44.                // state. For HC and later, we want to (and can) let the state be saved as the

45.                // normal part of stopping the activity.

46.                if (r.isPreHoneycomb()) {

47.                    r.state = oldState;

48.                }

49.            }

50.        } else {

51.            // If there was an error, for any reason, tell the activity manager to stop us.

52.            try {

53.                ActivityManagerNative.getDefault()

54.                    .finishActivity(r.token, Activity.RESULT_CANCELED, null,

55.                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY);

56.            } catch (RemoteException ex) {

57.                throw ex.rethrowFromSystemServer();

58.            }

59.        }

60.    }

真正启动activity的方法

1.    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {    

2.        // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

4.        ActivityInfo aInfo = r.activityInfo;

5.        if (r.packageInfo == null) {

6.            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,

7.                    Context.CONTEXT_INCLUDE_CODE);

8.        }

10.             //拿到Component信息

11.         ComponentName component = r.intent.getComponent();

12.        if (component == null) {

13.            component = r.intent.resolveActivity(

14.                mInitialApplication.getPackageManager());

15.            r.intent.setComponent(component);

16.        }

18.        if (r.activityInfo.targetActivity != null) {

19.            component = new ComponentName(r.activityInfo.packageName,

20.                    r.activityInfo.targetActivity);

21.        }

23.        Activity activity = null;

24.        try {


25.         //通过反射方式实例化ClassLoader,然后再反射实例化activity


26.            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();

27.            activity = mInstrumentation.newActivity(

28.                    cl, component.getClassName(), r.intent);

29.            StrictMode.incrementExpectedActivityCount(activity.getClass());

30.            r.intent.setExtrasClassLoader(cl);

31.            r.intent.prepareToEnterProcess();

32.            if (r.state != null) {

33.                r.state.setClassLoader(cl);

34.            }

35.        } catch (Exception e) {

36.            if (!mInstrumentation.onException(activity, e)) {

37.                throw new RuntimeException(

38.                    "Unable to instantiate activity " + component

39.                    + ": " + e.toString(), e);

40.            }

41.        }

43.        try {


44.          //获取Application对象


45.            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

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

48.            if (localLOGV) Slog.v(

49.                    TAG, r + ": app=" + app

50.                    + ", appName=" + app.getPackageName()

51.                    + ", pkg=" + r.packageInfo.getPackageName()

52.                    + ", comp=" + r.intent.getComponent().toShortString()

53.                    + ", dir=" + r.packageInfo.getAppDir());

55.            if (activity != null) {

56.                Context appContext = createBaseContextForActivity(r, activity);

57.                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());

58.                Configuration config = new Configuration(mCompatConfiguration);

59.                if (r.overrideConfig != null) {

60.                    config.updateFrom(r.overrideConfig);

61.                }

62.                if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "

63.                        + r.activityInfo.name + " with config " + config);

64.                Window window = null;

65.                if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {

66.                    window = r.mPendingRemoveWindow;

67.                    r.mPendingRemoveWindow = null;

68.                    r.mPendingRemoveWindowManager = null;

69.                }


70.              //将application对象和activity进行绑定


71.                activity.attach(appContext, this, getInstrumentation(), r.token,

72.                        r.ident, app, r.intent, r.activityInfo, title, r.parent,

73.                        r.embeddedID, r.lastNonConfigurationInstances, config,

74.                        r.referrer, r.voiceInteractor, window);

76.                if (customIntent != null) {

77.                    activity.mIntent = customIntent;

78.                }

79.                r.lastNonConfigurationInstances = null;

80.                activity.mStartedActivity = false;

81.                int theme = r.activityInfo.getThemeResource();

82.                if (theme != 0) {

83.                    activity.setTheme(theme);

84.                }

86.                activity.mCalled = false;


87.              //调用activity的onCreate()方法


88.                if (r.isPersistable()) {

89.                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);

90.                } else {

91.                    mInstrumentation.callActivityOnCreate(activity, r.state);

92.                }

93.                if (!activity.mCalled) {

94.                    throw new SuperNotCalledException(

95.                        "Activity " + r.intent.getComponent().toShortString() +

96.                        " did not call through to super.onCreate()");

97.                }

98.                r.activity = activity;

99.                r.stopped = true;

100.                if (!r.activity.mFinished) {

101.                    activity.performStart();

102.                    r.stopped = false;

103.                }

104.                if (!r.activity.mFinished) {

105.                    if (r.isPersistable()) {

106.                        if (r.state != null || r.persistentState != null) {

107.                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,

108.                                    r.persistentState);

109.                        }

110.                    } else if (r.state != null) {

111.                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);

112.                    }

113.                }

114.                if (!r.activity.mFinished) {

115.                    activity.mCalled = false;

116.                    if (r.isPersistable()) {

117.                        mInstrumentation.callActivityOnPostCreate(activity, r.state,

118.                                r.persistentState);

119.                    } else {

120.                        mInstrumentation.callActivityOnPostCreate(activity, r.state);

121.                    }

122.                    if (!activity.mCalled) {

123.                        throw new SuperNotCalledException(

124.                            "Activity " + r.intent.getComponent().toShortString() +

125.                            " did not call through to super.onPostCreate()");

126.                    }

127.                }

128.            }

129.            r.paused = true;

131.            mActivities.put(r.token, r);

133.        } catch (SuperNotCalledException e) {

134.            throw e;

136.        } catch (Exception e) {

137.            if (!mInstrumentation.onException(activity, e)) {

138.                throw new RuntimeException(

139.                    "Unable to start activity " + component

140.                    + ": " + e.toString(), e);

141.            }

142.        }

144.        return activity;

145.    }

进入Instrumentation类，看下activity的oncreate方法是如何调用的

1.    public void callActivityOnCreate(Activity activity, Bundle icicle,

2.            PersistableBundle persistentState) {

3.        prePerformCreate(activity);


4.       //activity方法调用


5.        activity.performCreate(icicle, persistentState);

6.        postPerformCreate(activity);

7.    }

1.    final void performCreate(Bundle icicle) {

2.        restoreHasCurrentPermissionRequest(icicle);

3.        onCreate(icicle);

4.        mActivityTransitionState.readState(icicle);

5.        performCreateCommon();

6.    }

最后是我们熟悉的onCreate()方法

1.    protected void onCreate(@Nullable Bundle savedInstanceState) {

2.        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onCreate " + this + ": " + savedInstanceState);

3.        if (mLastNonConfigurationInstances != null) {

4.            mFragments.restoreLoaderNonConfig(mLastNonConfigurationInstances.loaders);

5.        }

6.        if (mActivityInfo.parentActivityName != null) {

7.            if (mActionBar == null) {

8.                mEnableDefaultActionBarUp = true;

9.            } else {

10.                mActionBar.setDefaultDisplayHomeAsUpEnabled(true);

11.            }

12.        }

13.        if (savedInstanceState != null) {

14.            Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);

15.            mFragments.restoreAllState(p, mLastNonConfigurationInstances != null

16.                    ? mLastNonConfigurationInstances.fragments : null);

17.        }

18.        mFragments.dispatchCreate();

19.        getApplication().dispatchActivityCreated(this, savedInstanceState);

20.        if (mVoiceInteractor != null) {

21.            mVoiceInteractor.attachActivity(this);

22.        }

23.        mCalled = true;

24.    }

总结：通过的源码分析，我们了解了一个应用程序的入口不是Activity的onCreate()方法，而是ActivityThread的main()方法，在该方法中会通过AMS来将ApplicationThread和ams进行绑定，之后又调用了ApplicationThread的scheduleLaunchActivity()方法通过handler发送通知实例化activity，并最后调用了Activity的onCreate()方法。

原文链接：http://www.apkbus.com/blog-689749-68279.html