Service启动流程
前面的文章分析过Activity组件的启动流程，Service是四大组件之一，一种后台服务，它一般没有界面，我们感知不到它的存在。在Android开发时一种重要的组件，在主线程中运行，本文分析一下Service的启动流程，通常是以下代码启动一个Service。
Intent intent = new Intent(this, XxxService);
startService(intent);
Activty中的startService方法，调用父类ContextWrapper的startService方法。
@Override
public ComponentName startService(Intent service) {
return mBase.startService(service);
}
在ContextWrapper中，mBase是ContextImpl的具体实现类，下面是它的startService方法。
@Override
public ComponentName startService(Intent service) {
warnIfCallingFromSystemProcess();
return startServiceCommon(service, mUser);
}
调用startServiceCommon方法。
private ComponentName startServiceCommon(Intent service, UserHandle user) {
try {
...
ComponentName cn = ActivityManagerNative.getDefault().startService(
mMainThread.getApplicationThread(), service, service.resolveTypeIfNeeded(
getContentResolver()), getOpPackageName(), user.getIdentifier());
...
return cn;
} catch (RemoteException e) {
}
}
访问Ams服务，调用ActivityManagerService的#startService方法。
@Override
public ComponentName startService(IApplicationThread caller, Intent service,
String resolvedType, String callingPackage, int userId)
throws TransactionTooLargeException {
//service和callingPackage必须存在。否则抛异常。
synchronized(this) {
final int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
ComponentName res = mServices.startServiceLocked(caller, service,
resolvedType, callingPid, callingUid, callingPackage, userId);
Binder.restoreCallingIdentity(origId);
return res;
}
}
参数ApplicationThread，App回调，将启动的Service类Intent，resolveType。调用ActiveServices的startServiceLocked方法，Ams类将Service启动的相关流程委托给ActiveServices类管理。
ComponentName startServiceLocked(IApplicationThread caller, Intent service, String resolvedType,
int callingPid, int callingUid, String callingPackage, int userId)
throws TransactionTooLargeException {
final boolean callerFg;
if (caller != null) {
//根据IApplicationThread获取ProcessRecord，callerApp空报异常。
final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
callerFg = callerApp.setSchedGroup != Process.THREAD_GROUP_BG_NONINTERACTIVE;
} else {
callerFg = true;
}
ServiceLookupResult res =
retrieveServiceLocked(service, resolvedType, callingPackage,
callingPid, callingUid, userId, true, callerFg);
ServiceRecord r = res.record;
final ServiceMap smap = getServiceMap(r.userId);
...
return startServiceInnerLocked(smap, service, r, callerFg, addToStarting);
}
调用ActiveServices的startServiceInnerLocked方法。
ComponentName startServiceInnerLocked(ServiceMap smap, Intent service, ServiceRecord r,
boolean callerFg, boolean addToStarting) throws TransactionTooLargeException {
ProcessStats.ServiceState stracker = r.getTracker();
if (stracker != null) {
stracker.setStarted(true, mAm.mProcessStats.getMemFactorLocked(), r.lastActivity);
}
r.callStart = false;
synchronized (r.stats.getBatteryStats()) {
r.stats.startRunningLocked();
}
String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false);
if (error != null) {
return new ComponentName("!!", error);
}
if (r.startRequested && addToStarting) {
boolean first = smap.mStartingBackground.size() == 0;
smap.mStartingBackground.add(r);
r.startingBgTimeout = SystemClock.uptimeMillis() + BG_START_TIMEOUT;
if (first) {
smap.rescheduleDelayedStarts();
}
} else if (callerFg) {
smap.ensureNotStartingBackground(r);
}
return r.name;
}
调用bringUpServiceLocked方法。
private final String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
boolean whileRestarting) throws TransactionTooLargeException {
//如果app和thread存在，直接回调app进程onStartCommand方法，
if (r.app != null && r.app.thread != null) {
sendServiceArgsLocked(r, execInFg, false);
return null;
}
//不存在，继续走流程
realStartServiceLocked方法
}
ServiceRecord是Ams保存的服务记录，它和ActivityRecord类似。
在realStartServiceLocked方法。
private final void realStartServiceLocked(ServiceRecord r,
ProcessRecord app, boolean execInFg) throws RemoteException {
//app.thread不能是空。
r.app = app;//设置ProcessRecord
boolean created = false;
try {
...
app.thread.scheduleCreateService(r, r.serviceInfo,
mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo),
app.repProcState);
created = true;
} catch (DeadObjectException e) {
throw e;
} finally {
...
}
...
sendServiceArgsLocked(r, execInFg, true);
}
该方法通过ApplicationThread回调App的scheduleCreateService方法，向主线程发送一个CREATE_SERVICE消息，然后，执行handleCreateService方法。
private void handleCreateService(CreateServiceData data) {
LoadedApk packageInfo = getPackageInfoNoCheck(
data.info.applicationInfo, data.compatInfo);
Service service = null;
try {
//构建Service对象
java.lang.ClassLoader cl = packageInfo.getClassLoader();
service = (Service) cl.loadClass(data.info.name).newInstance();
} catch (Exception e) {
}
try {
//创建Service内部真实类
ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
context.setOuterContext(service);
Application app = packageInfo.makeApplication(false, mInstrumentation);
//attach方法
service.attach(context, this, data.info.name, data.token, app,
ActivityManagerNative.getDefault());
//生命周期方法。
service.onCreate();
mServices.put(data.token, service);
try {
ActivityManagerNative.getDefault().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
} catch (RemoteException e) {
}
} catch (Exception e) {
}
}
首先，类加载器ClassLoader加载对应的Service类，调用类的newInstance方法，创建Service对象。
然后，创建ContextImpl实现类，调用attach方法向Service内部赋值。执行Service的生命周期方法onCreate。
最后，根据IBinder类型的token，将新建Service保存到Map中，这些过程和Activity的启动流程一样。
我们再回到realStartServiceLocked方法，最后，调用sendServiceArgsLocked方法，该方法回调ApplicationThread的scheduleServiceArgs方法，发送的是SERVICE_ARGS消息。
private void handleServiceArgs(ServiceArgsData data) {
Service s = mServices.get(data.token);
if (s != null) {
try {
...
int res;
if (!data.taskRemoved) {
//调用onStartCommand方法
res = s.onStartCommand(data.args, data.flags, data.startId);
} else {
s.onTaskRemoved(data.args);
res = Service.START_TASK_REMOVED_COMPLETE;
}
} catch (Exception e) {
}
}
}
在主线程处理消息时，调用Service的onStartCommand方法。到这里，从无到有启动一个Service就已经完成了，在开发中遇到的方法都已经执行到。如果该Service组件已经存在，我们再次执行startService方法，这时，ServiceRecord的ProcessRecord已被赋值过，同时，ProcessRecord内部ApplicationThread也存在，在bringUpServiceLocked方法，会调用sendServiceArgsLocked方法，回调App进程，触发onStartCommand方法。
下面是一张Service启动时调用方法当流程图。
Service启动时调用方法当流程图.jpg
总结流程
在服务启动过程中，经历两个方法，onCreate和onStartCommand方法，他们都是通过Ams服务回调App进程，消息通知主线程调用。
当多次启动服务时，实例化和创建方法只执行一次，开始方法会执行多次。
任重而道远
