应用进程被zygote创建后，会调用ActivityThread的main方法，进入应用主流程
ActivityThread.main()
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
//初始化Looper和消息队列
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
- 主要完成Looper的初始化和消息循环的进入
- 创建ActivityThread，并attach
ActivityThread.attach
private void attach(boolean system) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
ViewRootImpl.addFirstDrawHandler(new Runnable() {
@Override
public void run() {
ensureJitEnabled();
}
});
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
//与AMS通信，注册AppThread
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
// Ignore
}
// Watch for getting close to heap limit.
//低内存情况下，回收该进程的一些Activity
BinderInternal.addGcWatcher(new Runnable() {
@Override public void run() {
if (!mSomeActivitiesChanged) {
return;
}
Runtime runtime = Runtime.getRuntime();
long dalvikMax = runtime.maxMemory();
long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
if (dalvikUsed > ((3*dalvikMax)/4)) {
if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
+ " total=" + (runtime.totalMemory()/1024)
+ " used=" + (dalvikUsed/1024));
mSomeActivitiesChanged = false;
try {
mgr.releaseSomeActivities(mAppThread);
} catch (RemoteException e) {
}
}
}
});
} else {
....
}
// add dropbox logging to libcore
DropBox.setReporter(new DropBoxReporter());
ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
@Override
public void onConfigurationChanged(Configuration newConfig) {
synchronized (mResourcesManager) {
// We need to apply this change to the resources
// immediately, because upon returning the view
// hierarchy will be informed about it.
if (mResourcesManager.applyConfigurationToResourcesLocked(newConfig, null)) {
// This actually changed the resources! Tell
// everyone about it.
if (mPendingConfiguration == null ||
mPendingConfiguration.isOtherSeqNewer(newConfig)) {
mPendingConfiguration = newConfig;
sendMessage(H.CONFIGURATION_CHANGED, newConfig);
}
}
}
}
@Override
public void onLowMemory() {
}
@Override
public void onTrimMemory(int level) {
}
});
}
在attach中，通过Binder通信，调用到AMS中,将应用进程的通信对象ApplicationThread注册到ams中
AMS.attachApplication
@Override
public final void attachApplication(IApplicationThread thread) {
logAppLaunchTime(TAG, "attachApplication +"); /// M: It's for debugging App Launch time
/// M: AMS log enhancement @{
if (!IS_USER_BUILD)
Slog.d(TAG, "ACT-attachApplication pid " + Binder.getCallingPid() + " to thread " + thread);
/// @}
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
logAppLaunchTime(TAG, "attachApplication -"); /// M: It's for debugging App Launch time
}
thread是应用层传递的binder对象，后续AMS通过改对象与应用层进行通信。
AMS.attachApplicationLocked
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
ProcessRecord app;
// 根据PID映射应用进程的ProcessRecord对象
if (pid != MY_PID && pid >= 0) {
synchronized (mPidsSelfLocked) {
app = mPidsSelfLocked.get(pid)
}
} else {
app = null;
}
if (app == null) {
// 获取ProcessRecord对象失败，则做一些清理操作后退出
if (pid > 0 && pid != MY_PID) {
Process.killProcessQuiet(pid)
} else {
thread.scheduleExit();
}
return false;
}
if (app.thread != null) {
// ProcessRecord对象之前绑定的进程还则，而当下需要将ProcessRecord绑定到一个新的进程
// 所以需要将之前ProcessRecord所绑定的进程信息清除
handleAppDiedLocked(app, true, true);
}
final String processName = app.processName;
try {
// 注册应用进程的DeathRecipient，当应用进程崩溃时，系统进程可以收到通知
AppDeathRecipient adr = new AppDeathRecipient(
app, pid, thread);
thread.asBinder().linkToDeath(adr, 0);
app.deathRecipient = adr;
} catch (RemoteException e) {
app.resetPackageList(mProcessStats);
startProcessLocked(app, "link fail", processName);
return false;
}
// 将ProcessRecord对象绑定到应用进程，这是ProcessRecord就变成了“激活”状态
app.makeActive(thread, mProcessStats);
app.curAdj = app.setAdj = -100;
app.curSchedGroup = app.setSchedGroup = Process.THREAD_GROUP_DEFAULT;
app.forcingToForeground = null;
updateProcessForegroundLocked(app, false, false);
app.hasShownUi = false;
app.debugging = false;
app.cached = false;
app.killedByAm = false;
mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
// 获取应用进程的所有Provider
List<ProviderInfo> providers = normalMode ? generateApplicationProvidersLocked(app) : null;
try {
... // 省略debug和性能相关的代码
// 发起跨进程调用，将一堆的信息传递给应用进程
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);
} catch (Exception e) {...}
mPersistentStartingProcesses.remove(app);
mProcessesOnHold.remove(app);
boolean badApp = false;
boolean didSomething = false;
if (normalMode) {
try {
// 调度Activity
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
badApp = true;
}
}
if (!badApp) {
try {
// 调度Service
didSomething |= mServices.attachApplicationLocked(app, processName);
} catch (Exception e) {
badApp = true;
}
}
if (!badApp && isPendingBroadcastProcessLocked(pid)) {
try {
// 调度Broadcast
didSomething |= sendPendingBroadcastsLocked(app);
} catch (Exception e) {
badApp = true;
}
}
if (!badApp && mBackupTarget != null && mBackupTarget.appInfo.uid == app.uid) {
... // 省略Backup相关的代码
}
if (badApp) {
app.kill("error during init", true);
handleAppDiedLocked(app, false, true);
return false;
}
if (!didSomething) {
updateOomAdjLocked();
}
return true;
}
该函数的实现逻辑如下：
-
获取ProcessRecord对象。通过Binder.getCallingPid()可以获取Binder接口的调用者所在进程的PID 进一步，通过PID，就能获取到应用进程对应的ProcessRecord。如果ProcessRecord对象获取失败，则表示应用进程已经被杀掉，需要清除应用进程的数据；如果ProcessRecord之前所绑定的进程信息还在，则需要清除这些信息；
-
为应用进程注册AppDeathRecipient，它是存在于系统进程的对象，当应用进程被杀掉的时候，系统进程会收到通知；
-
激活ProcessRecord对象。所谓“激活”，就是ProcessRecord已经绑定到了一个应用进程，绑定的标识就是：应用进程的ApplicationThread对象赋值给ProcessRecord.thread变量；
-
获取应用进程中所有注册的Provider，这需要通过PackageManager来扫描进程所关联的包名，所有静态的Provider信息，即ProviderInfo对象，都会保存到ProcessRecord.pubProviders变量中;
在系统进程启动时，也曾经历过这个过程，系统进程对应的包名是”android”，扫描的是framework-res.apk的这个应用的信息。
-
进行一些调试与性能相关的变量设置之后，通过IApplicationThread.bindApplication() 发起跨进程调用，这样一来，诸如进程名、ApplicationInfo等信息就传递给应用进程了；
-
将信息传递给应用程序以后，就可以进行调度了。这里通过两个标识来记录调度的情况：badApp标识是否调度失败，默认为false，在依次调度Activity、Service和Broadcast的过程中，根据实际的情况，可能将其调整为true，表示调度失败了。一旦调度失败，则需要杀掉应用进程；didSomething表示确有调度发生。在后文中，我们将着重分析Activity的调度，即ASS.attachApplicationLocked()函数。
ApplicationThread.bindApplication
public final void bindApplication(String processName, ApplicationInfo appInfo,
List<ProviderInfo> providers, ComponentName instrumentationName,
ProfilerInfo profilerInfo, Bundle instrumentationArgs,
IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection, int debugMode,
boolean enableOpenGlTrace, boolean isRestrictedBackupMode, boolean persistent,
Configuration config, CompatibilityInfo compatInfo, Map<String, IBinder> services,
Bundle coreSettings) {
//应用进程缓存servicemanager中的核心服务，例如pms，wms等服务
if (services != null) {
// Setup the service cache in the ServiceManager
ServiceManager.initServiceCache(services);
}
setCoreSettings(coreSettings);
/*
* Two possible indications that this package could be
* sharing its runtime with other packages:
*
* 1.) the sharedUserId attribute is set in the manifest,
* indicating a request to share a VM with other
* packages with the same sharedUserId.
*
* 2.) the application element of the manifest has an
* attribute specifying a non-default process name,
* indicating the desire to run in another packages VM.
*
* If sharing is enabled we do not have a unique application
* in a process and therefore cannot rely on the package
* name inside the runtime.
*/
IPackageManager pm = getPackageManager();
android.content.pm.PackageInfo pi = null;
try {
pi = pm.getPackageInfo(appInfo.packageName, 0, UserHandle.myUserId());
} catch (RemoteException e) {
}
if (pi != null) {
boolean sharedUserIdSet = (pi.sharedUserId != null);
boolean processNameNotDefault =
(pi.applicationInfo != null &&
!appInfo.packageName.equals(pi.applicationInfo.processName));
boolean sharable = (sharedUserIdSet || processNameNotDefault);
// Tell the VMRuntime about the application, unless it is shared
// inside a process.
if (!sharable) {//根据进程是否共享，注册appinfo，在共享的情况下，不能通过包名映射进程
VMRuntime.registerAppInfo(appInfo.packageName, appInfo.dataDir,
appInfo.processName);
}
}
//根据ams创建的传递的信息，创建AppBindData对象
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
data.instrumentationName = instrumentationName;
data.instrumentationArgs = instrumentationArgs;
data.instrumentationWatcher = instrumentationWatcher;
data.instrumentationUiAutomationConnection = instrumentationUiConnection;
data.debugMode = debugMode;
data.enableOpenGlTrace = enableOpenGlTrace;
data.restrictedBackupMode = isRestrictedBackupMode;
data.persistent = persistent;
data.config = config;
data.compatInfo = compatInfo;
data.initProfilerInfo = profilerInfo;
sendMessage(H.BIND_APPLICATION, data);
}
然后，通过handler发送message给ActivtyThread
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
ActivityThread.handleBindApplication
private void handleBindApplication(AppBindData data) {
mBoundApplication = data;
mConfiguration = new Configuration(data.config);
mCompatConfiguration = new Configuration(data.config);
...
// send up app name; do this *before* waiting for debugger
Process.setArgV0(data.processName);
android.ddm.DdmHandleAppName.setAppName(data.processName,
UserHandle.myUserId());
...
if (data.instrumentationName != null) {
....
//初始化ApplicationInfo和LoadedApk
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);
//实例化Instrumentation
try {
java.lang.ClassLoader cl = instrContext.getClassLoader();
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();
}
...
try {
// If the app is being launched for full backup or restore, bring it up in
// a restricted environment with the base application class.
//实例化Application
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
....
// Do this after providers, since instrumentation tests generally start their
// test thread at this point, and we don't want that racing.
try {
mInstrumentation.onCreate(data.instrumentationArgs);
}
catch (Exception e) {
}
//调用Applicaiton的onCreate方法
try {
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);
}
}
- 主要完成LoadedApk，Instrumentation和Application的初始化
- 通过Instrumentation调用Application的onCreate方法
总结
应用层：
-
主要完成Looper的初始化和消息循环的进入
-
创建ActivityThread，并attach
-
在attach中，通过Binder通信，调用到AMS的attachApplication中,将应用进程的通信对象ApplicationThread注册到ams中
AMS:
- 在AMS的attachApplicationLocked，主要是完成ProcessRecord的获取，将IApplicationThread赋值给ProcessRecord，并激活，
- 回调应用进程的bindApplication，传递进程信息到应用层
应用层：
-
在ApplicationThread的bindApplication，完成对PMS,wms远程服务的缓存
-
通过AMS传递的进程信息，创建AppBindData数据对象通过handler发送message给ActivtyThread
-
通过handler发送BIND_APPLICATION ，传递AppBindData给ActivtyThread
-
在ActivithThread中接受消息，调用到AMS的attachApplication中
-
完成LoadedApk，Instrumentation和Application的初始化
-
通过Instrumentation调用Application的onCreate方法
ActivityStackSupervisor.attachApplicationLocked
该函数取名为attachApplication()，意在将ASS绑定到应用进程; 也就是将ASS中的AcivityRecord绑定到一个应用进程呢？当然是AcivityRecord了。
启动HomeActivity创建了一个新的ActivityRecord，并将其挪到了HomeStack的栈顶位置，当时，ActivityRecord还没有关联到任何进程相关的信息，还不能被迁移到显示状态。当应用进程被创建之后，Activity才有了运行的机会，这时候才会真正调度ActivityRecord。
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 {
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (RemoteException e) { ... }
}
}
}
}
if (!didSomething) {
ensureActivitiesVisibleLocked(null, 0);
}
return didSomething;
}
该函数的实现逻辑与很多ASS的其他函数都类似：遍历寻找所有ActivityStack和TaskRecord，对栈顶的ActivityRecord进行操作。这里其实就是需要启动应用进程中还未启动的Activity。
ASS.realStartActivityLocked()
final boolean realStartActivityLocked(ActivityRecord r,
ProcessRecord app, boolean andResume, boolean checkConfig)
throws RemoteException {
...
r.app = app;
app.waitingToKill = null;
r.launchCount++;
r.lastLaunchTime = SystemClock.uptimeMillis();
...
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
new Configuration(stack.mOverrideConfig), r.compat, r.launchedFromPackage,
task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
...
if (andResume) {
stack.minimalResumeActivityLocked(r);
}
...
}
主要流程：
- 将ProcessRecord和ActivityRecord关联。ActivityRecord对象的app属性，就是ProcessRecord类型；
- 跨进程调用IApplicationThread.scheduleLaunchActivity()，调度启动Activity。很多参数都会通过这个函数传递到应用进程；
- 调用AS.minimalResumeActivityLocked()来显示Activity。
ApplicationThread.scheduleLaunchActivity
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
r.token = token;
r.ident = ident;
r.intent = intent;
r.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;
r.overrideConfig = overrideConfig;
updatePendingConfiguration(curConfig);
sendMessage(H.LAUNCH_ACTIVITY, r);
}
主要是根据AMS传递的Activity相关信息，初始化应用层ActivityClientRecord对象
ActivityThread.handleLaunchActivity()
应用进程在收到系统进程发起的scheduleLaunchActivity()请求后，便开始驱动Activity生命周期的运转了。
该函数的主要职能就是触发Activity生命周期的开始。代码片段如下：
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
unscheduleGcIdler();
mSomeActivitiesChanged = true;
if (r.profilerInfo != null) {
mProfiler.setProfiler(r.profilerInfo);
mProfiler.startProfiling();
}
handleConfigurationChanged(null, null);
WindowManagerGlobal.initialize();
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed);
if (!r.activity.mFinished && r.startsNotResumed) {
...
}
} else {
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null, false);
} catch (RemoteException ex) { ... }
}
}
- 在进行了一些参数设置后，便调用ActivityThread.performLaunchActivity()函数，初始化一个Activity。
- 调用ActivityThread.handleResumeActivity()来处理Activity进入显示状态时需要完成的操作；如果初始化失败，则发起跨进程调用IActivityManager.finishActivity()，来通报结束一个Activity的生命周期。
ActivityThread.performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
...
//调用mInstrumentation，通过反射实例化activity
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) {
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
Context appContext = createBaseContextForActivity(r, activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
+ r.activityInfo.name + " with config " + config);
//完成activity和ActivityClientRecord相关信息的绑定。窗口PhoneWindow的创建也是在
//次方法中完成的
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor);
...
//调用Activity的onCreate生命周期
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
//
r.activity = activity;
r.stopped = true;
//调用Activity的onStart生命周期
if (!r.activity.mFinished) {
activity.performStart();
r.stopped = false;
}
//OnRestoreInstanceState调用
if (!r.activity.mFinished) {
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);
}
}
//OnPostCreate调用
if (!r.activity.mFinished) {
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnPostCreate(activity, r.state,
r.persistentState);
} else {
mInstrumentation.callActivityOnPostCreate(activity, r.state);
}
}
r.paused = true;
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
}
return activity;
}
主要流程如下：
- 调用mInstrumentation，通过反射实例化activity
- 调用Activity的onCreate，onStart，OnRestoreInstanceState，OnPostCreate生命周期
ActivityThread.handleResumeActivity()
在Activity对象构建成功，并成功走完onCreate(), onStart()两个生命周期函数之后，便进入到这个阶段：Activity要进入onResume()的这个生命周期：
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume) {
unscheduleGcIdler();
mSomeActivitiesChanged = true;
// 实际执行应用进程一侧的Activity.onResume()
ActivityClientRecord r = performResumeActivity(token, clearHide);
if (r != null) {
... // 省略与WindownManager相关的窗口操作
if (reallyResume) {
// 通知系统进程，Activity已经处于Resumed状态
ActivityManagerNative.getDefault().activityResumed(token);
}
}
}
public final ActivityClientRecord performResumeActivity(IBinder token,
boolean clearHide) {
ActivityClientRecord r = mActivities.get(token);
if (r != null && !r.activity.mFinished) {
if (!r.paused && !r.stopped) {
Slog.w(TAG, "Skipping resume of activity that is already resumed");
return r;
}
if (clearHide) {
r.hideForNow = false;
r.activity.mStartedActivity = false;
}
try {
r.activity.onStateNotSaved();
r.activity.mFragments.noteStateNotSaved();
if (r.pendingIntents != null) {
deliverNewIntents(r, r.pendingIntents);
r.pendingIntents = null;
}
if (r.pendingResults != null) {
deliverResults(r, r.pendingResults);
r.pendingResults = null;
}
r.activity.performResume();
r.paused = false;
r.stopped = false;
r.state = null;
r.persistentState = null;
} catch (Exception e) {
}
}
return r;
}
真正调用生命周期的是performResumeActivity()函数，本文不展开分析了。有一点需要读者注意： 在调用onResume()之前，如果Activity已经处于Stopped状态，则会先调用onRestart()函数，在performResumeActivity()函数中，读者可以找到这部分逻辑。
当应用进程已经走完onResme()之后，便可通知系统进程：IActivityManager.activityResumed()，Activity已经进入Resumed状态了
