四大组件的工作过程
这篇文章只是对刘望舒大佬书籍的摘抄，适合复习用，没看过的请先看大佬的原书
下面是大佬博客的链接Android进阶三部曲 第二部《Android进阶解密》
一、根Activity的启动过程
Activity的启动分为两种一种是根Activity的启动过程，另一种是普通Activity的启动过程。根Activity指的是应用程序启动的第一个Activity，因此根Activity的启动过程也可以理解为应用程序的启动过程。普通Activity指的是除第一个Activity外其他的Activity。
Launcher请求AMS过程
Launcher桌面上应用程序的快捷图标就是启动根Activity的入口，当我们点击某个程序的快捷图标时，就会通过Launcher请求Ams来启动该应用程序。Launch请求Ams的时序图如下
当我们点击应用程序的图标时就会调用Launcher的startActivitySafely方法
/packages/apps/Launcher3/src/com/android/launcher3/Launcher.java
public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
//...
//将Flag设置为Intent.FLAG_ACTIVITY_NEW_TASK，根Activity就会在新的任务栈启动
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
if (v != null) {
intent.setSourceBounds(getViewBounds(v));
}
try {
if (Utilities.ATLEAST_MARSHMALLOW
&& (item instanceof ShortcutInfo)
&& (item.itemType == Favorites.ITEM_TYPE_SHORTCUT
|| item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT)
&& !((ShortcutInfo) item).isPromise()) {
startShortcutIntentSafely(intent, optsBundle, item);
} else if (user == null || user.equals(Process.myUserHandle())) {
// 调用Activity的startActivity方法
startActivity(intent, optsBundle);
} else {
LauncherAppsCompat.getInstance(this).startActivityForProfile(
intent.getComponent(), user, intent.getSourceBounds(), optsBundle);
}
return true;
} catch (ActivityNotFoundException|SecurityException e) {
...
}
return false;
}
/frameworks/base/core/java/android/app/Activity.java
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
// 调用startActivityForResult，第二个参数传入-1表示，不关心Activity的启动结果
startActivityForResult(intent, -1, options);
} else {
startActivityForResult(intent, -1);
}
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
//mParent是Activity的类型，表示当前Activity的父类，当前根Activity都没有所以成立
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
//调用Instrumentation的execStartActivity方法
Instrumentation的.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
...
} else {
...
}
}
最后调用了Instrumentation的execStartActivity方法，Instrumentation主要用来监控应用程序和系统的交互。
/frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
//...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
//通过ActivityManager.getService()获取AMS的代理对象，然后调用其startActivity方法
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;
}
execStartActivity方法首先通过通过ActivityManager.getService()获取AMS的代理对象，然后调用其startActivity方法，先看ActivityManager.getService方法
/frameworks/base/core/java/android/app/ActivityManager.java
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
//获得名称为"activity"的Service引用，此为IBinder类型的AMS类型
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
//通过aidl转为IActivityManager，这里的am为AMS的本地代理
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
ActivityManager.getService方法获得了AMS的本地代理，最后通过Binder的方法跨进程调用了AMS的startActivity方法
AMS到ApplicationThread的调用过程
/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());
}
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) {
//判断调用者进程是否被个例
enforceNotIsolatedCaller("startActivity");
//检查调用者权限
userId = mUserController.handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(),
userId, false, ALLOW_FULL_ONLY, "startActivity", null);
//最后交个ActivityStarter的startActivityMayWait方法处理
return mActivityStarter.startActivityMayWait(caller, -1, callingPackage, intent,
resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,
profilerInfo, null, null, bOptions, false, userId, null, null,
"startActivityAsUser");
}
/frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java
/**
* @para inTask启动的Activity所在的栈
* @param reason表示启动的理由
*/
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) {
...
//交给startActivityLocked方法
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;
}
}
ActivityStarter是Android7.0中加入的类，它是加载Activity的控制类，会收集所有的逻辑来决定如何将Intent和Flags转换为Activity，并将Activity和Task以及Stack相关联。
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) {
//判断启动的理由不为空
if (TextUtils.isEmpty(reason)) {
throw new IllegalArgumentException("Need to specify a reason.");
}
mLastStartReason = reason;
mLastStartActivityTimeMs = System.currentTimeMillis();
mLastStartActivityRecord[0] = null;
//交给startActivity方法
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);
if (outActivity != null) {
// mLastStartActivityRecord[0] is set in the call to startActivity above.
outActivity[0] = mLastStartActivityRecord[0];
}
return mLastStartActivityResult;
}
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;
ProcessRecord callerApp = null;
//判断caller是否为null，指向的是Launcher所在的应用程序进程的ApplicationThread对象
if (caller != null) {
//得到Launcher进程callerApp,它是ProcessRecord类型的，ProcessRecord用来描述一个应用程序进程
callerApp = mService.getRecordForAppLocked(caller);
if (callerApp != null) {
//获取Launcher进程的pid和uid
callingPid = callerApp.pid;
callingUid = callerApp.info.uid;
} else {
Slog.w(TAG, "Unable to find app for caller " + caller
+ " (pid=" + callingPid + ") when starting: "
+ intent.toString());
err = ActivityManager.START_PERMISSION_DENIED;
}
}
...
//创建即将启动的Activity的描述类ActivityRecord，ActivityRecord用于描述一个Activity，用来记录一个Activity的所有信息
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
mSupervisor, container, options, sourceRecord);
if (outActivity != null) {
//将创建的ActivityRecord复制给outActivity,outActivity会为作为后面方法的参数传递下去
outActivity[0] = r;
}
...
//
return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true,
options, inTask, outActivity);
}
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();
//继续调用startActivityUnchecked
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity);
} finally {
...
}
...
return result;
}
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity) {
...
if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
&& (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
newTask = true;
//创建新的TaskRecord,TaskRecord用来描述一个Activity的任务战,Activity任务栈是一个假想的模型，并不真实存在。
result = setTaskFromReuseOrCreateNewTask(
taskToAffiliate, preferredLaunchStackId, topStack);
} else if (mSourceRecord != null) {
result = setTaskFromSourceRecord();
} else if (mInTask != null) {
result = setTaskFromInTask();
} else {
setTaskToCurrentTopOrCreateNewTask();
}
...
if (mDoResume) {
final ActivityRecord topTaskActivity =
mStartActivity.getTask().topRunningActivityLocked();
if (!mTargetStack.isFocusable()
|| (topTaskActivity != null && topTaskActivity.mTaskOverlay
&& mStartActivity != topTaskActivity)) {
...
} else {
if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
mTargetStack.moveToFront("startActivityUnchecked");
}
//调用ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
}
} else {
mTargetStack.addRecentActivityLocked(mStartActivity);
}
...
}
/frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
//获取要启动的Activity所在栈的栈顶的不是处于停止状态的ActivityRecord
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || r.state != RESUMED) {
//如果Activity为null或者要启动的Activity的状态不是RESUMED就调用ActivityStack的resumeTopActivityUncheckedLocked方法。新启动的应用满足此条件
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.state == RESUMED) {
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
/frameworks/base/services/core/java/com/android/server/am/ActivityStack.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
if (mStackSupervisor.inResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean result = false;
try {
mStackSupervisor.inResumeTopActivity = true;
//调用resumeTopActivityInnerLocked
result = resumeTopActivityInnerLocked(prev, options);
} finally {
mStackSupervisor.inResumeTopActivity = false;
}
mStackSupervisor.checkReadyForSleepLocked();
return result;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
...
//调用ActivityStackSupervisor的startSpecificActivityLocked方法
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
return true;
}
/frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
//获取即将启动的Activity所在的应用程序进程
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
r.getStack().setLaunchTime(r);
if (app != null && app.thread != null) {
//要启动的Activity所在的应用程序进程如果已经运行的话
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);
}
//调用realStartActivityLocked方法
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
}
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
上面路径上应该写错了，根 Activity 启动时进程应该不存在走
mService.startProcessLocked这行代码，然后创建新的进程，最后在新进程启动 ActivityThread 后再调用 AMS 的 attachApplication ，然后 AMS 先是 调用 ActivityThread 的 bindApplication，然后再调用下面的方法，启动Activity
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
...
try {
...
//调用app.thread.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);
...
} catch (RemoteException e) {
...
}
...
return true;
}
最重调用app.thread的scheduleLaunchActivity方法。app.thread指的是IApplicationThread，它的实现是ActivityThread的内部类ApplicationThread，ApplicationThread继承了IApplicationThread.Stub。app指的要启动的Activity所在的应用程序进程。所以这里是要在目标应用进程启动Activity。
当前代码运行在AMS所在的进程(SystemServer 进程)，通过ApplicationThread来与应用程序进程进行Binder通信。也就是是说ApplicationThread是AMS所在进程和应用程序进程的通信桥梁如图
ActivityThread启动Activity的过程
ActivityThread启动Activity过程的时序图如下
首先是ApplicationThread的scheduleLaunchActivity方法
/frameworks/base/core/java/android/app/ActivityThread.java
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;
...
sendMessage(H.LAUNCH_ACTIVITY, r);
}
scheduleLaunchActivity方法将启动的参数封装成ActivityClientRecord，然后调用sendMessage方法向H发送消息类型为LAUNCH_ACTIVITY的消息，并将ActivityClientRecord传递过去
private void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1) {
sendMessage(what, obj, arg1, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2) {
sendMessage(what, obj, arg1, arg2, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
if (DEBUG_MESSAGES) Slog.v(
TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
+ ": " + arg1 + " / " + obj);
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
这里的mH就是H，它是ActivityThread的内部类并继承自Handler，是应用程序中主线程的消息管理类。由于ApplicationThread是一个Binder，它的调用逻辑运行在线程池中，所以这里需要用H将代码逻辑切换到主线程中。
private class H extends Handler {
public static final int LAUNCH_ACTIVITY = 100;
...
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
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
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
} break;
...
}
...
}
}
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
...
WindowManagerGlobal.initialize();
//启动Activity
Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
reportSizeConfigurations(r);
Bundle oldState = r.state;
//将Activity状态置为Resume
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
if (!r.activity.mFinished && r.startsNotResumed) {
performPauseActivityIfNeeded(r, reason);
if (r.isPreHoneycomb()) {
r.state = oldState;
}
}
} else {
//如果该Activity为null则会通知AMS停止启动Activity
try {
//停止Activity启动
ActivityManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//获取ActivityInfo类，ActivityInfo用于存储代码以及AndroidManifests设置的Activity和Receiver节点信息
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
//获取APK文件的描述符，
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
//获取要启动的Activity的，ComponentName类，ComponentName中保存了该Activity的包名和类名。
ComponentName component = r.intent.getComponent();
...
//创建要启动Activity的上下文环境
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
//用类加载器来创建该Activity的实例
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
...
} catch (Exception e) {
...
}
try {
//创建Application，makeApplication方法内部会调用Application的onCreate方法
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
...
if (activity != null) {
...
appContext.setOuterContext(activity);
//初始化Activity，attach会创建Window对象，并与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);
...
if (r.isPersistable()) {
//启动Activity
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
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);
}
}
...
r.paused = true;
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
...
}
return activity;
}
mInstrumentation.callActivityOnCreate会启动Activity
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
restoreHasCurrentPermissionRequest(icicle);
//调用onCreate生命周期
onCreate(icicle, persistentState);
mActivityTransitionState.readState(icicle);
performCreateCommon();
}
performCreate里面调用了Activity的onCreate生命周期方法，根Activity也就启动了
根Activity启动过程中涉及到的进程
根Activity启动过程中涉及4个进程，分别是Zygote进程，Launcher进程，AMS所在进程（SystemService进程）、应用程序进程，他们的关系如下
首先Launcher进程向AMS请求创建根Activity，AMS会判断根Activity所需的应用进程是否存在并启动，如果不存在就会请求Zygote进程创建应用程序进程。应用程序进程启动后，AMS会请求创建应用程序进程并启动Activity。
上图中步骤1和步骤4次啊用的是Binder通信。步骤2是Socket通信
下面是进程调用的时序图
如果是普通Activity启动过程只会涉及2个进程。AMS所在进程和应用程序进程
二、Service的启动过程
Service的启动过程和跟Activity的启动过程有部分相似的知识点。Service的启动过程分为ContextImpl到ActivityManagerService的调用过程和ActivityThread启动Service的过程两部分
ContextImpl到ActivityManagerService的调用过程
时序图如下
要启动Service，我们会调用startService方法，它在ContextWrapper中实现
/frameworks/base/core/java/android/content/ContextWrapper.java
public class ContextWrapper extends Context {
@Override
public ComponentName startService(Intent service) {
return mBase.startService(service);
}
}
这里交给了mBase，而我们需要知道mBase是什么
/frameworks/base/core/java/android/app/ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
//创建要启动Activity的上下文环境
ContextImpl appContext = createBaseContextForActivity(r);
...
try {
...
if (activity != null) {
...
//初始化Activity，调用attach方法与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);
...
}
...
} catch (SuperNotCalledException e) {
...
}
return activity;
}
createBaseContextForActivity创建了要启动Activity的上下文环境，在调用attach方法时传入并与Activity进行关联
private ContextImpl createBaseContextForActivity(ActivityClientRecord r) {
...
ContextImpl appContext = ContextImpl.createActivityContext(
this, r.packageInfo, r.activityInfo, r.token, displayId, r.overrideConfig);
...
return appContext;
}
上下文appContext的具体类型就是ContextImpl，在Activity的attach方法中将ContextImpl赋值给ContextWrapper的成员变量mBase，因此mBase的具体类型就是ContextImpl所以ContextWrapper的startService就是交给了ContextImpl的startService方法
/frameworks/base/core/java/android/app/ContextImpl.java
@Override
public ComponentName startService(Intent service) {
warnIfCallingFromSystemProcess();
return startServiceCommon(service, false, mUser);
}
private ComponentName startServiceCommon(Intent service, boolean requireForeground,
UserHandle user) {
try {
validateServiceIntent(service);
service.prepareToLeaveProcess(this);
//调用AMS的startService方法
ComponentName cn = ActivityManager.getService().startService方法(
mMainThread.getApplicationThread(), service, service.resolveTypeIfNeeded(
getContentResolver()), requireForeground,
getOpPackageName(), user.getIdentifier());
...
return cn;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
最后调用AMS的startService方法
ActivityThread 启动Service
ActivityThread 启动Service的时序图如下
首先是ActivityManagerService的startService方法
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public ComponentName startService(IApplicationThread caller, Intent service,
String resolvedType, boolean requireForeground, String callingPackage, int userId)
throws TransactionTooLargeException {
...
synchronized(this) {
final int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
ComponentName res;
try {
调用mServices的startServiceLocked方法，mServices的类型是ActiveServices
res = mServices.startServiceLocked(caller, service,
resolvedType, callingPid, callingUid,
requireForeground, callingPackage, userId);
} finally {
Binder.restoreCallingIdentity(origId);
}
return res;
}
}
/frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
ComponentName startServiceLocked(IApplicationThread caller, Intent service, String resolvedType,
int callingPid, int callingUid, boolean fgRequired, String callingPackage, final int userId)
throws TransactionTooLargeException {
...
//查找是否有与参数service对应的ServiceRecord,如果没找到就会调用PackageManagerService去获取service对应的Service信息
ServiceLookupResult res =retrieveServiceLocked(service, resolvedType, callingPackage,
callingPid, callingUid, userId, true, callerFg, false);
if (res == null) {
return null;
}
if (res.record == null) {
return new ComponentName("!", res.permission != null
? res.permission : "private to package");
}
//得到ServiceRecord，ServiceRecord用来描述一个Service，与ActivityRecord类似
ServiceRecord r = res.record;
...
//掉用startServiceInnerLocked启动service
ComponentName cmp = startServiceInnerLocked(smap, service, r, callerFg, addToStarting);
return cmp;
}
ComponentName startServiceInnerLocked(ServiceMap smap, Intent service, ServiceRecord r,
boolean callerFg, boolean addToStarting) throws TransactionTooLargeException {
...
//调用bringUpServiceLocked方法
String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false, false);
if (error != null) {
return new ComponentName("!!", error);
}
...
return r.name;
}
private String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
boolean whileRestarting, boolean permissionsReviewRequired)
throws TransactionTooLargeException {
...
//获取进程想要运行在那个进程，默认是当前进程，或者是AndroidManifest中陪孩子的android:process属性
final String procName = r.processName;
String hostingType = "service";
ProcessRecord app;
if (!isolated) {
//查询是否存在一个与Service对应的ProcessRecord类型的对象app
app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
+ " app=" + app);
//如果运行Service的应用进程存在
if (app != null && app.thread != null) {
try {
app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);
//启动Service
realStartServiceLocked(r, app, execInFg);
return null;
} catch (TransactionTooLargeException e) {
...
}
}
} else {
app = r.isolatedProc;
if (WebViewZygote.isMultiprocessEnabled()
&& r.serviceInfo.packageName.equals(WebViewZygote.getPackageName())) {
hostingType = "webview_service";
}
}
//如果用来运行Service的应用程序进程不存在
if (app == null && !permissionsReviewRequired) {
//创建应用程序进程
if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
hostingType, r.name, false, isolated, false)) == null) {
String msg = "Unable to launch app "
+ r.appInfo.packageName + "/"
+ r.appInfo.uid + " for service "
+ r.intent.getIntent() + ": process is bad";
Slog.w(TAG, msg);
bringDownServiceLocked(r);
return msg;
}
if (isolated) {
r.isolatedProc = app;
}
}
if (!mPendingServices.contains(r)) {
//添加到mPendingServices，用于新进程启动后启动Service
mPendingServices.add(r);
}
...
return null;
}
如果应用进程已经存在的话会调用realStartServiceLocked方法来启动Service
private final void realStartServiceLocked(ServiceRecord r,
ProcessRecord app, boolean execInFg) throws RemoteException {
...
try {
...
//调用app.thread.scheduleCreateService方法，app.thread是IapplicationThread类型的，它的实现是ActivityThread的内部类ApplicationThread
app.thread.scheduleCreateService(r, r.serviceInfo,
mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo),
app.repProcState);
r.postNotification();
created = true;
} catch (DeadObjectException e) {
Slog.w(TAG, "Application dead when creating service " + r);
mAm.appDiedLocked(app);
throw e;
} finally {
...
}
if (r.whitelistManager) {
app.whitelistManager = true;
}
...
}
/frameworks/base/core/java/android/app/ActivityThread.java
public final void scheduleCreateService(IBinder token,
ServiceInfo info, CompatibilityInfo compatInfo, int processState) {
updateProcessState(processState, false);
CreateServiceData s = new CreateServiceData();
s.token = token;
s.info = info;
s.compatInfo = compatInfo;
//发送信息交给H处理
sendMessage(H.CREATE_SERVICE, s);
}
最后通过Handler的方法发送了CREATE_SERVICE消息给H
private class H extends Handler {
...
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case CREATE_SERVICE:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate: " + String.valueOf(msg.obj)));
//调用handleCreateService进行真正的Service创建
handleCreateService((CreateServiceData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
}
...
}
}
private void handleCreateService(CreateServiceData data) {
unscheduleGcIdler();
//获取要启动Service的应用程序的LoadedApk,LoadedApk是一个Apk文件的描述类
LoadedApk packageInfo = getPackageInfoNoCheck(
data.info.applicationInfo, data.compatInfo);
Service service = null;
try {
java.lang.ClassLoader cl = packageInfo.getClassLoader();
//使用发射的方式创建Service示例
service = (Service) cl.loadClass(data.info.name).newInstance();
} catch (Exception e) {
...
}
try {
if (localLOGV) Slog.v(TAG, "Creating service " + data.info.name);
//创建Service的上下文环境ContextImpl对象
ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
context.setOuterContext(service);
Application app = packageInfo.makeApplication(false, mInstrumentation);
//初始化Service
service.attach(context, this, data.info.name, data.token, app,
ActivityManager.getService());
// 调用Service的onCreate生命周期，此时Service已经启动了
service.onCreate();
//将启动的Service加入到成员变量mServices中
mServices中.put(data.token, service);
...
} catch (Exception e) {
...
}
}
这里主要是通过反射创建了Service对象，然后创建其上下文环境，然后调用其声明周期启动Service
三、Sercie的绑定过程
Servicd的绑定过程可以分为两个部分，分别是ContextImpl到Ams的调用过程和Service的绑定过程
ContextImpl到AMS的调用过程
过程如图
首先是ContextWrapper的bindService方法
/frameworks/base/core/java/android/content/ContextWrapper.java
public boolean bindService(Intent service, ServiceConnection conn,int flags) {
return mBase.bindService(service, conn, flags);
}
我们知道mBase就是ContextImpl类型的，所以我们进到ContextImpl类里看
/frameworks/base/core/java/android/app/ContextImpl.java
public boolean bindService(Intent service, ServiceConnection conn,int flags) {
warnIfCallingFromSystemProcess();
//调用bindServiceCommon方法
return bindServiceCommon(service, conn, flags, mMainThread.getHandler(),
Process.myUserHandle());
}
private boolean bindServiceCommon(Intent service, ServiceConnection conn, int flags, Handler
handler, UserHandle user) {
IServiceConnection sd;
if (conn == null) {
throw new IllegalArgumentException("connection is null");
}
if (mPackageInfo != null) {
//将ServiceConnection封装为IserviceConnection类型的对象，它支持跨进程通信
sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);
} else {
throw new RuntimeException("Not supported in system context");
}
validateServiceIntent(service);
try {
...
//调用AMS的bindService方法
int res = ActivityManager.getService().bindService(
mMainThread.getApplicationThread(), getActivityToken(), service,
service.resolveTypeIfNeeded(getContentResolver()),
sd, flags, getOpPackageName(), user.getIdentifier());
if (res < 0) {
throw new SecurityException(
"Not allowed to bind to service " + service);
}
return res != 0;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
最终调用了AMS的bindService，注意传入的参数里面有个sd，它会对 ServiceConnection 进行封装，后面用于跨进程通信
AMS的Service绑定过程
过程如下图
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public int bindService(IApplicationThread caller, IBinder token, Intent service,
String resolvedType, IServiceConnection connection, int flags, String callingPackage,
int userId) throws TransactionTooLargeException {
enforceNotIsolatedCaller("bindService");
if (service != null && service.hasFileDescriptors() == true) {
throw new IllegalArgumentException("File descriptors passed in Intent");
}
if (callingPackage == null) {
throw new IllegalArgumentException("callingPackage cannot be null");
}
synchronized(this) {
//调用ActiveServices的bindServiceLocked方法
return mServices.bindServiceLocked(caller, token, service,
resolvedType, connection, flags, callingPackage, userId);
}
}
AMS的bindService方法最后调用了ActiveServices的bindServiceLocked方法
在看其源码时需要首先了解一些与Service相关的对象类型
- ServiceReocrd 用于描述一个Service
- ProcessRecord 一个进程的信息
- ConnectionRecord 用于描述应用进城和Service建立连接的一个通道
- AppBindRecord 应用程序进程通过Intent绑定Service时，会通过AppBindRecord来维护Service与应用程序之间的关联。其内部存储了 谁绑定的Service（ProcessRecord）被绑定的Service（AppBindRecord）绑定Service的Intent（IntentBindRecord）和所有绑定通信记录的信息（ArraySet<ConnectionRecord>）。
- IntentBindRecord 用于描述绑定Service的Intent
接下来看ActiveServices的bindServiceLocked方法
/frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service,
String resolvedType, final IServiceConnection connection, int flags,
String callingPackage, final int userId) throws TransactionTooLargeException {
...
ServiceRecord s = res.record;
...
try {
...
//获取AppBindRecord,retrieveAppBindingLocked方法内部会创建IntendBindRecord，并给其成员赋值
AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
...
if ((flags&Context.BIND_AUTO_CREATE) != 0) {
s.lastActivity = SystemClock.uptimeMillis();
//通上面的bringUpServiceLocked，最终通过ActivityThread来调用Service的onCreate方法
if (bringUpServiceLocked(s, service.getFlags(), callerFg, false,
permissionsReviewRequired) != null) {
return 0;
}
}
...
//Service已经运行并且当前应用进程已经接受到绑定Service时返回的Binder
if (s.app != null && b.intent.received) {
try {
//c.conn是IServiceConnection类型。具体实现为ServiceDispatcher.InnerConnection
//ServiceDispatchers是LoadedApk的内部类，
//InnerConnection的connected方法内部会调用H的post方法想主线程发送消息，并且解决当前应用程序进程和Service跨进程通信的问题
c.conn.connected(s.name, b.intent.binder, false);
} catch (Exception e) {
Slog.w(TAG, "Failure sending service " + s.shortName
+ " to connection " + c.conn.asBinder()
+ " (in " + c.binding.client.processName + ")", e);
}
//如果当前应用程序进程是第一个与Service进行绑定的，并且Service已经调用onUnbInd方法
if (b.intent.apps.size() == 1 && b.intent.doRebind) {
//绑定Service,最后一个参数表示是否是重新绑定
requestServiceBindingLocked(s, b.intent, callerFg, true);
}
} else if (!b.intent.requested) {
//绑定Service,不重新绑定
requestServiceBindingLocked(s, b.intent, callerFg, false);
}
getServiceMapLocked(s.userId).ensureNotStartingBackgroundLocked(s);
} finally {
Binder.restoreCallingIdentity(origId);
}
return 1;
}
这里调用了requestServiceBindingLocked方法来进行绑定
private final boolean requestServiceBindingLocked(ServiceRecord r, IntentBindRecord i,
boolean execInFg, boolean rebind) throws TransactionTooLargeException {
...
//如果（没有发送过绑定Service的请求或者是重新绑定）并且 用当前Intent来绑定Service的应用程序的进程个数大于0
if ((!i.requested || rebind) && i.apps.size() > 0) {
try {
bumpServiceExecutingLocked(r, execInFg, "bind");
r.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
//跨进程调用IApplicationThread的scheduleBindService方法
r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind,
r.app.repProcState);
if (!rebind) {
i.requested = true;
}
i.hasBound = true;
i.doRebind = false;
} catch (TransactionTooLargeException e) {
...
}
}
return true;
}
AMS会为每个绑定Service的Intent分配一个IntentBindRecord类型对象。代码如下
/frameworks/base/services/core/java/com/android/server/am/IntentBindRecord.java
final class IntentBindRecord {
//被绑定的Service
final ServiceRecord service;
//绑定Service的Intent
final Intent.FilterComparison intent;
//所有用当前Intent绑定Service的应用程序
final ArrayMap<ProcessRecord, AppBindRecord> apps= new ArrayMap<>();
}
IntentBindRecord里的apps用来存储所有用当前Intent绑定Service的应用程序进程。i.apps.size()>0表示用当前Intent来绑定Service的应用程序的进程个数大于0。而i.apps.size()>0是否为true 则需要看下ServiceRecord 的retrieveAppBindingLocked方法
/frameworks/base/services/core/java/com/android/server/am/ServiceRecord.java
public AppBindRecord retrieveAppBindingLocked(Intent intent,
ProcessRecord app) {
Intent.FilterComparison filter = new Intent.FilterComparison(intent);
IntentBindRecord i = bindings.get(filter);
if (i == null) {
i = new IntentBindRecord(this, filter);
bindings.put(filter, i);
}
//根据ProcessRecord获取
AppBindRecord a = i.apps.get(app);
if (a != null) {
//如果AppBindRecord不为null就返回
return a;
}
//为null则创建AppBindRecord
a = new AppBindRecord(this, i, app);
//将新建的AppBindRecord保存在i.apps 这个map中
i.apps.put(app, a);
return a;
}
由此可知retrieveAppBindingLocked方法完成后i.apps.size()>0必定为true。所以必定会调用r.app.thread.scheduleBindService方法。此处跟Activity的启动类似，通过Binder的形式跨进程调用IApplicationThread的scheduleBindService方法
/frameworks/base/core/java/android/app/ActivityThread.java
public final void scheduleBindService(IBinder token, Intent intent,
boolean rebind, int processState) {
updateProcessState(processState, false);
BindServiceData s = new BindServiceData();
s.token = token;
s.intent = intent;
s.rebind = rebind;
if (DEBUG_SERVICE)
Slog.v(TAG, "scheduleBindService token=" + token + " intent=" + intent + " uid="
+ Binder.getCallingUid() + " pid=" + Binder.getCallingPid());
sendMessage(H.BIND_SERVICE, s);
}
这里的代码我们很眼熟，最后通过Handler的方法发送了BIND_SERVICE消息给H
private class H extends Handler {
...
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case BIND_SERVICE:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
//调用handleBindService方法
handleBindService((BindServiceData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
}
...
}
}
private void handleBindService(BindServiceData data) {
Service s = mServices.get(data.token);
...
if (s != null) {
try {
data.intent.setExtrasClassLoader(s.getClassLoader());
data.intent.prepareToEnterProcess();
try {
//如果不是重新绑定
if (!data.rebind) {
//调用Service的onBind方法
IBinder binder = s.onBind(data.intent);
//调用AMS的publishService方法
ActivityManager.getService().publishService(
data.token, data.intent, binder);
} else {
//如果是重新重新绑定，调用Service的onBind方法
s.onRebind(data.intent);
ActivityManager.getService().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
}
ensureJitEnabled();
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
} catch (Exception e) {
if (!mInstrumentation.onException(s, e)) {
throw new RuntimeException(
"Unable to bind to service " + s
+ " with " + data.intent + ": " + e.toString(), e);
}
}
}
}
这里如果不是重新绑定则调用调用Service的onBind方法，如果是重新绑定则调用Service的onBind方法
最后看一下AMS的publishService方法
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void publishService(IBinder token, Intent intent, IBinder service) {
// Refuse possible leaked file descriptors
if (intent != null && intent.hasFileDescriptors() == true) {
throw new IllegalArgumentException("File descriptors passed in Intent");
}
synchronized(this) {
if (!(token instanceof ServiceRecord)) {
throw new IllegalArgumentException("Invalid service token");
}
//调用ActiveServices的publishServiceLocked方法
mServices.publishServiceLocked((ServiceRecord)token, intent, service);
}
}
在publishService方法中调用ActiveServices的publishServiceLocked方法
/frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
...
try {
...
for (int i=0; i<clist.size(); i++) {
ConnectionRecord c = clist.get(i);
...
try {
//调用IserviceConnection的connected方法，它是ServiceConnection在本地的代理
c.conn.connected(r.name, service, false);
} catch (Exception e) {
...
}
}
...
} finally {
Binder.restoreCallingIdentity(origId);
}
}
conn指的是IserviceConnection，它是ServiceConnection在本地的代理，用于解决当前应用进程和Service跨进程通信的问题。具体实现为ServiceDispatcher.InnerConnection，期中ServiceDispatcher是LoadedApk的内部类。
frameworks/base/core/java/android/app/LoadedApk.java
static final class ServiceDispatcher {
...
private final ServiceConnection mConnection;
...
private static class InnerConnection extends IServiceConnection.Stub {
final WeakReference<LoadedApk.ServiceDispatcher> mDispatcher;
InnerConnection(LoadedApk.ServiceDispatcher sd) {
mDispatcher = new WeakReference<LoadedApk.ServiceDispatcher>(sd);
}
public void connected(ComponentName name, IBinder service, boolean dead)
throws RemoteException {
LoadedApk.ServiceDispatcher sd = mDispatcher.get();
if (sd != null) {
//调用ServiceDispatcher的connected方法
sd.connected(name, service, dead);
}
}
}
ServiceDispatcher(ServiceConnection conn,
Context context, Handler activityThread, int flags) {
mIServiceConnection = new InnerConnection(this);
mConnection = conn;
...
}
...
}
调用了ServiceDispatcher的connected方法
public void connected(ComponentName name, IBinder service, boolean dead) {
if (mActivityThread != null) {
//mActivityThread是Handler类型的对象。实际指向的是H,此处将RunConnection运行在主线程
mActivityThread.post(new RunConnection(name, service, 0, dead));
} else {
doConnected(name, service, dead);
}
}
private final class RunConnection implements Runnable {
RunConnection(ComponentName name, IBinder service, int command, boolean dead) {
mName = name;
mService = service;
mCommand = command;
mDead = dead;
}
public void run() {
if (mCommand == 0) {
//调用doConnected方法
doConnected(mName, mService, mDead);
} else if (mCommand == 1) {
doDeath(mName, mService);
}
}
final ComponentName mName;
final IBinder mService;
final int mCommand;
final boolean mDead;
}
public void doConnected(ComponentName name, IBinder service, boolean dead) {
...
if (old != null) {
mConnection.onServiceDisconnected(name);
}
if (dead) {
mConnection.onBindingDied(name);
}
if (service != null) {
//调用ServiceConnection的onServiceConnected方法
mConnection.onServiceConnected(name, service);
}
}
四、广播的注册、发送和接受
广播的注册过程
广播的注册通俗来讲就是广播接收者注册自己感兴趣的广播，广播的注册分为两种，分别是静态注册和动态注册，静态注册在应用安装时由PackageManagerService来完成注册。我们只看广播的动态注册
时序图如下
首先是ContextWrapper的registerReceiver
/frameworks/base/core/java/android/content/ContextWrapper.java
@Override
public Intent registerReceiver(
BroadcastReceiver receiver, IntentFilter filter) {
return mBase.registerReceiver(receiver, filter);
}
我们知道mBase的具体指向是ContextImpl
/frameworks/base/core/java/android/app/ContextImpl.java
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
return registerReceiver(receiver, filter, null, null);
}
public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
return registerReceiver(receiver, filter, null, null);
}
private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId,
IntentFilter filter, String broadcastPermission,
Handler scheduler, Context context, int flags) {
IIntentReceiver rd = null;
if (receiver != null) {
if (mPackageInfo != null && context != null) {
if (scheduler == null) {
scheduler = mMainThread.getHandler();
}
//调用LoadApk的getReceiverDispatcher方法获取rd对象
rd = mPackageInfo.getReceiverDispatcher(
receiver, context, scheduler,
mMainThread.getInstrumentation(), true);
} else {
if (scheduler == null) {
scheduler = mMainThread.getHandler();
}
//创建LoadedApk.ReceiverDispatcher类型的对象获取rd
rd = new LoadedApk.ReceiverDispatcher(
receiver, context, scheduler, null, true).getIIntentReceiver();
}
}
try {
//调用AMS的registerReceiver方法
final Intent intent = ActivityManager.getService().registerReceiver(
mMainThread.getApplicationThread(), mBasePackageName, rd, filter,
broadcastPermission, userId, flags);
if (intent != null) {
intent.setExtrasClassLoader(getClassLoader());
intent.prepareToEnterProcess();
}
return intent;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
首先获取IIntentReceiver类型的rd对象。IIntentReceiver是一个Binder接口，用于广播的跨进程通信，它在LoadedApk.ReceiverDispatcher中实现的
static final class ReceiverDispatcher {
final static class InnerReceiver extends IIntentReceiver.Stub {
final WeakReference<LoadedApk.ReceiverDispatcher> mDispatcher;
final LoadedApk.ReceiverDispatcher mStrongRef;
InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) {
mDispatcher = new WeakReference<LoadedApk.ReceiverDispatcher>(rd);
mStrongRef = strong ? rd : null;
}
...
}
...
}
最后调用了AMS的registerReceiver方法，并将IIntentReceiver类型的rd对象穿进去了。
接下来看registerReceiver方法，我们分两部分看
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
-
registerReceiver方法的part1
public Intent registerReceiver(IApplicationThread caller, String callerPackage, IIntentReceiver receiver, IntentFilter filter, String permission, int userId, int flags) { ... ProcessRecord callerApp = null; ... synchronized(this) { if (caller != null) { //通过getRecordForAppLocked方法获取到ProcessRecord的callerApp对象， //用于描述请求AMS注册广播接受者所在的应用程序进程。 callerApp = getRecordForAppLocked(caller); } ... //根据IntentFilter得到actions列表，根据actions列表和userIds的都所有的粘性广播的Intent Iterator<String> actions = filter.actionsIterator(); if (actions == null) { ArrayList<String> noAction = new ArrayList<String>(1); noAction.add(null); actions = noAction.iterator(); } int[] userIds = { UserHandle.USER_ALL, UserHandle.getUserId(callingUid) }; while (actions.hasNext()) { String action = actions.next(); for (int id : userIds) { ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(id); if (stickies != null) { ArrayList<Intent> intents = stickies.get(action); if (intents != null) { if (stickyIntents == null) { stickyIntents = new ArrayList<Intent>(); } //保存所有的粘性广播Intent stickyIntents.addAll(intents); } } } } } ArrayList<Intent> allSticky = null; if (stickyIntents != null) { final ContentResolver resolver = mContext.getContentResolver(); //遍历寻找匹配的粘性广播 for (int i = 0, N = stickyIntents.size(); i < N; i++) { Intent intent = stickyIntents.get(i); if (instantApp && (intent.getFlags() & Intent.FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS) == 0) { continue; } if (filter.match(resolver, intent, true, TAG) >= 0) { if (allSticky == null) { allSticky = new ArrayList<Intent>(); } // allSticky.add(intent); } } } ... } -
registerReceiver方法的part2
public Intent registerReceiver(IApplicationThread caller, String callerPackage, IIntentReceiver receiver, IntentFilter filter, String permission, int userId, int flags) { ... synchronized (this) { ... //获取ReceiverList广播接受者列表；ReceiverList继承ArrayList，用来存储广播接受者 ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder()); if (rl == null) { //如果列表为空则创建 rl = new ReceiverList(this, callerApp, callingPid, callingUid, userId, receiver); if (rl.app != null) { rl.app.receivers.add(rl); } ... } ... //创建BroadcastFilter；BroadcastFilter用来描述注册的广播接受者 BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, permission, callingUid, userId, instantApp, visibleToInstantApps); //将bf添加到ReceiverList rl.add(bf); if (!bf.debugCheck()) { Slog.w(TAG, "==> For Dynamic broadcast"); } //将bf添加到IntentResolver类型mReceiverResolver中，当AMS接受到广播时就可以从mReceiverResolver中找到对应的广播接受者了 mReceiverResolver.addFilter(bf); return sticky; } }
广播的发送和接受过程
广播的发送和接受过程分为两个部分分别是ContextImpl到AMS的调用过程和AMS到BroadcastReceiver的调用过程
ContextImpl到AMS的调用过程
广播可以发送多种类型，包括无序广播（普通广播）、有序广播和粘性广播。这里以无需广播为例。
要发送无需广播无需要调用sendBroadcast方法，它同样在ContextWrapper中实现。时序图如下
/frameworks/base/core/java/android/content/ContextWrapper.java
public void sendBroadcast(Intent intent) {
mBase.sendBroadcast(intent);
}
接下来看ContextImpl中的sendBroadcast
/frameworks/base/core/java/android/app/ContextImpl.java
public void sendBroadcast(Intent intent) {
warnIfCallingFromSystemProcess();
String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
try {
intent.prepareToLeaveProcess(this);
//调用AMSbroadcastIntent
ActivityManager.getService().broadcastIntent(
mMainThread.getApplicationThread(), intent, resolvedType, null,
Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, null, false, false,
getUserId());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public final int broadcastIntent(IApplicationThread caller,
Intent intent, String resolvedType, IIntentReceiver resultTo,
int resultCode, String resultData, Bundle resultExtras,
String[] requiredPermissions, int appOp, Bundle bOptions,
boolean serialized, boolean sticky, int userId) {
enforceNotIsolatedCaller("broadcastIntent");
synchronized(this) {
//验证广播是否合法
intent = verifyBroadcastLocked(intent);
final ProcessRecord callerApp = getRecordForAppLocked(caller);
final int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
//调用broadcastIntentLocked
int res = broadcastIntentLocked(callerApp,
callerApp != null ? callerApp.info.packageName : null,
intent, resolvedType, resultTo, resultCode, resultData, resultExtras,
requiredPermissions, appOp, bOptions, serialized, sticky,
callingPid, callingUid, userId);
Binder.restoreCallingIdentity(origId);
return res;
}
}
这里首先用verifyBroadcastLocked方法验证广播是否合法
final Intent verifyBroadcastLocked(Intent intent) {
//验证Intent不为null并且有问价描述符
if (intent != null && intent.hasFileDescriptors() == true) {
throw new IllegalArgumentException("File descriptors passed in Intent");
}
//获得intent的Flag
int flags = intent.getFlags();
if (!mProcessesReady) {
//如果系统正在启动过程
if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT) != 0) {
//如果flag设置 启动检查时只接受动态注册的广播接受者 则不做处理
} else if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
//如果没有设置直接红素动态这车的广播接收者，则抛出异常
Slog.e(TAG, "Attempt to launch receivers of broadcast intent " + intent
+ " before boot completion");
throw new IllegalStateException("Cannot broadcast before boot completed");
}
}
...
return intent;
}
然后调用broadcastIntentLocked方法
final int broadcastIntentLocked(ProcessRecord callerApp,
String callerPackage, Intent intent, String resolvedType,
IIntentReceiver resultTo, int resultCode, String resultData,
Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions,
boolean ordered, boolean sticky, int callingPid, int callingUid, int userId) {
...
//将动态注册的广播接收者和静态注册的广播接收者按照优先级高低不同存储在不同的列表中，再将这两个列表合并到receivers列表中，这样receivers列表包含了所有的广播接收者（无序广播和有序广播）
...
if ((receivers != null && receivers.size() > 0)
|| resultTo != null) {
BroadcastQueue queue = broadcastQueueForIntent(intent);
//创建BroadcastRecord对象并将receivers传进去
BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,callerPackage, callingPid, callingUid, callerInstantApp, resolvedType,requiredPermissions, appOp, brOptions, receivers, resultTo, resultCode,resultData, resultExtras, ordered, sticky, false, userId)
...
final BroadcastRecord oldRecord =
replacePending ? queue.replaceOrderedBroadcastLocked(r) : null;
if (oldRecord != null) {
...
} else {
//将新建的BroadcastRecord对象加入到队列中
queue.enqueueOrderedBroadcastLocked(r);
//调用BroadcastQueue的scheduleBroadcastsLocked方法
queue.scheduleBroadcastsLocked();
}
}
...
return ActivityManager.BROADCAST_SUCCESS;
}
创建 BroadcastRecord 对象并将 receivers 传进去，然后将 BroadcastRecord 对象添加多队列中，然后调用队列的 scheduleBroadcastsLocked 方法开始从队列取出广播并发送，具体看下面
AMS到BroadcastReceiver的调用过程
时序图如下
/frameworks/base/services/core/java/com/android/server/am/BroadcastQueue.java
public void scheduleBroadcastsLocked() {
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Schedule broadcasts ["
+ mQueueName + "]: current="
+ mBroadcastsScheduled);
if (mBroadcastsScheduled) {
return;
}
//向BroadcastHandler类型的对象mHandler发送BROADCAST_INTENT_MSG消息
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
mBroadcastsScheduled = true;
}
这里向向BroadcastHandler类型的对象mHandler发送BROADCAST_INTENT_MSG消息，这个消息在BroadcastHandler中的handleMessage方法中进行处理
private final class BroadcastHandler extends Handler {
public void handleMessage(Message msg) {
switch (msg.what) {
case BROADCAST_INTENT_MSG: {
...
processNextBroadcast(true);
} break;
...
}
}
}
又交给了processNextBroadcast方法
final void processNextBroadcast(boolean fromMsg) {
synchronized(mService) {
BroadcastRecord r;
...
if (fromMsg) {
//将mBroadcastsScheduled置为true
mBroadcastsScheduled = false;
}
//遍历存储无序广播的mParallelBroadcasts列表
while (mParallelBroadcasts.size() > 0) {
//获取无序广播
r = mParallelBroadcasts.remove(0);
...
for (int i=0; i<N; i++) {
Object target = r.receivers.get(i);
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,"Delivering non-ordered on [" + mQueueName + "] to registered "+ target + ": " + r);
//将无序广播r发送给对应的广播接收者
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
}
...
}
...
}
}
private void deliverToRegisteredReceiverLocked(BroadcastRecord r,
BroadcastFilter filter, boolean ordered, int
index) {
...
try {
if (DEBUG_BROADCAST_LIGHT) Slog.i(TAG_BROADCAST,"Delivering to " + filter + " : " + r);
if (filter.receiverList.app != null && filter.receiverList.app.inFullBackup) {
...
} else {
//调用performReceiveLocked
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
new Intent(r.intent), r.resultCode, r.resultData,
r.resultExtras, r.ordered, r.initialSticky, r.userId);
}
if (ordered) {
r.state = BroadcastRecord.CALL_DONE_RECEIVE;
}
} catch (RemoteException e) {
...
}
}
void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,Intent intent, int resultCode, String data, Bundle extras,boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
if (app != null) {
//如果广播接收者所在的应用程序进程存在
if (app.thread != null) {
//如果广播接受这所在的应用进程正在运行
try {
//调用ApplicationThread的scheduleRegisteredReceiver方法
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
data, extras, ordered, sticky, sendingUser, app.repProcState);
} catch (RemoteException ex) {
...
}
}
...
}
...
}
/frameworks/base/core/java/android/app/ActivityThread.java
public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,int resultCode, String dataStr, Bundle extras, boolean ordered,boolean sticky, int sendingUser, int processState) throws RemoteException {
updateProcessState(processState, false);
//调用IIntentReceiver的performReceive方法，
receiver.performReceive(intent, resultCode, dataStr, extras, ordered,
sticky, sendingUser);
}
这里调用了IIntentReceiver的performReceive方法，
IIntentReceiver和IActivityManager一样，都使用了AIDL来实现进程建通信。InnerReceiver继承自IIntentReceiver.Stub，是Binder通信的服务器端，IIntentReceiver则是Binder通信的客户端、是InnerReceiver在本地的代理
IIntentReceiver的具体实现在LoadedApk.ReceiverDispatcher.InnerReceiver.
/frameworks/base/core/java/android/app/LoadedApk.java
static final class ReceiverDispatcher {
final static class InnerReceiver extends IIntentReceiver.Stub {
final WeakReference<LoadedApk.ReceiverDispatcher> mDispatcher;
final LoadedApk.ReceiverDispatcher mStrongRef;
InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) {
mDispatcher = new WeakReference<LoadedApk.ReceiverDispatcher>(rd);
mStrongRef = strong ? rd : null;
}
public void performReceive(Intent intent, int resultCode, String data,Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
final LoadedApk.ReceiverDispatcher rd;
if (intent == null) {
Log.wtf(TAG, "Null intent received");
rd = null;
} else {
rd = mDispatcher.get();
}
...
if (rd != null) {
//调用ReceiverDispatcher的performReceive方法
rd.performReceive(intent, resultCode, data, extras,
ordered, sticky, sendingUser);
}
...
}
}
...
}
这里又调用了ReceiverDispatcher的performReceive方法，注意上面是在oadedApk.ReceiverDispatcher.InnerReceiver这个类里
static final class ReceiverDispatcher {
...
public void performReceive(Intent intent, int resultCode, String data,Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
//将广播的Intent等信息封装为Args对象
final Args args = new Args(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
...
//调用mActivityThread的post方法，并传入args转换的runable,mActivityThread是一个Handler对象，默认指向H
if (intent == null || !mActivityThread.post(args.getRunnable())) {
if (mRegistered && ordered) {
IActivityManager mgr = ActivityManager.getService();
if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
"Finishing sync broadcast to " + mReceiver);
args.sendFinished(mgr);
}
}
}
}
final class Args extends BroadcastReceiver.PendingResult {
...
public final Runnable getRunnable() {
return () -> {
final BroadcastReceiver receiver = mReceiver;
...
try {
ClassLoader cl = mReceiver.getClass().getClassLoader();
intent.setExtrasClassLoader(cl);
intent.prepareToEnterProcess();
setExtrasClassLoader(cl);
receiver.setPendingResult(this);
//执行BroadcastReceiver的onReceive方法
receiver.onReceive(mContext, intent);
} catch (Exception e) {
...
}
...
};
}
}
五、ContentProvider的启动过程
ContentProvider的启动过程主要分两个部分，分别是query方法到AMS的调用和AMS启动ContentProvider的过程
query方法到AMS的调用
时序图如下
我们知道要想使用ContentProvider我们必须先调用getContentResolver方法，如下所示
/frameworks/base/core/java/android/content/ContextWrapper.java
public ContentResolver getContentResolver() {
return mBase.getContentResolver();
}
我们知道mBase实际是ContextImpl的实例
/frameworks/base/core/java/android/app/ContextImpl.java
public ContentResolver getContentResolver() {
return mContentResolver;
}
getContentResolver方法中返回了ApplicationContentResolver类型的mContentResolver对象，ApplicationContentResolver是ContextImpl中的静态内部类，继承自ContentResolver，它在ContextImpl的构造方法中被创建.这说明当我们调用ContentResolver的insert、query、update等方法时就会启动ContentProvider（这是指客户端应用的ContentProvider）。
这里看query方法的调用，query方法在ApplicationContentResolver的父类ContentResolver中实现。有三个重载方法，最终会调用下面的这个方法
/frameworks/base/core/java/android/content/ContentResolver.java
public final @Nullable Cursor query(final @RequiresPermission.Read @NonNull Uri uri,
@Nullable String[] projection, @Nullable Bundle queryArgs,
@Nullable CancellationSignal cancellationSignal) {
Preconditions.checkNotNull(uri, "uri");
//获取IContentProvider；IContentProvider是ContentProvider在本地的代理。具体实现是ContentProvider
IContentProvider unstableProvider = acquireUnstableProvider(uri);
...
try {
...
try {
//调用IContentProvider的query方法
qCursor = unstableProvider.query(mPackageName, uri, projection,
queryArgs, remoteCancellationSignal);
} catch (DeadObjectException e) {
...
}
....
} catch (RemoteException e) {
return null;
} finally {
...
}
}
我们来看acquireUnstableProvider方法
public final IContentProvider acquireUnstableProvider(Uri uri) {
//检查Uri的scheme是否等于"content"
if (!SCHEME_CONTENT.equals(uri.getScheme())) {
return null;
}
String auth = uri.getAuthority();
if (auth != null) {
//调用ApplicationContentResolver的acquireUnstableProvider方法
return acquireUnstableProvider(mContext, uri.getAuthority());
}
return null;
}
上面调用了acquireUnstableProvider，这是一个抽象方法，由子类ApplicationContentResolver实现
/frameworks/base/core/java/android/app/ContextImpl.java
private static final class ApplicationContentResolver extends ContentResolver {
private final ActivityThread mMainThread;
...
protected IContentProvider acquireProvider(Context context, String auth) {
//调用ActivityThread的acquireProvider方法
return mMainThread.acquireProvider(context,
ContentProvider.getAuthorityWithoutUserId(auth),
resolveUserIdFromAuthority(auth), true);
}
}
/frameworks/base/core/java/android/app/ActivityThread.java
public final IContentProvider acquireProvider(
Context c, String auth, int userId, boolean stable) {
//检查ActivityThread的全局变量mProviderMap中是否有目标ContentProvider存在，有则返回
final IContentProvider provider = acquireExistingProvider(c, auth, userId, stable);
if (provider != null) {
return provider;
}
ContentProviderHolder holder = null;
try {
//调用AMS的getContentProvider方法
holder = ActivityManager.getService().getContentProvider(
getApplicationThread(), auth, userId, stable);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
if (holder == null) {
Slog.e(TAG, "Failed to find provider info for " + auth);
return null;
}
//安装ContentProvider，并将上面AMS返回的ContentProvider缓存到mProviderMap中。
holder = installProvider(c, holder, holder.info,
true /*noisy*/, holder.noReleaseNeeded, stable);
return holder.provider;
}
acquireProvider首先检查缓存中是否有目标ContentProvider，如果没有则调用AMS的getContentProvider获取，然后调用installProvider安装并缓存在ActivityThread
接下来看下AMS的getContentProvider
public final ContentProviderHolder getContentProvider(
IApplicationThread caller, String name, int userId, boolean stable) {
enforceNotIsolatedCaller("getContentProvider");
if (caller == null) {
String msg = "null IApplicationThread when getting content provider "
+ name;
Slog.w(TAG, msg);
throw new SecurityException(msg);
}
//调用getContentProviderImpl
return getContentProviderImpl(caller, name, null, stable, userId);
}
private ContentProviderHolder getContentProviderImpl(IApplicationThread caller,
String name, IBinder token, boolean stable, int userId) {
...
synchronized(this) {
...
if (!providerRunning) {
...
if (i >= N) {
...
try {
....
//获取目标ContentProvider的应用程序进程信息
ProcessRecord proc = getProcessRecordLocked(
cpi.processName, cpr.appInfo.uid, false);
if (proc != null && proc.thread != null && !proc.killed) {
//如果进程已经启动
...
if (!proc.pubProviders.containsKey(cpi.name)) {
checkTime(startTime, "getContentProviderImpl: scheduling install");
proc.pubProviders.put(cpi.name, cpr);
try {
//如果进程已经启动调用scheduleInstallProvider
proc.thread.scheduleInstallProvider(cpi);
} catch (RemoteException e) {
}
}
} else {
checkTime(startTime, "getContentProviderImpl: before start process");
//如果进程没有启动，调用startProcessLocked方法
proc = startProcessLocked(cpi.processName,
cpr.appInfo, false, 0, "content provider",
new ComponentName(cpi.applicationInfo.packageName,
cpi.name), false, false, false);
checkTime(startTime, "getContentProviderImpl: after start process");
...
}
....
} finally {
...
}
}
...
}
...
....
}
进程没有启动时，会调用startProcessLocked方法启动进程（服务端ContentProvider所在的进程），最后调用ActivityThread的main方法
public static void main(String[] args) {
...
Looper.prepareMainLooper();
//创建ActivityThread对象
ActivityThread thread = new ActivityThread();
//调用ActivityThread的attach方法
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));
}
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//开启消息循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
我们来看下ActivityThread的attach方法
private void attach(boolean system) {
if (!system) {
...
final IActivityManager mgr = ActivityManager.getService();
try {
//调用AMS的attachApplication方法
mgr.attachApplication方法(mAppThread);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
...
}
...
}
AMS启动ContentProvider的过程
时序图如下
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public final void attachApplication(IApplicationThread thread) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final long origId = Binder.clearCallingIdentity();
//调用attachApplicationLocked
attachApplicationLocked(thread, callingPid);
Binder.restoreCallingIdentity(origId);
}
}
private final boolean attachApplicationLocked(IApplicationThread thread,int pid) {
...
try {
...
if (app.instr != null) {
//调用app.thread.bindApplication方法，app.thread是IapplicationThread类型的，它的实现是ActivityThread的内部类ApplicationThread
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);
}
...
} catch (Exception e) {
...
}
...
}
接下来调用ApplicationThread的bindApplication方法
/frameworks/base/core/java/android/app/ActivityThread.java
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) {
if (services != null) {
// Setup the service cache in the ServiceManager
ServiceManager.initServiceCache(services);
}
setCoreSettings(coreSettings);
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
data.instrumentationName = instrumentationName;
data.instrumentationArgs = instrumentationArgs;
...
sendMessage(H.BIND_APPLICATION, data);
}
这里通过sendMessage方法发送BIND_APPLICATION消息给H
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
...
BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
//调用handleBindApplication方法
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
}
...
}
private void handleBindApplication(AppBindData data) {
...
//1.创建ContextImpl
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
...
if (ii != null) {
...
try {
final ClassLoader cl = instrContext.getClassLoader();
//2.通过反射创建Instrumentation
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
} catch (Exception e) {
...
}
final ComponentName component = new ComponentName(ii.packageName, ii.name);
//3.初始化Instrumentation
mInstrumentation.init(this, instrContext, appContext, component,
data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
...
try {
//4.创建Application
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;
if (!data.restrictedBackupMode) {
if (!ArrayUtils.isEmpty(data.providers)) {
//5.启动ContentProvider
installContentProviders(app, data.providers);
mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);
}
}
try {
//6.调用Application的onCreate方法
mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
...
}
} finally {
StrictMode.setThreadPolicy(savedPolicy);
}
...
}
这里通过调用installContentProviders方法用来启动ContentProvider
private void installContentProviders(
Context context, List<ProviderInfo> providers) {
final ArrayList<ContentProviderHolder> results = new ArrayList<>();
//遍历当前应用进程的ProviderInfo列表，ProviderInfo用来存储ContentProvider的信息
for (ProviderInfo cpi : providers) {
...
//2.启动ContentProvider
ContentProviderHolder cph = installProvider(context, null, cpi,false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
if (cph != null) {
cph.noReleaseNeeded = true;
results.add(cph);
}
}
try {
//3.将ContentProvider存储在AMS的mProviderMap中，启动缓存作用，防止使用相同的ContentProvider时都会调用AMS的getContentProvider方法
ActivityManager.getService().publishContentProviders(
getApplicationThread(), results);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
上面2出调用installProvider启动ContentProvider
private ContentProviderHolder installProvider(Context context,
ContentProviderHolder holder, ProviderInfo info,
boolean noisy, boolean noReleaseNeeded, boolean stable) {
ContentProvider localProvider = null;
IContentProvider provider;
if (holder == null || holder.provider == null) {
...
try {
final java.lang.ClassLoader cl = c.getClassLoader();
//1.通过反射创建ContentProvider类型的对象
localProvider = (ContentProvider)cl.
loadClass(info.name).newInstance();
provider = localProvider.getIContentProvider();
if (provider == null) {
...
return null;
}
if (DEBUG_PROVIDER) Slog.v(
TAG, "Instantiating local provider " + info.name);
//2.调用ContentProvider的attachInfo
localProvider.attachInfo(c, info);
} catch (java.lang.Exception e) {
...
}
}
...
return retHolder;
}
/frameworks/base/core/java/android/content/ContentProvider.java
public void attachInfo(Context context, ProviderInfo info) {
attachInfo(context, info, false);
}
private void attachInfo(Context context, ProviderInfo info, boolean testing) {
...
if (mContext == null) {
...
//调用用ContentProvider的onCreate方法
ContentProvider.this.onCreate();
}
}
1364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
