android startService调用流程(一) (android6.0源码)

我们知道要开启一个Service，首先在AndroidManifest.xml注册该Service，然后在Activity中startService

现在我们就看下Service是怎么一步步通过ActivityManagerService启动的。

Context.startService是一个抽象方法，我们知道真正实现Context的类ContextImpl(./frameworks/base/core/java/android/app/ContextImpl.java)，于是我们查看其startService代码

1.     public ComponentName startService(Intent service) {
2.         warnIfCallingFromSystemProcess();
3.         return startServiceCommon(service, mUser);
4.     }

调用了startServiceCommon方法，

1.     private ComponentName startServiceCommon(Intent service, UserHandle user) {
2.         try {
3.             validateServiceIntent(service);
4.             service.prepareToLeaveProcess();
5.             ComponentName cn = ActivityManagerNative.getDefault().startService(
6.                 mMainThread.getApplicationThread(), service, service.resolveTypeIfNeeded(
7.                             getContentResolver()), getOpPackageName(), user.getIdentifier());
8.             if (cn != null) {
9.                 if (cn.getPackageName().equals("!")) {
10.                     throw new SecurityException(
11.                             "Not allowed to start service " + service
12.                             + " without permission " + cn.getClassName());
13.                 } else if (cn.getPackageName().equals("!!")) {
14.                     throw new SecurityException(
15.                             "Unable to start service " + service
16.                             + ": " + cn.getClassName());
17.                 }
18.             }
19.             return cn;
20.         } catch (RemoteException e) {
21.             throw new RuntimeException("Failure from system", e);
22.         }
23.     }

在第5-7行，通过ActivityManagerProxy代理ActivityManagerService（具体细节参见文章Activity启动过程），调用了ActivityManagerService的startService方法，ActivityManagerService代码如下：

1. 
   
2.     public ComponentName startService(IApplicationThread caller, Intent service,
3.             String resolvedType, String callingPackage, int userId)
4.             throws TransactionTooLargeException {
5.         enforceNotIsolatedCaller("startService");
6.         // Refuse possible leaked file descriptors
7.         if (service != null && service.hasFileDescriptors() == true) {
8.             throw new IllegalArgumentException("File descriptors passed in Intent");
9.         }
10. 
    
11.         if (callingPackage == null) {
12.             throw new IllegalArgumentException("callingPackage cannot be null");
13.         }
14. 
    
15.         if (DEBUG_SERVICE) Slog.v(TAG_SERVICE,
16.                 "startService: " + service + " type=" + resolvedType);
17.         synchronized(this) {
18.             final int callingPid = Binder.getCallingPid();
19.             final int callingUid = Binder.getCallingUid();
20.             final long origId = Binder.clearCallingIdentity();
21.             ComponentName res = mServices.startServiceLocked(caller, service,
22.                     resolvedType, callingPid, callingUid, callingPackage, userId);
23.             Binder.restoreCallingIdentity(origId);
24.             return res;
25.         }
26.     }

经过一些逻辑判断后实际调用了mServices.startServiceLocked。mService定义如下，

1.     final ActiveServices mServices;

ActiveServices.startServiceLocked代码量约有110行，其中主要是在最后调用了startServiceInnerLocked方法，

接下来我们看下ActiveServices的startServiceInnerLocked方法，代码如下：

1.     ComponentName startServiceInnerLocked(ServiceMap smap, Intent service, ServiceRecord r,
2.             boolean callerFg, boolean addToStarting) throws TransactionTooLargeException {
3.         ProcessStats.ServiceState stracker = r.getTracker();
4.         if (stracker != null) {
5.             stracker.setStarted(true, mAm.mProcessStats.getMemFactorLocked(), r.lastActivity);
6.         }
7.         r.callStart = false;
8.         synchronized (r.stats.getBatteryStats()) {
9.             r.stats.startRunningLocked();
10.         }
11.         String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false);
12.         if (error != null) {
13.             return new ComponentName("!!", error);
14.         }
15.       //省略部分代码
16.     }

其中调用了bringUpServiceLocked方法，bringUpServiceLocked代码量也是110行左右（真特么多啊），但我们可以很清楚的分析到其主要代码如下：

