我们要启动一个Service服务一般都是在Activity类中直接调用startService(Intent)来启动，而Activity类中并没有相关的方法，我们知道Activity继承自ContextWrapper，ContextWrapper类中的startService方法直接调用了ContextImpl的startService方法。
Service的可以在当前的进程中启动，也可以在新的进程中启动。在新的进程中启动的逻辑和前面分析的Activity的启动流程类似，所以此处我们仅仅分析在当前进程中启动Service的情况。
我们分析Service的启动流程首先从ContextImpl的startService方法开始分析。
1. ContextImpl.StartService
public ComponentName startService(Intent service) {
return startServiceCommon(service, mUser);
}
private ComponentName startServiceCommon(Intent service, UserHandle user) {
try {
validateServiceIntent(service);
service.prepareToLeaveProcess();
ComponentName cn = ActivityManagerNative.getDefault().startService(
mMainThread.getApplicationThread(), service, service.resolveTypeIfNeeded(
getContentResolver()), getOpPackageName(), user.getIdentifier());
return cn;
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
}StartService调用了startServiceCommon方法来启动Service，在startServiceCommon方法中通过进程间通信请求，调用了AMS服务的startService方法。以上代码在应用进程中。通过进程间调用，下面代码逻辑进入系统服务进程中。
2. AMS.startService
public ComponentName startService(IApplicationThread caller, Intent service,
String resolvedType, String callingPackage, int userId)
throws TransactionTooLargeException {
……
synchronized(this) {
//获取调用进程的UID和PID
final int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
//调用startServiceLocked来继续处理service启动的逻辑
ComponentName res = mServices.startServiceLocked(caller, service,
resolvedType, callingPid, callingUid, callingPackage, userId);
Binder.restoreCallingIdentity(origId);
return res;
}
}这个方法处理也是比较简单，获取调用者的Uid和Pid,调用ActiveService的startServiceLocked方法来继续处理Service启动的逻辑。
??
3. ActiveService.startServiceLocked
ComponentName startServiceLocked(IApplicationThread caller, Intent service, String resolvedType,
int callingPid, int callingUid, String callingPackage, int userId)
throws TransactionTooLargeException {
//获取调用程序的进程信息
if (caller != null) {
final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
……
}
//调用要启动的service的Intent信息，在PMS服务中查找对应的service，并将它封装在一个ServiceLookupResult对象中
ServiceLookupResult res =
retrieveServiceLocked(service, resolvedType, callingPackage,
callingPid, callingUid, userId, true, callerFg);
//得到要启动service的ServiceRecord信息
ServiceRecord r = res.record;
final ServiceMap smap = getServiceMap(r.userId);
……
//调用startServiceInnerLocked方法继续启动service服务
return startServiceInnerLocked(smap, service, r, callerFg, addToStarting);
}最后条用startServiceInnerLocked方法来继续启动目标Service
下面在了解下retrieveServiceLocked方法的处理逻辑。
private ServiceLookupResult retrieveServiceLocked(Intent service,
String resolvedType, String callingPackage, int callingPid, int callingUid, int userId,
boolean createIfNeeded, boolean callingFromFg) {
ServiceRecord r = null;
//获取当前的用户ID
userId = mAm.handleIncomingUser(callingPid, callingUid, userId,
false, ActivityManagerService.ALLOW_NON_FULL_IN_PROFILE, "service", null);
找到该用户下的保存Service的集合ServiceMap
ServiceMap smap = getServiceMap(userId);
final ComponentName comp = service.getComponent();
//根据component信息从ServiceMap中查找
if (comp != null) {
r = smap.mServicesByName.get(comp);
}
//根据IntentFilter信息从ServiceMap中查找
if (r == null) {
Intent.FilterComparison filter = new Intent.FilterComparison(service);
r = smap.mServicesByIntent.get(filter);
}
//如果ServiceMap中没有找到目标Service的ServiceRecord信息，则从PMS中查找并创建一个ServiceRecord对象，然后保存到ServiceMap中
if (r == null) {
try {
ResolveInfo rInfo =
AppGlobals.getPackageManager().resolveService(
service, resolvedType,
ActivityManagerService.STOCK_PM_FLAGS, userId);
ServiceInfo sInfo =
rInfo != null ? rInfo.serviceInfo : null;
……
r = new ServiceRecord(mAm, ss, name, filter, sInfo, callingFromFg, res);
res.setService(r);
smap.mServicesByName.put(name, r);
smap.mServicesByIntent.put(filter, r);
}
} catch (RemoteException ex) {
// pm is in same process, this will never happen.
}
}
……
return null;
}retrieveServiceLocked方法用来查找目标Service的ServiceRecord对象，首先从AMS服务中的ServiceMap中查找，ServiceMap中保存了AMS服务中所有激活的Service信息，如果在ServiceMap中没有找到，说明该Service还没有启动。那么就需要从PMS服务中查找目标Service的信息并创建一个ServiceRecord对象。最后把他保存在对应的ServiceMap集合中。
接着看startServiceInnerLocked方法，该方法中处理逻辑直接较简单，直接调用了bringUpServiceLocked方法来处理
4. ActiveService. bringUpServiceLocked
private final String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
boolean whileRestarting) throws TransactionTooLargeException {
final String procName = r.processName;
ProcessRecord app;
//判断目标Service所在的进程是否已经存在，如果已经存在则直接调用目标进程启动Service
app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
if (app != null && app.thread != null) {
try {
app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);
realStartServiceLocked(r, app, execInFg);
return null;
}
……
}
//如果目标进程不存在，则需要先创建目标进程，然后再创建Service
if (app == null) {
if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
"service", r.name, false, isolated, false)) == null) {
……
}这个方法首先根据目标Serivce的进程信息，来查询对应的进程是否存在，如果对应的目标进程已经存在，则通过通知目标进程来启动Service,如果目标进程还没有创建，则电泳AMS服务的startProcessLocked方法启动一个目标进程，然后在启动service。启动目标进程的方法和Activity中启动目标进程的方法类似，此处不再分析。
我们分析在同一个进程中启动Service的逻辑，目标进程肯定已经存在了，不需要新创建进程，所以直接调用realStartServiceLocked方法来启动service服务。
5. ActiveService.realStartServiceLocked
private final void realStartServiceLocked(ServiceRecord r,
ProcessRecord app, boolean execInFg) throws RemoteException {
……
//将即将要启动ServiceRecord和一个进程关联起来
r.app = app;
boolean created = false;
try {
……
//通过进程间通信请求，调用目标进程的scheduleCreateService方法创建一个Service服务
app.thread.scheduleCreateService(r, r.serviceInfo,
mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo),
app.repProcState);
r.postNotification();
created = true;
}
……
}将即将要启动的ServiceRecord r的成员变量设置为ProcessRecord对象app，表示这个ServiceRecord对象锁描述的Service组件是在app所描述的进程中启动运行的。
在Activity的启动过程中描述过：ProcessRecord的成员变量thread是一个ApplicationThreadProxy的binder代理对象，它指向了应用程序进程中一个Applicationthread的binder服务端对象。因此可以通过thread进行进程间通信请求，调用binder服务端ApplicationThread的scheduleCreateService来创建Service。
同样，ApplicationThread接收到请求后，最终发送消息CREATE_SERVICE由Hander来处理，Handler的handleMessage又调用了ActivityThread的handleCreateService方法来处理。
6. ActivityThread.handleCreateService
private void handleCreateService(CreateServiceData data) {
//获取当前应用程序的LoadedApk对象
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 {
//创建并初始化Context对象
ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
context.setOuterContext(service);
//创建一个Application对象，用来描述service所在的应用程序信息
Application app = packageInfo.makeApplication(false, mInstrumentation);
//使用上面的信息初始化刚创建的service对象
service.attach(context, this, data.info.name, data.token, app,
ActivityManagerNative.getDefault());
//调用service的onCreate方法
service.onCreate();
//最后将servcie保存在ActivityThread的mServices变量中。
mServices.put(data.token, service);
try {
ActivityManagerNative.getDefault().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
} catch (RemoteException e) {
// nothing to do.
}
} ……
}在该方法中首先获得一个LoadedAPK对象，在之前我们曾经分析过，LoadedApk主要用来描述进程中所加载的一个应用程序，里面保存了应用程序的资源路径等信息。
然后使用LoadedApk对象中保存的ClassLoader来加载目标Service类到内存中，并创建一个目标Service的对象。
第三步，创建ContextImpl对象，并初始化，用来当做Service对象的上下文信息，Service对象就可以通过它来访问程序的资源和方法。
第四步，创建一个Application对象，用来描述Service所在应用程序的信息。
第五步，用上面创建的信息，context,Application等信息来初始化刚创建的service对象。
第六步，service对象初始化完成后就调用了它的onCreate方法。这样Service服务就基本上启动起来了