解析Service的启动过程
Service 的启动过程
Service
的启动过程和根
Activity
启动过程有部分相似的知识点，另外
Service
启动过
程涉及上下文 Context
的知识点，这里只关注流程而不会详细介绍
Context
，
Service
的启动过程将分为两个部分来进行讲解，分别是 Contextimpl到Activity
ManageService 调用
过程和
ActivityThread
启动
Service。本文基于Android8.1.0系统分析Service的启动过程。
1. Contextlmpl到AMS 的调用过程
要启动
Service
，我们会调用
startService 方法
，它在
Context
Wrapper
中实现，代码如下所示：
frameworks/base/core/java/android/content/ContextWrapper.java
public class ContextWrapper extends Context {
Context mBase;
...
@Override
public ComponentName startService(Intent service) {
return mBase.startService(service);
}
...
}
在startService方法中会
调用
mBase的
startService 方法
，
Context
类型的
mBase 对
象具
体指的是什么呢？在“解析Activity的启动过程”
中我们分析过，
ActivityThread
启动
Activity
调用如下代码创建 Activity 的上下文环境：
frameworks/base/core/java/android/app/ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
ContextImpl appContext = createBaseContextForActivity(r); // ... 1
Activity activity = null;
try {
if (activity != null) {
...
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) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to start activity " + component
+ ": " + e.toString(), e);
}
}
return activity;
}
在注释1处创建上下文对象appContext，并传入Activity的attach方法中，将Activity与上下文对象appContext关联起来，这个上下文对象appContext的具体类型是什么？接下来我们继续分析createBaseContextForActivity方法，代码如下所示：
frameworks/base/core/java/android/app/ActivityThread.java
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，因此，mBast具体指向就是ContextImpl。接下来分析ContextImpl的startService方法，代码如下所示：
frameworks/base/core/java/android/app/Contextlmpl.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);
ComponentName cn = ActivityManager.getService().startService(
mMainThread.getApplicationThread(), service, service.resolveTypeIfNeeded(
getContentResolver()), requireForeground,
getOpPackageName(), user.getIdentifier()); // ... 1
...
}
return cn;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
在startService 方法
中会返回
startServ
iceCommon
方法，在
startServiceCommon 方法中
会在注释1处调用
AMS
的代理I
Activity
Manager的
startService
方法，最终调用的是 AMS 的startService 方法，这一过程在
“解析Activity的启动过程”
中我们也分析过，不懂的同学可以看看Activity的启动过程，这里就不再做说明了。
2. ActivityThread 启动 Service
接着我们来分析 AMS 的
startService 方法
，代码如下所示：
frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
@Override
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 {
res = mServices.startServiceLocked(caller, service,
resolvedType, callingPid, callingUid,
requireForeground, callingPackage, userId); // ... 1
} finally {
Binder.restoreCallingIdentity(origId);
}
return res;
}
}
在注释1
处调用
mServices 的
startServiceLocked 方法
，
mServices
的类型是
ActiveServices,
ActiveServices 的startServiceLocked 方法代码如下所示
：
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 {
...
ServiceLookupResult res =
retrieveServiceLocked(service, resolvedType, callingPackage,
callingPid, callingUid, userId, true, callerFg, false); // ... 1
if (res == null) {
return null;
}
if (res.record == null) {
return new ComponentName("!", res.permission != null
? res.permission : "private to package");
}
ServiceRecord r = res.record; // ... 2
...
ComponentName cmp = startServiceInnerLocked(smap, service, r, callerFg, addToStarting);
return cmp;
}在注释1处的 retrieveServiceLocked 方法会查找是否有与参数 service 对应的 ServiceRecord ，如果没有找到，就会调用 PackageManagerService 去获取参数 service 对应的 Service 信息，并封装到 ServiceRecord 中，最后将 ServiceRecord 封装为 ServiceLookupResult 返回。其中 ServiceRecord 用于描述一个 Service ，和 ActivityRecord 类似。在注释2处通过注释1处返回的 ServiceLookupResult 得到参数 service 对应的 ServiceRecord ，并传入到注释3处的 startServicelnnerLocked 方法中。代码如下所示：
frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
ComponentName startServiceInnerLocked(ServiceMap smap, Intent service, ServiceRecord r,
boolean callerFg, boolean addToStarting) throws TransactionTooLargeException {
...
String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false, false);
if (error != null) {
return new ComponentName("!!", error);
}
...
return r.name;
}
在startServiceInnerLocked方法中又调用了bringUpServiceLocked方法，代码如下所示：
frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
private String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
boolean whileRestarting, boolean permissionsReviewRequired)
throws TransactionTooLargeException {
// 获取Service想要在哪个进程中运行
final String procName = r.processName; // ... 1
String hostingType = "service";
ProcessRecord app;
if (!isolated) {
app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false); // ... 2
if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
+ " app=" + app);
// 如果运行Service的应用程序进程存在
if (app != null && app.thread != null) { // ... 3
try {
app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);
// 启动Service
realStartServiceLocked(r, app, execInFg); // ... 4
return null;
} catch (TransactionTooLargeException e) {
throw e;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting service " + r.shortName, e);
}
// If a dead object exception was thrown -- fall through to
// restart the application.
}
} else {
// If this service runs in an isolated process, then each time
// we call startProcessLocked() we will get a new isolated
// process, starting another process if we are currently waiting
// for a previous process to come up. To deal with this, we store
// in the service any current isolated process it is running in or
// waiting to have come up.
app = r.isolatedProc;
if (WebViewZygote.isMultiprocessEnabled()
&& r.serviceInfo.packageName.equals(WebViewZygote.getPackageName())) {
hostingType = "webview_service";
}
}
// Not running -- get it started, and enqueue this service record
// to be executed when the app comes up.
// 如果用来运行Service的应用程序进程不存在
if (app == null && !permissionsReviewRequired) { // ... 5
// 创建应用程序进程
if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
hostingType, r.name, false, isolated, false)) == null) { // ... 6
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;
}
}
...
return null;
}
在注释1
处得到
ServiceRecord 的
processName
值并赋
procName， procName用来描述 Service
要在
哪个
进程
中运
行，默
是当
前进程，
我们也可以在
AndroidManif
es
文件中设 android:process 属
性来新开
启一
个进程运行
Service
。在注释2
处将
procName 和
Service 的uid 传入到
AMS的
getProcessRecordLocked 方法
，查
询是否存
在一个与
Service 对应的Process
Record
类型
的对象 a
pp，
ProcessRecord
主要用来
描述运行的应用
程序
进程的信息。
注释5
处判断
Service
对应的
app 为
null 则
说明用
来运行
Service 序进程不存在 ，则调
用注释6
处的
AMS 的
startProcessLock
方法来创建
对应的应用
程序
进程，关于创建应用
程序
进程
请查看" Android系统中应用程序进程的启动过程
"， 这
里只讨论
没有设置
android:
proce
ss
属性，即应用程序进程存在的情况 。
注释3
处判断如果用
来运行
Service
的应用
程序进程
存在，则调
用注释4
处的
realStartServiceLocked 方法
来启动 Service，realStartServiceLocked方法代码如下所示：
frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
private final void realStartServiceLocked(ServiceRecord r,
ProcessRecord app, boolean execInFg) throws RemoteException {
...
try {
...
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 {
...
}
...
}
在realStartServiceLocked 方法中
调用了
app.thread 的
scheduleCreateService 方法
。其中
app.thread是 IApplicationThread
类型的，它的实现是
Activi
tyThread
的内部类
Application
Thread 。
Application
Thread 的scheduleCreateService
方法如下所示：
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;
sendMessage(H.CREATE_SERVICE, s);
}
scheduleCreateService 方法将启动
Service
的参数封装成 CreateServiceData ,
sendMessage 方法向H
类发送类型为
CREATE_
SERVICE
的消息，并将 CreateServiceData
传递过去，这个过程和
Ac
ti
vi
tyThread
启动
Activity
的过程是类似的。
sendMessage 方法
有多个重载方法，最终调用的
sendMessage 方法代码
如下所示：
frameworks/base/core/java/android/app/ActivityThread.java
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
，是应用程序进程中主线程的消息管理类。 我们接
着查看 H 的
handleMessage 方法，代码如下所示：
frameworks/base/core/java/android/app/ActivityThread.java
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((CreateServiceData)msg.obj);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
}
...
}
}
handleMessage 方法根据消息类型为 CREA E_SERVICE，会调用 handleCreateService 方法，代码如下所示：
frameworks/base/core/java/android/app/ActivityThread.java
private void handleCreateService(CreateServiceData data) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
// 获取要启动Service的应用程序的LoadedApk
LoadedApk packageInfo = getPackageInfoNoCheck(
data.info.applicationInfo, data.compatInfo); // ... 1
Service service = null;
try {
// 获取类加载器
java.lang.ClassLoader cl = packageInfo.getClassLoader(); // ... 2
// 创建Service实例
service = (Service) cl.loadClass(data.info.name).newInstance(); // ... 3
} catch (Exception e) {
if (!mInstrumentation.onException(service, e)) {
throw new RuntimeException(
"Unable to instantiate service " + data.info.name
+ ": " + e.toString(), e);
}
}
try {
if (localLOGV) Slog.v(TAG, "Creating service " + data.info.name);
// 创建Service的上下文环境ContextImpl对象
ContextImpl context = ContextImpl.createAppContext(this, packageInfo); // ... 4
context.setOuterContext(service);
Application app = packageInfo.makeApplication(false, mInstrumentation);
// 初始化Service
service.attach(context, this, data.info.name, data.token, app,
ActivityManager.getService()); // ... 5
service.onCreate(); // ... 6
mServices.put(data.token, service); // ... 7
try {
ActivityManager.getService().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
} catch (Exception e) {
if (!mInstrumentation.onException(service, e)) {
throw new RuntimeException(
"Unable to create service " + data.info.name
+ ": " + e.toString(), e);
}
}
}
在注释1处获取要启动
Service
的应用程序的
LoadedApk,
LoadedApk是一个
APK 文件的描述类。在注释2处通过调
用
LoadedApk的
getClassLoader 方法
来获取类加载器。接
着在注释3处根据
CreateServiceData
对象中存储的
Service
信息，创建
Service
实例。在注释4处创建 Serv
ice
的上下
文环境
Contextlmpl
对象。在注释5
处通过
Service的
attach方法
来初始化Service
。在注释6
处调用
Service 的
on
Create 方法
，这样
Service
就启动了。在注释7
处将启动的 Service
加入到
ActivityThread
的成员变量
mServices
中，其中
mServices 是
ArrayMap
类型。