一、生命周期
Android 四大组件之一 Service，后台服务，用户无法感知它的存在，开发过程中，它是一种重要的组件，在主线程运行。
Intent intent = new Intent(this, XxxService);
startService(intent);
在 Activty，调用 startService() 方法，启动一个 Service 服务，ContextWrapper 装饰者类的 startService() 方法。
Service 服务 startService() 方法生命周期
onCreate() ==> onStartCommand()
1，onCreate() 方法，创建服务，和 onDestory() 销毁服务一样，只执行一次。
2，onStartCommand() 方法，开始服务，可以开始多次，每次 startService() 方法，都执行一次。
3，onDestory() 方法，销毁服务，stopService() 方法停止服务。
注意，启动服务时，如果开启一个线程工作，关闭服务时，线程不会自动停止，可以通过 onDestory() 标志位手动关停。
二、启动流程
装饰者 ContextWrap 类的 startService() 方法，委托内部 ContextImpl 类的 startService() 方法。
@Override
public ComponentName startService(Intent service) {
return mBase.startService(service);
}
//ContextImpl 类方法。
@Override
public ComponentName startService(Intent service) {
warnIfCallingFromSystemProcess();
return startServiceCommon(service, mUser);
}
startServiceCommon() 方法，访问 Ams 服务。
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 服务责管理启动的 App Service，入口 startService() 方法，在 Ams 服务中，启动流程相关类是 ActivityManagerService 和 ActiveServices 类。
依次执行的方法
==> startService()
==> startServiceLocked()
==> startServiceInnerLocked()
==> bringUpServiceLocked()
==> realStartServiceLocked()
最后，在 realStartServiceLocked() 方法中，通过 IApplicationThread 代理，回调 App 进程 scheduleCreateService() 方法。
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 {
...
}
...
//根据ServiceRecord的标志判断是启动不是绑定
sendServiceArgsLocked(r, execInFg, true);
}
向 App 主线程发送 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 = packageInfo.getAppFactory()
.instantiateService(cl, data.info.name, data.intent);
} 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,
ActivityManager.getService());
//生命周期方法。
service.onCreate();
mServices.put(data.token, service);
try {
ActivityManager.getService().serviceDoneExecuting(
data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
} catch (RemoteException e) {
}
} catch (Exception e) {
}
}
1，创建 Service 对象，(类加载器 ClassLoader 加载)，newInstance() 方法。
2，创建 Service 内部 ContextImpl (真实类)。
3，Service 的 attach() 方法，内部赋值。
4，生命周期 onCreate() 方法。
根据 IBinder类型 的 token ，在 Ams 服务注册的标志，将 Service 服务保存到 Map，当 Ams 再次回调 App 时，由 token 查找 Service。
Ams 服务 sendServiceArgsLocked() 方法，通过 IApplicationThread 代理回调 App 进程 scheduleServiceArgs() 方法。
private final void sendServiceArgsLocked(ServiceRecord r, boolean execInFg,
boolean oomAdjusted) throws TransactionTooLargeException {
ArrayList args = new ArrayList<>();
...
try {
r.app.thread.scheduleServiceArgs(r, slice);
} catch (TransactionTooLargeException e) {
}
}
向 App 主线程发送 SERVICE_ARGS 类型消息，然后 handleServiceArgs() 方法执行。
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) {
}
}
}
生命周期 onStartCommand() 方法，主线程。
三、Service 启动 Ams 流程
@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;
}
}
Ams 类将 Service 启动流程委托给 ActiveServices 类管理，startServiceLocked has() 方法。
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);
r.lastActivity = SystemClock.uptimeMillis();
r.startRequested = true;
r.delayedStop = false;
r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),
service, neededGrants));
...
return startServiceInnerLocked(smap, service, r, callerFg, addToStarting);
}
设置 ServiceRecord 的 startRequest 标志，添加 pendingStarts 队列，在后面的调用的 realStartServiceLocked 方法队列不空，会认为是启动服务，不是绑定。
调用 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 类似。
如果 Service 组件已存在，再一次 startService() 方法启动时，ServiceRecord 的 ProcessRecord 已赋值，内部的 ApplicationThread 存在。
在 bringUpServiceLocked() 方法，直接调用 sendServiceArgsLocked() 方法，如果是启动，pendingStarts 队列不空，回调 App 进程，触发 onStartCommand() 方法。
四、总结
Service 服务启动过程，生命周期两个方法，onCreate() 和 onStartCommand() 方法，都是通过 Ams 服务回调 App 进程，发送消息通知到主线程运行。
多次启动服务时，Service 实例化和创建过程只执行一次，开始方法执行多次。
任重而道远