Android启动（七）应用进程的启动过程
该流程内部包含activity的启动过程
场景描述
当点击桌面的图标到展示打开应用的MainActivity
也可以称作是MainActivity的启动过程,因为这里说的是应用的启动过程,所以下文中的Activity 可以理解为MainActivity(应用的第一个页面)
- 如果不了解Activity栈管理相关类 可以参看Activity栈管理类
步骤分析
这里我们先规划下总体步骤方便后面看起来好理解
- 点击Launcher图标，执行Launcher内的OnClick，获取AMS的Binder代理对象，该对象利用Binder驱动通知AMS要启动一个Activity(MainActiity)的消息.
- (AMS管理启动Activity)AMS接收到消息之后，开始管理启动MainActivity的工作，并通过Binder驱动通知给Launcher自己要创建Activity需要launcer进入Paused状态，当Launcher进入paused状态之后,就开始启动Activity
- 启动Activity，判断当前的Activity所属的应用进程是否存在
- 若存在，则执行
realStartActivityLocked方法去启动准备好的Activity - 若不存在，则需要执行
Service.startProcessLocked,AMS通过binder驱动通知Zygot先创建一个进程，启动一个ActivityThread，将要启动的Activity就该ActivityThread中运行,- 在进程启动过程中，执行ActivityThrad#main方法通过Binder给AMS传递了一个ApplicationThread类型的Binder对象,以便以后AMS能够通过这个Binder对象和ActivityThrad进行通信
- 一切准备好之后，ams开始检测是否有任务在等待当前进程运行，这里也就是我们的MainActiy，此时就去执行Activity的启动
- 若存在，则执行
- AMS利用binder通知ActivityThread来启动Activity
- 通过Handler发送Launcher_activity来启动Activity
- 先通过classsLoader加载activity
- 通过mInstrumentation执行Activity的onCreate
- mInstrumentation它用来监控应用程序和系统的交互。
- 通过Handler发送Launcher_activity来启动Activity
源码分析
1.1 点击Launcher执行OnClick方法
launcher本质上就是系统内的第一个应用，Luancher就是launcher程序的一个Activity,当我们点击Luancher上的图标的时候会执行到他的OnClick方法
Launcher的源码位置
packages/apps/Launcher2/src/com/android/launcher2/Launcher.java
public final class Launcher extends Activity
implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,
View.OnTouchListener {
public void onClick(View v) {
........
Object tag = v.getTag();
if (tag instanceof ShortcutInfo) {
// 打开桌面图标，获取intent
final Intent intent = ((ShortcutInfo) tag).intent;
int[] pos = new int[2];
v.getLocationOnScreen(pos);
intent.setSourceBounds(new Rect(pos[0], pos[1],
pos[0] + v.getWidth(), pos[1] + v.getHeight()));
//启动intent
boolean success = startActivitySafely(v, intent, tag);
...
}
}
}
boolean startActivitySafely(View v, Intent intent, Object tag) {
boolean success = false;
try {
//启动Activity
success = startActivity(v, intent, tag);
} catch (ActivityNotFoundException e) {
...
}
return success;
}
-
在
OnClick中获取了Intent-
这里的Intent信息就是MainActivity在AndroidManifest.xml中设置的
-
<activity android:name=".MainActivity" android:label="@string/app_name"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> -
表示它要启动的Activity为.MainActivity，并且是在一个新的栈中启动
-
-
后面调用
startActivitySafely来执行，内部调用的是StartActivity因为Launcher继承Activity所以也就是调用的Activity的StartActivity，最终会执行到startActivityForResult- 此时进入了获取AMs代理对象并通知AMS要启动activity
1.2 获取AMS代理通知AMS要启动Activity
startActivityForResult根据上文可知执行到了这里
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
····
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
···
}
}
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
................
int result = ActivityManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
..................
return null;
}
- 通过mInstrumentation.execStartActivity来启动Activity
mInstrumentation是Activity类的成员变量，它的类型是Intrumentation,它用来监控应用程序和系统的交互。- mMainThreadmMainThread也是Activity类的成员变量，它的类型是ActivityThread，它代表的是应用程序的主线程
- 这里通过
mMainThread.getApplicationThread()来获取它里面的ApplicationThread成员变量，它是一个Binder对象，后面ActivityManagerService会使用它来和ActivityThread来进行进程间通信。 - 这里我们需注意的是，这里的mMainThread代表的是Launcher应用程序运行的进程
- 这里通过
- mToken也是Activity类的成员变量，它是一个Binder对象的远程接口，也就是Launcher这个Activity里的一个Binder对象 也就是下文中的resultTo
1.2.1 获取AMS代理对象
通过
ActivityManager.getService()获取AMS的代理对象
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
//利用单例获取，通过Binder驱动获取amd的dialing对象
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
ActivityManager.getService()返回ActivityManagerService的代理对象- ActivityManagerService 实现了IActivityManager接口
- 调用代理对象的.startActivity方法通过Binder驱动就会执行Ams的
StartActivity了
1.2.2 通知AMS启动Activity
在
execStartActivity方法中，AMs的代理对象调用了start方法，通过Binder驱动就会执行AMS中的StartActivity
ActivityManager.getService().startActivity-》AMS.StartActivity()AMS源码位置
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
@Override
public final int startActivity(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho,
int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions){
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,resultWho, requestCode, startFlags, profilerInfo, bOptions,UserHandle.getCallingUserId());
}
- 此时AMS已经接收到了消息，开始进入第二步了，AMS管理启动Activity
2.1 AMS管理Activity
AMS源码位置
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo,
String resultWho,int requestCode,int startFlags, ProfilerInfo profilerInfo, Bundle bOptions,
int userId) {
return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
profilerInfo, null, null, bOptions, false, userId, null, null,
"startActivityAsUser");
}
- 简单的参数传递执行到了
ActivityStarter#startActivityMayWaitActivityStarter源码位置frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java
ActivityStarter#startActivityMayWait
final int startActivityMayWait(IApplicationThread caller, int callingUid,
String callingPackage, Intent intent,
String resolvedType,IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,IBinder resultTo,
String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, WaitResult outResult,Configuration globalConfig, Bundle bOptions,
boolean ignoreTargetSecurity, int userId,
IActivityContainer iContainer,
TaskRecord inTask, String reason) {
..................
boolean componentSpecified = intent.getComponent() != null;
..................
intent = new Intent(intent);
......................省略intent赋值部分
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId);
.....................
// 1 根据intent去收集需要启动的activity的信息，包名和要启动的MainActivity
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
ActivityOptions options = ActivityOptions.fromBundle(bOptions);
ActivityStackSupervisor.ActivityContainer container =
(ActivityStackSupervisor.ActivityContainer)iContainer;
..................
synchronized (mService) {
final ActivityStack stack;
if (container == null || container.mStack.isOnHomeDisplay()) {
stack = mSupervisor.mFocusedStack;
} else {
stack = container.mStack;
}
................................
final ActivityRecord[] outRecord = new ActivityRecord[1];
// 2
int res = startActivityLocked(caller, intent, ephemeralIntent, resolvedType,
aInfo, rInfo, voiceSession, voiceInteractor,
resultTo, resultWho, requestCode, callingPid,
callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,options, ignoreTargetSecurity, componentSpecified, outRecord, container,
inTask, reason);
return res;
}
}
- 在注释1 位置，获取Activity相关的信息，保存在ActivityInfo中
- 注释2 调用
startActivityLocked进一步操作 - 注释3 通知
通知launcher要启动Activity请进入paused
2.2 调用startActivityLocked进一步操作
ActivityStarter#startActivityLocked
int startActivityLocked(IApplicationThread caller, Intent intent,
Intent ephemeralIntent,String resolvedType,
ActivityInfo aInfo, ResolveInfo rInfo,
IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor,IBinder resultTo,
String resultWho, int requestCode, int callingPid,
int callingUid,String callingPackage, int realCallingPid,
int realCallingUid, int startFlags,ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
ActivityRecord[] outActivity, ActivityStackSupervisor.ActivityContainer container,
TaskRecord inTask, String reason) {
.................
mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo, voiceSession,
voiceInteractor, resultTo, resultWho, requestCode, callingPid, callingUid,
callingPackage, realCallingPid, realCallingUid, startFlags,options,
ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,container, inTask);
...................
return mLastStartActivityResult;
}
- 参数传递，执行一个
startActivity
2.2.1 创建ActivityRecord
private int startActivity(IApplicationThread caller, Intent intent,
Intent ephemeralIntent,String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,IVoiceInteractionSession voiceSession,
IVoiceInteractor voiceInteractor,IBinder resultTo,
String resultWho, int requestCode, int callingPid,
int callingUid,String callingPackage, int realCallingPid,
int realCallingUid, int startFlags,ActivityOptions options,
boolean ignoreTargetSecurity, boolean componentSpecified,
ActivityRecord[] outActivity,
ActivityStackSupervisor.ActivityContainer container,
TaskRecord inTask) {
int err = ActivityManager.START_SUCCESS;
// Pull the optional Ephemeral Installer-only bundle out of the options early.
final Bundle verificationBundle
= options != null ? options.popAppVerificationBundle() : null;
//从传进来的参数caller得到调用者的进程信息，并保存在callerApp变量中，
//这里就是Launcher应用程序的进程信息了。
ProcessRecord callerApp = null;
if (caller != null) {
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
................
}
}
................................
//保存launcher的binder对象
//参数resultTo是Launcher这个Activity里面的一个Binder对象
//通过它可以获得Launcher这个Activity的相关信息，保存在sourceRecord变量中。
ActivityRecord sourceRecord = null;
ActivityRecord resultRecord = null;
if (resultTo != null) {
sourceRecord = mSupervisor.isInAnyStackLocked(resultTo);
if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
"Will send result to " + resultTo + " " + sourceRecord);
if (sourceRecord != null) {
if (requestCode >= && !sourceRecord.finishing) {
resultRecord = sourceRecord;
}
}
}
.............
//创建即将要启动的Activity的相关信息，并保存在r变量中
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),resultRecord, resultWho,
requestCode, componentSpecified, voiceSession != null,
mSupervisor, container, options, sourceRecord);
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true, options, inTask, outActivity);
}
- 保存launcher的Binder对象
- 创建ActivityRecord 把要启动的Activity信息封装到里面
- 又执行了一个
startActivity
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
int result = START_CANCELED;
try {
mService.mWindowManager.deferSurfaceLayout();
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,startFlags, doResume,
options, inTask, outActivity);
} finally {
............
}
..................
return result;
}
- 参数传递执行
startActivityUnchecked
2.2.2 给创建的Activityrecord找到它的TaskRecord和ActivityStack
ActivityStarter#startActivityUnchecked
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
// 初始化ActivityStarter全局变量
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,voiceInteractor);
// 检测Activity是否启动模式，是否需要在新的栈中启动，对与新的进程、SingleTask、SingleInstance启动模式就需要在新的栈中启动, 一般是判断是否需要在mLaunchFlags中加入FLAG_ACTIVITY_NEW_TASK
computeLaunchingTaskFlags();
//检测当前栈
computeSourceStack();
//最终确定Task启动方式
mIntent.setFlags(mLaunchFlags);
// 判断是否应将新Activity插入到现有任务栈中
// 如果不需要，则返回null，如果需要，则返回该任务栈信息
ActivityRecord reusedActivity = getReusableIntentActivity();
//判断是否可以重新利用
if (reusedActivity != null) {
...............
if (reusedActivity.getTask().intent == null) {
//如果历史记录中有匹配的任务，找出应该将哪个放到前面
reusedActivity = setTargetStackAndMoveToFrontIfNeeded(reusedActivity);
//设置为当前栈顶或最先创建的活动
setTaskFromIntentActivity(reusedActivity);
}
//恢复当前focus的堆栈stack中的顶端活动对象top activity
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
return START_SUCCESS;
}
- 为待启动的ActivityRecord找到他对应的TaskRecord和ActivityStack;
2.2.3 恢复当前Stack中的顶端活动对象
ActivityStackSupervisor#resumeFocusedStackTopActivityLocked源码位置
frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
boolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack,
ActivityRecord target,
ActivityOptions targetOptions) {
//如果目标栈不为空且是焦点栈,则直接将准备的activityRecord设置为栈顶活动
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
//获取能运行的栈中的栈顶ActivityRecord
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || r.state != RESUMED) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.state == RESUMED) {
// Kick off any lingering app transitions form the MoveTaskToFront operation.
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
ActivityStack#resumeTopActivityUncheckedLocked
ActivityStack源码路径
frameworks/base/services/core/java/com/android/server/am/ActivityStack.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
boolean result = false;
//设置栈顶Activity
result = resumeTopActivityInnerLocked(prev, options);
return result;
}
2.2.4 暂停上一个Activity,并启动准备好的Activity
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
//暂停失去焦点的活动对象 如果是启动Launcher进程 这里不会做操作因为launcher之前没有activity
boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
if (mResumedActivity != null) {
if (DEBUG_STATES) Slog.d(TAG_STATES,
"resumeTopActivityLocked: Pausing " + mResumedActivity);
//准备暂定活动这里准备暂停的是Launcher
pausing |= startPausingLocked(userLeaving, false, next, false);
}
// 启动Activity
mStackSupervisor.startSpecificActivityLocked(next, true, true);
return true;
}
- 暂停上一个Activity
- 并启动准备好的Activity
3.1 启动Activity 判断进程是否存在
启动准备好的Activity
ActivityStackSupervisor.startSpecificActivityLocked
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running? 此活动的应用程序是否已在运行？
//1 获取即将启动的Activiy所在的应用程序进程
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
r.getStack().setLaunchTime(r);
//2 判断是否运行 运行 则执行 realStartActivityLocked
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
app.addPackage(r.info.packageName,
r.info.applicationInfo.versionCode,
mService.mProcessStats);
}
//3 启动Activity
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
}
}
//4 若没运行则 创建新的进程
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
- 获取即将启动的Activiy所在的应用程序进程
- 若存在启动Activity
- 不存在则创建进程，这里启动的是MainActivity 肯定是不存在的
3.2 AMS通知Zygote创建新的进程
AMS#startProcessLocked
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
String hostingType, ComponentName hostingName, boolean allowWhileBooting,
boolean isolated, boolean keepIfLarge) {
return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType,hostingName, allowWhileBooting,
isolated, 0 /* isolatedUid */,
keepIfLarge,null /* ABI override */,
null /* entryPoint */,
null /* entryPointArgs */,
null /* crashHandler */);
}
- 参数传递,内部又调用了一个
startProcessLocked继续执行
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName,
boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
long startTime = SystemClock.elapsedRealtime();
//创建processRecord
ProcessRecord app;
if (!isolated) {
//再次获取为空
app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
}
if (app == null) {
//创建ProcessRecord
app=newProcessRecordLocked(info, processName, isolated, isolatedUid);
}
//进入startProcess
startProcessLocked(
app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs);
return (app.pid != 0) ? app : null;
}
- 创建ProcessRecord ，执行
startProcessLocked - ProcessRecord 进程记录表 Android中一个ProcessRecord就代表记录了一个进程
- 内部存储了进程相关的信息
- ApplicationInfo info：AndroidManifest.xml中定义的Application信息
- IApplicationThread thread：
- 这个很重要，它是ApplicationThread的客户端是一个Binder对象，AMS就是通过这个对象给apk进程发送异步消息的（管理四大组件的消息），所以只有这个对象不为空的情况下，才代表apk进程可用
- …还有很多
- 内部存储了进程相关的信息
- 内部又调用了一个
startProcessLocked继续执行
private final void startProcessLocked(ProcessRecord app, String hostingType,
String hostingNameStr, String abiOverride,
String entryPoint, String[] entryPointArgs) {
//设置用户id
int uid = app.uid;
int[] gids = null;
int mountExternal = Zygote.MOUNT_EXTERNAL_NONE;
if (!app.isolated) {
/*
* 创建添加共享程序文件的gid 便于共享数据
*/
if (ArrayUtils.isEmpty(permGids)) {
gids = new int[3];
} else {
gids = new int[permGids.length + 3];
System.arraycopy(permGids, 0, gids, 3, permGids.length);
}
gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid));
gids[1] = UserHandle.getCacheAppGid(UserHandle.getAppId(uid));
gids[2] = UserHandle.getUserGid(UserHandle.getUserId(uid));
}
//如果entryPoint为空则赋值为ActivityThread,这里entryPoint是空的
boolean isActivityProcess = (entryPoint == null);
if (entryPoint == null) entryPoint = "android.app.ActivityThread";
// 通知zygote 启动进程
startResult = Process.start(entryPoint, app.processName, uid, uid, gids, debugFlags, mountExternal, app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,app.info.dataDir, invokeWith, entryPointArgs);
}
- 此时传递参数为ActivityThread，通知Zygote创建新进程
- 这里传递的ActivityThread类，是在后面调用ZygoteInit时调用其main方法，完成对AMS设置ApplicationThread,方便AMS和ActivityThrad沟通的
3.2.1 传递ActivityThread类，通知Zygote创建新进程
Process源码在
/frameworks/base/core/java/android/os/Process.javaProcess.start()
public class Process {
public static final ZygoteProcess zygoteProcess =new ZygoteProcess(ZYGOTE_SOCKET, SECONDARY_ZYGOTE_SOCKET);
//ZYGOTE_SOCKET = "zygote"; 在引用启动时我们创建了一个名为zygote的进程
//SECONDARY_ZYGOTE_SOCKET = "zygote_secondary";
public static final ProcessStartResult start(final String processClass,
final String niceName,
int uid, int gid, int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String abi,
String instructionSet,
String appDataDir,
String invokeWith,
String[] zygoteArgs) {
return zygoteProcess.start(processClass, niceName, uid, gid, gids,
debugFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
}
}
3.2.2 给zygote发送创建新进程请求
zygoteProcess.start
zygoteProcess源码在
/frameworks/base/core/java/android/os/ZygoteProcess.java
public final Process.ProcessStartResult start(final String processClass,
final String niceName,
int uid, int gid, int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String abi,
String instructionSet,
String appDataDir,
String invokeWith,
String[] zygoteArgs) {
try {
// 通过zygote 启动一个新的进程
//这里的processClass 表示将来要运行存在main函数的类，也就是上面传递进来的ActivityThread
return startViaZygote(processClass, niceName, uid, gid, gids,
debugFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
} catch (ZygoteStartFailedEx ex) {
}
}
3.2.2.1 给zygote发送参数列表和通讯状态
private Process.ProcessStartResult startViaZygote(final String processClass,
final String niceName,
final int uid, final int gid,
final int[] gids,
int debugFlags, int mountExternal,
int targetSdkVersion,
String seInfo,
String abi,
String instructionSet,
String appDataDir,
String invokeWith,
String[] extraArgs)
throws ZygoteStartFailedEx {
// 1 创建字符串列表argsForZygote ，并将启动应用进程的启动参数保存在argsForZygote中
ArrayList<String> argsForZygote = new ArrayList<String>();
// --runtime-args, --setuid=, --setgid=,
// and --setgroups= must go first
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
synchronized(mLock) {
//参数 zygoteState（与zygote的通讯状态），调用openZygoteSocketIfNeeded(),尝试打开Socket 连接到zygote 如果已经打开 就直接返回
// 参数二 就是要启动进程的参数列表
return zygoteSendArgsAndGetResult(/*2*/openZygoteSocketIfNeeded(abi), argsForZygote);
}
}
- 注释一 封装参数列表
- 注释二，尝试打开socket连接zygote
- 调用zygoteSendArgsAndGetResult 发送请求
3.2.2.1.1 打开Socket与zygote进行连接，获取连接通讯状态
// 尝试打开socket 与zygote进程连接 private ZygoteState // 尝试打开socket 与zygote进程连接
private ZygoteState openZygoteSocketIfNeeded(String abi) throws ZygoteStartFailedEx {
Preconditions.checkState(Thread.holdsLock(mLock), "ZygoteProcess lock not held");
if (primaryZygoteState == null || primaryZygoteState.isClosed()) {
try {
// 尝试与名字为zygote的进程连接 这种是位的
primaryZygoteState = ZygoteState.connect(mSocket);
} catch (IOException ioe) {
throw new ZygoteStartFailedEx("Error connecting to primary zygote", ioe);
}
}
//如果获取的进程abi 匹配则返回 zygote的连接状态
if (primaryZygoteState.matches(abi)) {
return primaryZygoteState;
}
// 如果zygote 的abi 不匹配就要尝试与名为zygote_secondary连接
// 区别在于
//名字为”zygote”的Socket是运行在位Zygote进程中的
//名字为“ zygote_secondary”的socket运行在位zygote进程中
if (secondaryZygoteState == null || secondaryZygoteState.isClosed()) {
secondaryZygoteState = ZygoteState.connect(mSecondarySocket);
}
}
-
ZygoteStates
-
与zygote进程通信的状态。
-
内部维护了 读写流等
-
final LocalSocket socket; //socket对象 final DataInputStream inputStream; //读取流 final BufferedWriter writer;//写入对象 final List<String> abiList;//abi列表 boolean mClosed;//是否关闭
-
3.2.2.1.2 发送消息给zygote
向zygote进程发送参数列表，该进程启动一个新的子进程并返回子进程的pid。
zygoteSendArgsAndGetResult
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
ZygoteState zygoteState, ArrayList<String> args)
throws ZygoteStartFailedEx {
try {
//检测参数格式
int sz = args.size();
for (int i = 0; i < sz; i++) {
if (args.get(i).indexOf('\n') >= 0) {
throw new ZygoteStartFailedEx("embedded newlines not allowed");
}
}
//将数据写入socket 的writer里这样zygote 就能接收到一个新的请求了
final BufferedWriter writer = zygoteState.writer;
final DataInputStream inputStream = zygoteState.inputStream;
writer.write(Integer.toString(args.size()));
writer.newLine();
for (int i = 0; i < sz; i++) {
String arg = args.get(i);
writer.write(arg);
writer.newLine();
}
writer.flush();
................
return result;
} catch (IOException ex) {
zygoteState.close();
throw new ZygoteStartFailedEx(ex);
}
}
- 在zygote进程启动 文章中我们说过，zygote 启动后 注册一个LocalSocketService 并开启了runSelectLoop循环来接收请求，现在请求来了，我们看下runSelectLoop
3.2.3 zygote进程接收,处理消息
####### 3.2.3.1 接收
ZygoteInit#runSelectLoop
ZygoteInit 源码位置frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
//文件描述符列表
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
//socket连接列表
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
fds.add(mServerSocket.getFileDescriptor());
peers.add(null);
// 开启while循环接收请求
while (true) {
for (int i = pollFds.length - 1; i >= 0; --i) {
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
if (i == 0) {
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
//获取当前ZygoteConnection，执行runOnce方法
boolean done = peers.get(i).runOnce(this);
if (done) {
peers.remove(i);
fds.remove(i);
}
}
}
}
}
- 在runOnce方法中处理
3.2.3.2 处理
/frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java
boolean runOnce(ZygoteServer zygoteServer) throws Zygote.MethodAndArgsCaller {
String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;
try {
//读取要启动进程的参数列表
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
//有异常则关闭连接
closeSocket();
return true;
}
if (args == null) {
//参数列表为空也关闭连接
closeSocket();
return true;
}
//将读取的参数 封装到Arguments对象里
try {
parsedArgs = new Arguments(args);
.......................................
//调用forkAndSpecialize fork 子进程
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids, parsedArgs.debugFlags,
rlimits,parsedArgs.mountExternal,
parsedArgs.seInfo,parsedArgs.niceName, fdsToClose,
fdsToIgnore,parsedArgs.instructionSet,
parsedArgs.appDataDir);
}
try {
if (pid == 0) {
// in child
zygoteServer.closeServerSocket();
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
//启动子进程
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
...........................
return true;
} else {
................
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}
- 读取要fork进程的参数列表
- 调用Zygote.forkAndSpecialize
- 调用handleChildProc启动子进程
3.3 fork子进程
Zygote.forkAndSpecialize
public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
int[][] rlimits, int mountExternal, String seInfo, String niceName, int[] fdsToClose,int[] fdsToIgnore, String instructionSet, String appDataDir) {
int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits,
mountExternal, seInfo, niceName, fdsToClose,
fdsToIgnore, instructionSet, appDataDir);
return pid;
}
//调用native方法来fork子进程
native private static int nativeForkAndSpecialize(int uid, int gid, int[] gids,
int debugFlags,int[][] rlimits,
int mountExternal, String seInfo, String niceName, int[] fdsToClose,
int[] fdsToIgnore, String instructionSet, String appDataDir);
- native方法实现在
/frameworks/base/core/jni/com_android_internal_os_Zygote.cpp中
3.4 启动子进程
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
private void handleChildProc(Arguments parsedArgs,FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
throws Zygote.MethodAndArgsCaller {
.......................
//调用zygoteInit来启动创建的程序
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs, null /* classLoader */);
}
ZygoteInit.zygoteInit
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
//通过Jni调用Native层的代码，给新的程序进程启动Binder线程池,这样进程就可以使用Binder来与其他进程进行通讯
ZygoteInit.nativeZygoteInit();
//applicationInit 启动进程
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
RuntimeInit.applicationInit
源码位置在
frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {
//执行传递进来执行文件的main方法 也就是ActiviytThrad的main
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
3.4.1 执行ThreadActivity #main
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
//获取主线程looper
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
//调用attach 绑定applicaiton
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//启动循环
Looper.loop();
}
3.4.2 给AMS 设置APPlicationThread
attach方法绑定Appliaciton binder 用来和ams通讯
调用Thread.bindApplicaiton，通过该ApplicationThread来通知ActivtyThread 创建绑定Application
// 实现stub接口是一个binder
final ApplicationThread mAppThread = new ApplicationThread();
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mSystemThread = system;
//获取Ams的代理对象，通过代理对象利用Binder驱动，将applicaitonBinder 传递给ams 这样ams 就能和app通讯
final IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
- 最终调用到了AMS的attachApplication
AMS#attachApplication
@Override
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
AMS#attachApplicationLocked
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
ProcessRecord app;
long startTime = SystemClock.uptimeMillis();
if (pid != MY_PID && pid >= 0) {
synchronized (mPidsSelfLocked) {
app = mPidsSelfLocked.get(pid);
}
//通知绑定AppLication
mStackSupervisor.mActivityMetricsLogger.notifyBindApplication(app);
//通知ActivityThread绑定application信息
if (app.instr != null) {
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);
} else {
thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(getGlobalConfiguration()), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial);
}
// See if the top visible activity is waiting to run in this process...
//查看是否有任务在等待当前进程运行,如果有就去启动
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
}
}
3.4.2.1 通知ActivityThread创建Application
调用thread.bindApplication通知ActivityThread创建Application
这里利用的是binder，执行的是ActivityThread中的
public final void bindApplication(String processName, ApplicationInfo appInfo,
List<ProviderInfo> providers, ComponentName instrumentationName,
ProfilerInfo profilerInfo, Bundle instrumentationArgs,
IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection, int debugMode,
boolean enableBinderTracking, boolean trackAllocation,
boolean isRestrictedBackupMode, boolean persistent, Configuration config,
CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
String buildSerial) {
//发送Bind_appLication
sendMessage(H.BIND_APPLICATION, data);
}
- 发送了BIND_APPLICATION给Handler
public void handleMessage(Message msg) {
switch (msg.what) {
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;
}
- 调用
handleBindApplication(data);
private void handleBindApplication(AppBindData data) {
try {
//创建Applicaton
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
try {
//调用Application的onCreate
mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
}
} finally {
StrictMode.setThreadPolicy(savedPolicy);
}
}
- 通过makeApplication创建Application
- 通过mInstrumentation.callApplicationOnCreate执行Application的OnCreate
3.4.2.2创建Application
makeApplication
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
//创建Application
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);
return app;
}
-
通过ActivityThread 的mInstrumentation创建Application
-
static public Application newApplication(Class<?> clazz, Context context) throws InstantiationException, IllegalAccessException, ClassNotFoundException { Application app = (Application)clazz.newInstance(); app.attach(context); return app; } final void attach(Context context) { attachBaseContext(context); mLoadedApk = ContextImpl.getImpl(context).mPackageInfo; }- 这里Application就创建完了，并绑定了context
- attach里面执行了attachBaseContext绑定了Context
- 因此attachBaseContext在OnCreate之前执行
3.4.3 查看是否有任务在等待当前进程运行,如果有就去启动
mStackSupervisor.attachApplicationLocked(app)
ActivitySupervisor#attachApplicationLocked
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);
...........
//获取栈顶的活动 也就是在fork 应用之前我们创建的MainActivity的record
ActivityRecord hr = stack.topRunningActivityLocked();
if (hr != null) {
//判断所属进程是否为空 进程名是否相同 就是为了确定属于当前进程
if (hr.app == null && app.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
try {
// 2 调用realStartActivityLocked启动当前活动
if (realStartActivityLocked(hr, app, true, true)) {
didSomething = true;
}
} catch (RemoteException e) {
}
}
}
}
}
}
- 获取栈顶的ActivityRecord
- 判断其是否存在运行条件
- 存在则调用realStartActivityLocked启动当前活动
4 启动Activity
#### 4.1 AMS 通知给ActivityThread
realStartActivityLocked
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
................
//在这里AMS通过ApplicationThread的binder对象,通过Binder驱动, 执行到了ActivityThread里的scheduleLaunchActivity
app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor,
app.repProcState, r.icicle,
r.persistentState, results, newIntents, !andResume,
mService.isNextTransitionForward(), profilerInfo);
}
- AMS通过ApplicationThread的binder对象,通过Binder驱动, 执行到了ActivityThread里的scheduleLaunchActivity
4.2 ActivityThread启动Activity
4.2.1 通过Handler 发送 LAUNCH_ACTIVITY 启动
ActivityThread#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();
// 发送一个LAUNCH_ACTIVITY 并将活动传递
sendMessage(H.LAUNCH_ACTIVITY, r);
}
4.2.2 Handler接收消息
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);
//调用HandleLauncheActivity启动
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
} break;
}
4.2.3 处理消息
handleLaunchActivity
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
// 创建Activity对象
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
//通知对象可见
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed,
r.lastProcessedSeq, reason);
} else {
//创建失败则关闭该activity
try {
ActivityManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
4.2.3.1 创建activity，执行Activity 的OnCreate
performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
//收集Activity相关信息，包信息，组件信息
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
//创建上下文
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
//通过类加载机制将Activity加载进来
java.lang.ClassLoader cl = appContext.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对象 当前进程内全局唯一
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
//attach内部首先调用了attachBaseContex绑定上下文信息,
//创建PhoneWindow并给其设置Windowmanager处理
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);
//通过mInstrumentation执行Activity的onCreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
.............
}
} catch (SuperNotCalledException e) {
.................
}
return activity;
}
-
通过类加载机制加载activity
-
通过调用Activity#attach 绑定上下文信息,创建PhoneWindow给Windowmanager处理
-
并通过Instrumentation的callActivityOnCreate方法来执行Activity的OnCreate
-
在oncreate中执行setContentView创建布局 在ActivityResume时 将布局添加到window
-
callActivityOnCreate
public void callActivityOnCreate(Activity activity, Bundle icicle, PersistableBundle persistentState) { prePerformCreate(activity); activity.performCreate(icicle, persistentState); postPerformCreate(activity); }- 内部通过
Activity#performCreate执行Activity的onCreate
final void performCreate(Bundle icicle) { restoreHasCurrentPermissionRequest(icicle); // 最后回调OnCrate方法 onCreate(icicle); mActivityTransitionState.readState(icicle); performCreateCommon(); } - 内部通过
4.2.3.2 执行onResume
在这里涉及到显示布局，也是就是Activtiy绘制这里仅点出 并不分析
在4.2.3.1中可知创建的Activity不为空.所以4.2.3后面执行了handleResumeActivity
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
ActivityClientRecord r = mActivities.get(token);
if (!checkAndUpdateLifecycleSeq(seq, r, "resumeActivity")) {
return;
}
r = performResumeActivity(token, clearHide, reason);
//.....................
if (r != null) {
final Activity a = r.activity;
//.........
//显示onCreate setContentView 创建的布局 通过wm.addview
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
//........
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
wm.addView(decor, l);
}
}
//...........
}
//通知AMS 该activity 已经可见并了
if (reallyResume) {
try {
ActivityManager.getService().activityResumed(token);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
}
- 上面代码主要作用
- 将onCreate创建的布局添加到window上展示
- 并通知AMS 该Activity已经可见了
至此应用启动结束。
738
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