1.     private final String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
2.             boolean whileRestarting) throws TransactionTooLargeException {
3.         //Slog.i(TAG, "Bring up service:");
4.         //省略部分代码
5. 
   
6.         final boolean isolated = (r.serviceInfo.flags&ServiceInfo.FLAG_ISOLATED_PROCESS) != 0;
7.         final String procName = r.processName;
8.         ProcessRecord app;
9. 
   
10.         if (!isolated) {
11.             app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
12.             if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
13.                         + " app=" + app);
14.             if (app != null && app.thread != null) {
15.                 try {
16.                     app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);
17.                     realStartServiceLocked(r, app, execInFg);
18.                     return null;
19.                 } catch (TransactionTooLargeException e) {
20.                     throw e;
21.                 } catch (RemoteException e) {
22.                     Slog.w(TAG, "Exception when starting service " + r.shortName, e);
23.                 }
24. 
    
25.                 // If a dead object exception was thrown -- fall through to
26.                 // restart the application.
27.             }
28.         } else {
29.             // If this service runs in an isolated process, then each time
30.             // we call startProcessLocked() we will get a new isolated
31.             // process, starting another process if we are currently waiting
32.             // for a previous process to come up.  To deal with this, we store
33.             // in the service any current isolated process it is running in or
34.             // waiting to have come up.
35.             app = r.isolatedProc;
36.         }
37.           //省略部分代码
38.         return null;
39.     }

在代码的第17行调用到了realStartServiceLocked（是不是很熟悉，和Activity启动过程调用方法名基本一致），

realStartServiceLocked方法代码如下：

1. 
   
2.     private final void realStartServiceLocked(ServiceRecord r,
3.             ProcessRecord app, boolean execInFg) throws RemoteException {
4.         //省略部分代码
5.         boolean created = false;
6.         try {
7.             if (LOG_SERVICE_START_STOP) {
8.                 String nameTerm;
9.                 int lastPeriod = r.shortName.lastIndexOf('.');
10.                 nameTerm = lastPeriod >= 0 ? r.shortName.substring(lastPeriod) : r.shortName;
11.                 EventLogTags.writeAmCreateService(
12.                         r.userId, System.identityHashCode(r), nameTerm, r.app.uid, r.app.pid);
13.             }
14.             synchronized (r.stats.getBatteryStats()) {
15.                 r.stats.startLaunchedLocked();
16.             }
17.             mAm.ensurePackageDexOpt(r.serviceInfo.packageName);
18.             app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
19.             app.thread.scheduleCreateService(r, r.serviceInfo,
20.                     mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo),
21.                     app.repProcState);
22.             r.postNotification();
23.             created = true;
24.         } catch (DeadObjectException e) {
25.             Slog.w(TAG, "Application dead when creating service " + r);
26.             mAm.appDiedLocked(app);
27.             throw e;
28.         } finally {
29.             if (!created) {
30.                 // Keep the executeNesting count accurate.
31.                 final boolean inDestroying = mDestroyingServices.contains(r);
32.                 serviceDoneExecutingLocked(r, inDestroying, inDestroying);
33. 
    
34.                 // Cleanup.
35.                 if (newService) {
36.                     app.services.remove(r);
37.                     r.app = null;
38.                 }
39. 
    
40.                 // Retry.
41.                 if (!inDestroying) {
42.                     scheduleServiceRestartLocked(r, false);
43.                 }
44.             }
45.         }
46.       //省略部分代码
47.     }

我们看到在realStartServiceLocked方法的第19-21行调用了app.thread.scheduleCreateService，我们在前面分析Activity启动过程的时候已经知道app.thread变量的类型其实是ActivityThread的私有内部类ApplicationThread，那么我们看下ApplicationThread的scheduleCreateService方法，

1.         public final void scheduleCreateService(IBinder token,
2.                 ServiceInfo info, CompatibilityInfo compatInfo, int processState) {
3.             updateProcessState(processState, false);
4.             CreateServiceData s = new CreateServiceData();
5.             s.token = token;
6.             s.info = info;
7.             s.compatInfo = compatInfo;
8. 
   
9.             sendMessage(H.CREATE_SERVICE, s);
10.         }

在scheduleCreateService方法的最后一句sendMessage发送了一个CREATE_SERVICE的消息，那么这里service启动流程我们分析了一半了，接收CREATE_SERVICE消息并如何处理我们放到第二部分，接下来总结一下这一部分分析的Service启动流程。

首先Context.startService实际调用的是ContextImpl.startService方法，从这里开始，

ContextImpl.startService -> startServiceCommon -> ActivityManagerService.startService -> ActiveServices.startServiceLocked -> startServiceInnerLocked -> bringUpServiceLocked ->

realStartServiceLocked -> ApplicationThread.scheduleCreateService -> sendMessage.

最终通过ActivityThread的mh变量(Handler类型)发送了一个CREATE_SERVICE的消息，第二部分会将mh如何处理该消息并回调Service的onCreate等生命周期方法。