App 启动流程分析
Android中每一个App都在一个独立的空间，运行在一个单独的进程中，拥有一个vm，系统会分配一个唯一的user ID 如u0_a30，用来实现沙盒目录。
init进程会启动一个"Zygote"进程. 这个进程初始化了第一个VM, 并且预加载了framework和众多App所需要的通用资源. 然后它开启一个Socket接口来监听请求, 根据请求孵化出新的VM来管理新的App进程. 一旦收到新的请求, Zygote会基于自身预先加载的VM来孵化出一个新的VM创建一个新的进程. Zygote还会孵化出一个超级管理进程---System Server. SystemServer会启动所有系统核心服务: 引导服务(7个)：ActivityManagerService、PowerManagerService、LightsService、DisplayManagerService、PackageManagerService、UserManagerService、SensorService； 核心服务(3个)：BatteryService、UsageStatsService、WebViewUpdateService； 其他服务(70个+)：AlarmManagerService、VibratorService等。
启动App流程
启动一个App的方式
Intent intent = packageManager.getLaunchIntentForPackage(packname);
startActivity(intent);
或者
ComponentName cn = new ComponentName("com.example", "com.example.MainActivity");
startActivity(intent);启动一个应用时：都会调用startActivity(Intent)
Activity.startActivity
```
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
// 忽略...
// 这里mMainThread也是Activity类的成员变量，它的类型是ActivityThread，
// token是表示Activity
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
// 忽略...
}
```这里mMainThread也是Activity类的成员变量，它的类型是ActivityThread，mMainThread.getApplicationThread获得它里面的ApplicationThread成员变量，这个ApplicationThread实际上是一个Binder对象，是App所在的进程与AMS所在进程system_server通信的桥梁。 1. AMS会对Activity生命周期的管理以及任务栈的管理，通过Binder通信，这时AMS是Server端，App进程持有AMS的client端IActivityManagerSingleton进行通信 2. AMS在完成任务栈和生命周期管理后，回调App方法，这时AMS是client持有App的ApplicationThread进行通信
mToken是Activity中一个成员变量，AMS和Activity交互中并没有把Activity实例传入，而是使用mToken，可以唯一标示Activity。
Instrumentation.execStartActivity
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
// Binder对象，把这个句柄传给AMS，用来回调App进程方法
IApplicationThread whoThread = (IApplicationThread) contextThread;
// 忽略..
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}这里把App中Binder的Server端的ApplicationThread的句柄传给AMS，用于生命周期的回调等，如onPause。 通过Binder驱动，就进入过AMS的startActivity方法
ActivityManagerService 通知当前进程进入pause状态
AMS在system_server进程中，由于AMS中代码太多了，我们这里就不全部展开讲了，大概的说一下。有兴趣的可以去看一下老罗的文章。 在AMS会新创建一个栈Task，并通过ApplicationThread的句柄通知当前Activity进入paused状态
回到ActivityThread中
public final class ActivityThread {
// ......
private class ApplicationThread extends IApplicationThread.Stub {
// ......
public final void schedulePauseActivity(IBinder token, boolean finished,
boolean userLeaving, int configChanges, boolean dontReport) {
int seq = getLifecycleSeq();
if (DEBUG_ORDER) Slog.d(TAG, "pauseActivity " + ActivityThread.this
+ " operation received seq: " + seq);
// 这里的finished为false
// token 代表要pause的Activity
sendMessage(
finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
token,
(userLeaving ? USER_LEAVING : 0) | (dontReport ? DONT_REPORT : 0),
configChanges,
seq);
}
// 忽略..
}
private class H extends Handler {
public void handleMessage(Message msg) {
// ......
case PAUSE_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
SomeArgs args = (SomeArgs) msg.obj;
handlePauseActivity((IBinder) args.arg1, false,
(args.argi1 & USER_LEAVING) != 0, args.argi2,
(args.argi1 & DONT_REPORT) != 0, args.argi3);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
// ......
}
}
private void handlePauseActivity(IBinder token, boolean finished,boolean userLeaving, int configChanges, boolean dontReport, int seq) {
// ......
// 获取ActivityClientRecord
ActivityClientRecord r = mActivities.get(token);
// 调用Activity的onPause
performPauseActivity(token, finished, r.isPreHoneycomb(), "handlePauseActivity");
// ......
// 通知AMS已经暂停, 可以继续AMS还没完成的事，启动新的Activity
if (!dontReport) {
try {
ActivityManager.getService().activityPaused(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
// ......
}通知AMS已经暂停，启动新的App
暂停当前Activity后，通知AMS已经暂停, 可以继续AMS还没完成的事，启动新的App，主要是调用了Process.start函数，通过LocalSocket和ZygoteServer通信，fork一个新的进程。注意这里使用的是Socket通信，并不是Binder。因为zygote进程内加载了preload()方法中的所有资源，当需要fork新进程时，采用copy on write技术，所以fork出的新进程可以直接使用预加载的资源，并调用ZygoteInit.nativeZygoteInit()执行Binder驱动程序初始化的相关工作了，才使得进程中的Binder对象能够顺利地进行Binder进程间通信，最后执行新进程中的android.app.ActivityThread类中的Main函数，在main函数调用了attach，接着有调用AMS的attachApplication，用于生命周期的回调。
public final class ActivityThread {
// ......
public static void main(String[] args) {
// ......
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
Looper.loop();
// ......
}
private void attach(boolean system) {
// ......
final IActivityManager mgr = ActivityManager.getService();
try {
// 把mAppThread传给AMS，用来进程通信，进入AMS的attachApplication函数中
mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
// ......
}
}创建Application
通过Binder驱动程序，执行流程又回到AMS中，调用ActivityManagerService的attachApplication函数中，主要做了2件事 1. 通过Binder驱动程序调用ApplicationThread的bindApplication。 2. 通过Binder驱动调用ApplicationThread的scheduleLaunchActivity。
public class ActivityManagerService ... {
// ......
@Override
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
// ......
private final boolean attachApplicationLocked(IApplicationThread thread,int pid) {
thread.bindApplication(processName, appInfo, providers,
app.instr.mClass,
profilerInfo, app.instr.mArguments,
app.instr.mWatcher,
app.instr.mUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial);
// ......
if (normalMode) {
try {
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
// ......
}
}通过Binder驱动程序调用ApplicationThread的bindApplication。然后利用mH.sendMessage最终会执行到ActivityThread中handleBindApplication函数，在这个函数主要是创建了Application，并调用了attach和onCreate方法。
public final class ActivityThread {
// ......
private void handleBindApplication(AppBindData data) {
Application app;
// ......
try {
// ......
data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
// 创建Application并调用了attach方法
app = data.info.makeApplication(data.restrictedBackupMode, null);
// 把app赋给全局变量
mInitialApplication = app;
// ......
// 调用了onCreate方法
mInstrumentation.callApplicationOnCreate(app);
}
// ......
}
public final class LoadedApk {
public Application makeApplication(boolean forceDefaultAppClass,Instrumentation instrumentation) {
Application app = null;
String appClass = mApplicationInfo.className;
// forceDefaultAppClass为false，如果没有没有指定就会加载默认的
if (forceDefaultAppClass || (appClass == null)) {
appClass = "android.app.Application";
}
try {
java.lang.ClassLoader cl = getClassLoader();
// ...... 创建一个Context对象
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
// 调用Instrumentation的newApplication
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
// ......
}
mActivityThread.mAllApplications.add(app);
mApplication = app;
}
}
public class Instrumentation {
static public Application newApplication(Class<?> clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
app.attach(context);
return app;
}
}创建Activity
通过Binder驱动程序调用ApplicationThread的scheduleLaunchActivity。然后利用mH.sendMessage最终会执行到ActivityThread中handleLaunchActivity函数，在这个函数主要是创建了Activity，并调用了attach和onCreate等生命周期方法。
public final class ActivityThread {
private class ApplicationThread extends IApplicationThread.Stub {
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);
// 发送msg，在H.handleMessage响应
sendMessage(H.LAUNCH_ACTIVITY, r);
}
}
private class H extends Handler {
public void handleMessage(Message msg) {
// ......
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
// ......
}
}
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
// ..... 创建Activity, 并调用onCreate, onStart, onPostCreate以及onRestoreInstanceState(分情况调用),
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
// ...... 调用onResume, onPostResume
handleResumeActivity(r.token, false, r.isForward,!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
// ......
}
}调用performLaunchActivity，创建Activity, 并调用onCreate, onStart, onPostCreate以及onRestoreInstanceState(分情况调用), 接下来我们继续看：
public final class ActivityThread {
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// ...... 创建Context
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
// 实例化一个Activity对象
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
// ......
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
// ......
}
// ......
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
// ......初始化Activity成员变量
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, window, r.configCallback);
// ...... 调用Activity的onCreate函数
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
// ...... 调用Activity的onStart函数
if (!r.activity.mFinished) {
activity.performStart();
r.stopped = false;
}
// ...... 调用Activity的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);
}
}
// ...... 调用Activity的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.activity = activity;
// ...... 添加到集合中，token是key
mActivities.put(r.token, r);
}
}调用handleResumeActivity，调用onResume, onPostResume生命周期方法，然后调用makeVisible, 添加View到WindowManager，WindowManager的实现类是WindowManagerImpl，WindowManagerImpl的addView又调用了WindowManagerGloble.addView, 创建ViewRootImpl对象，并调用了setView函数。(有点扯远了，有兴趣的小伙伴可以去看看)，
当线程空闲的时候，调用AMS的activityIdle，最终会调回ApplicationThread.scheduleStopActivity.
最后Activity进入Resumed，并通知AMS
public final class ActivityThread {
public final ActivityClientRecord performResumeActivity(IBinder token,
boolean clearHide, String reason) {
// 根据token取出ActivityClientRecord
ActivityClientRecord r = mActivities.get(token);
// 调用onResume, onPostResume
r = performResumeActivity(token, clearHide, reason);
// .......
// 添加View到WindowManager
if (r.activity.mVisibleFromClient) {
r.activity.makeVisible();
}
if (!r.onlyLocalRequest) {
r.nextIdle = mNewActivities;
mNewActivities = r;
// ...... 当线程空闲时，调用AMS的activityIdle
Looper.myQueue().addIdleHandler(new Idler());
}
r.onlyLocalRequest = false;
通知AMS, Activity已经进入了resumed状态
if (reallyResume) {
try {
ActivityManager.getService().activityResumed(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}到这里一个新的App，就完成启动了，整个App启动过程执行了很多步骤，最后画个图，帮助大家理解。
参考链接:
https://blog.csdn.net/luoshengyang/article/details/6689748blog.csdn.net播客地址
木易杨的博客 | YGS Blogshineygs.github.io
408
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
