Android Service 启动流程

在早些年学习Android的时候，对Service有过总结，但是主要是如何去使用，注意事项，startService和bindService的区别。
Android Service_public int onstartcommand(intent intent, int flags-CSDN博客
但是今天从源码来总结下framework层的启动流程大抵是什么样的。
一、startService()

平常，在我们的activity里，我们通过startService去启动一个service服务。
1.context.startService

使用例子：

1. //testActivity
2.     @Override
3.     public void onClick(View v) {
4.         Intent it=new Intent(this, SimpleService.class);
5.         switch (v.getId()){
6.             case R.id.startService:
7.                 startService(it);
8.                 break;
9.             case R.id.stopService:
10.                 stopService(it);
11.                 break;
12.         }

复制代码

这儿，现实上是调用的context上下文去调用的这个方法，那我们去看下里面的代码

1. @Override
2. public ComponentName startService(Intent service) {
3.     warnIfCallingFromSystemProcess();
4.     return startServiceCommon(service, false, mUser);
5. }
7. private ComponentName startServiceCommon(Intent service, boolean requireForeground,
8.         UserHandle user) {
9.     try {
10.         validateServiceIntent(service);
11.         service.prepareToLeaveProcess(this);
12.         ComponentName cn = ActivityManager.getService().startService(
13.             mMainThread.getApplicationThread(), service, service.resolveTypeIfNeeded(
14.                         getContentResolver()), requireForeground,
15.                         getOpPackageName(), user.getIdentifier());
16.        ...
17.         return cn;
18.     } catch (RemoteException e) {
19.         throw e.rethrowFromSystemServer();
20.     }
21. }

复制代码

2.ActivityManager.getService().startService()

可以看到：焦点代码为ActivityManager.getService().startService()
在 Activity 中使用的 startService 方法是定义在 Context 的抽象类中，它的真正实现类是 ContextImpl，以是先进入 ContextImpl 类。先从startService开始，然后进入本类的startServiceCommon方法，并最终调用ActivityManagerNative.getDefault()对象的 startService 方法。ActivityManager.getService()获取到IActivityManager对象，而且是通过单利模式创建的。

1. public static IActivityManager getService() {
2.     return IActivityManagerSingleton.get();
3. }
5. private static final Singleton<IActivityManager> IActivityManagerSingleton =
6.         new Singleton<IActivityManager>() {
7.             @Override
8.             protected IActivityManager create() {
9.                 final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
10.                 final IActivityManager am = IActivityManager.Stub.asInterface(b);
11.                 return am;
12.             }
13.         };

复制代码

看下ActivityManager.getService()这个如果看过app启动流程就知道，这玩意儿在创建application和activity时也看到过。这儿用到了binder实现进程间通信，最后走到了AMS里面
看下ActivityManagerService中startService()代码

这里面走到了startServiceLocked()方法，此中mServices是ActiveServices。
ActiveServices这里面进行了以下步骤：
1.通过 retrieveServiceLocked 方法来解析 service 这个 Intent，就是解析前面我们在 AndroidManifest.xml 定义的 Service 标签的 intent-filter 相干内容，然后将解析效果放在 res.record 中。
2.调用 startServiceInnerLocked 方法。

在startServiceInnerLocked 方法中会调用 bringUpServiceLocked 方法。

3.bringUpServiceLocked方法中，当 Service 所在的进程存在时，将调用realStartServiceLocked 方法来启动 Service，否则的话调用 startProcessLocked 方法来启动新进程。
情况一：realStartServiceLocked()

这里面会调用 app.thread.scheduleCreateService(r, r.serviceInfo, mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo), app.repProcState);
这里会走到ApplicationThread去sendMessage，最后去创建service，执行onCreate方法，后面有详细说明。因为它运行的进程已存在，就直接去创建了，如果不存在，接着往下走
情况二：startProcessLocked() 

 4.startProcessLocked()是ActivityManagerSevice中的方法，

1. //在ActivityManagerService类中
2. private final void startProcessLocked(ProcessRecord app, String hostingType,
3.         String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {
5.     boolean isActivityProcess = (entryPoint == null);
6.     if (entryPoint == null)
7.         entryPoint = "android.app.ActivityThread";
8.     checkTime(startTime, "startProcess: asking zygote to start proc");
9.     //通过 processName，uid 等启动新进程
10.     Process.start(entryPoint,
11.                         app.processName, uid, uid, gids, debugFlags, mountExternal,
12.                         app.info.targetSdkVersion, app.info.seinfo, requiredAbi,
13.                         instructionSet, app.info.dataDir, entryPointArgs);
14. }
16. //在Process类中
17. public static final ProcessStartResult start(final String processClass,
18.                               final String niceName,
19.                               int uid, int gid, int[] gids,
20.                               int debugFlags, int mountExternal,
21.                               int targetSdkVersion,
22.                               String seInfo,
23.                               String abi,
24.                               String instructionSet,
25.                               String appDataDir,
26.                               String invokeWith,
27.                               String[] zygoteArgs) {
28.     return zygoteProcess.start(processClass, niceName, uid, gid, gids,
29.                 debugFlags, mountExternal, targetSdkVersion, seInfo,
30.                 abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
31. }

复制代码

从这儿，启动了一个新的进程，创建一个新的进程过后就会走到熟悉的ActivityThread类的main方法里面去
3.启动新进程去ActivityThread

熟悉的源码

1. public static void main(String[] args) {
2.     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
3.     CloseGuard.setEnabled(false);
4.     // 初始化应用中需要使用的系统路径
5.     Environment.initForCurrentUser();
6.     Looper.prepareMainLooper();
7.     //创建ActivityThread 对象
8.     ActivityThread thread = new ActivityThread();
9.     thread.attach(false);
10.     Looper.loop();
11.     throw new RuntimeException("Main thread loop unexpectedly exited");
12. }

复制代码

大抵流程：

• 1.绑定应用进程到ActivityManagerService
  
  
  
  • 在 Android 应用程序中，每一个进程对应一个 ActivityThread 实例，然后这里创建了 ActivityThread 对象并调用了其 attach 方法
    
  
  
• 2.主线程Handler消息处理
  
  
  
  • 启动looper轮询器，以是在activity大概service创建handler对象时，不需要手动调用looper。缘故原由就是在这里
    
  • 首先Looper.prepareMainLooper();是为主线程创建了Looper，然后thread.getHandler();是生存了主线程的Handler，最后Looper.loop();进入消息循环。
    
  
  

其余的不用看了，主要看thread.attach(false)

• main()方法通过thread.attach(false)绑定应用进程。ActivityManagerNative通过getDefault()方法返回ActivityManagerService实例，ActivityManagerService通过attachApplication将ApplicationThread对象绑定到ActivityManagerService，而ApplicationThread作为Binder实现ActivityManagerService对应用进程的通信和控制。
  
• 在ActivityManagerService内部，attachApplication现实是通过调用attachApplicationLocked实现的，这里采用了synchronized关键字保证同步。
  

1. //ActivityThread.java
2. private void attach(boolean system) {
3.     final IActivityManager mgr = ActivityManagerNative.getDefault();
4.     try {
5.         //这里调用了 ActivityManagerProxy.attachApplication 方法。
6.         mgr.attachApplication(mAppThread);
7.     } catch (RemoteException ex) {
8.         // Ignore
9.     }
10. }
12. //ActivityManagerService.java 然后看看attachApplication方法
13. @Override
14. public final void attachApplication(IApplicationThread thread) {
15.     synchronized (this) {
16.         int callingPid = Binder.getCallingPid();
17.         final long origId = Binder.clearCallingIdentity();
18.         attachApplicationLocked(thread, callingPid);
19.         Binder.restoreCallingIdentity(origId);
20.     }
21. }

复制代码

往里面走，里面的代码很多，这儿根据我看过的源码，分为三个方向
1.关于application，他会走到 thread.bindApplication去绑定application，执行后续操作（创建application，执行onCreate生命周期）
2.关于activity，他会走到mStackSupervisor.attachApplicationLocked(app)执行有关activity的操作（走到scheduleLaunchActivity）
上面两个步骤，具体可看我之前的博客 Android App启动流程和源码详解-CSDN博客
3.关于service，他会走到 didSomething |= mServices.attachApplicationLocked(app, processName);执行service的后续操作。
关键代码：

1. private final boolean attachApplicationLocked(IApplicationThread thread,int pid) {
2.     if (app.instr != null) {//app的
3.         thread.bindApplication(processName, appInfo, providers,
4.                 app.instr.mClass,
5.                 profilerInfo, app.instr.mArguments,
6.                 app.instr.mWatcher,
7.                 app.instr.mUiAutomationConnection, testMode,
8.                 mBinderTransactionTrackingEnabled, enableTrackAllocation,
9.                 isRestrictedBackupMode || !normalMode, app.persistent,
10.                 new Configuration(getGlobalConfiguration()), app.compat,
11.                 getCommonServicesLocked(app.isolated),
12.                 mCoreSettingsObserver.getCoreSettingsLocked(),
13.                 buildSerial);
14.     } else {
15.         thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
16.                 null, null, null, testMode,
17.                 mBinderTransactionTrackingEnabled, enableTrackAllocation,
18.                 isRestrictedBackupMode || !normalMode, app.persistent,
19.                 new Configuration(getGlobalConfiguration()), app.compat,
20.                 getCommonServicesLocked(app.isolated),
21.                 mCoreSettingsObserver.getCoreSettingsLocked(),
22.                 buildSerial);
23.     }
24.    
25.     // See if the top visible activity is waiting to run in this process...
26.     if (normalMode) {
27.         try {//activity的
28.             if (mStackSupervisor.attachApplicationLocked(app)) {
29.                 didSomething = true;
30.             }
31.         } catch (Exception e) {
32.             Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
33.             badApp = true;
34.         }
35.     }
37.     // Find any services that should be running in this process...
38.     if (!badApp) {
39.         try {//sevice的
40.             didSomething |= mServices.attachApplicationLocked(app, processName);
41.             checkTime(startTime, "attachApplicationLocked: after mServices.attachApplicationLocked");
42.         } catch (Exception e) {
43.             Slog.wtf(TAG, "Exception thrown starting services in " + app, e);
44.             badApp = true;
45.         }
46.     }
47.    
48. }

复制代码

上面第三步，mServices.attachApplicationLocked看源码，会走到app.thread.scheduleCreateService(r, r.serviceInfo, mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo), app.repProcState);方法，哎，你看他又归去了，走到了ApplicationThread里去了，ApplicationThread是Activity的内部类（上面不创建进程也是调用的词方法），我们点进去看下源码：

1. public final void scheduleCreateService(IBinder token,  ServiceInfo info,
2.         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;
9.     sendMessage(H.CREATE_SERVICE, s);
10. }

复制代码

哎哟喂，殊途同归啊，和application和activity一样，最后都用到了用handler去处理消息。
来嘛，看下handler的handleMessage()方法

1. ...
2. case CREATE_SERVICE:
3.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate: " + String.valueOf(msg.obj)));
4.                     handleCreateService((CreateServiceData)msg.obj);
5.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
6.                     break;
7. ...

复制代码

继续往里走：handleCreateService((CreateServiceData)msg.obj);
1.通过类加载器 ClassLoader 来加载 Service 对象
2.创建一个 ContextImpl 对象，每个 Activity 和 Service 都有一个 Context 对象。

1. private void handleCreateService(CreateServiceData data) {
2.     Service service = null;
3.     try {
4.         //（1）通过类加载器来加载 Service 对象
5.         java.lang.ClassLoader cl = packageInfo.getClassLoader();
6.         service = (Service) cl.loadClass(data.info.name).newInstance();
7.     } catch (Exception e) {
8.         //......
9.     }
10.     //（2）这里创建 ContextImpl 对象
11.     ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
12.     context.setOuterContext(service);
13.     Application app = packageInfo.makeApplication(false, mInstrumentation);
14.     service.attach(context, this, data.info.name, data.token, app,ActivityManagerNative.getDefault());
15.     //（3）这里调用 Service 的 onCreate 方法
16.     service.onCreate();
17.     mServices.put(data.token, service);
18. }

复制代码

哎，这不就来了吗，最后执行了service的onCreate()生命周期。
二、bindService()

1.ContextImpl类中bindService()

具体使用：

1. TestActivity.java
2. private void test(){
3.     Intent intent = new Intent(this, XXXService.class);
4.     // bindService 的具体实现在 ContextImpl
5.     // BIND_AUTO_CREATE 参数具体使用的代码 ActivityServices
6.     bindService(intent, conn, BIND_AUTO_CREATE);
7. }
9. private ServiceConnection conn = new ServiceConnection() {  
10.     @Override  
11.     public void onServiceConnected(ComponentName name, IBinder service) {  
12.        // 绑定成功
13.     }  
14.     @Override  
15.     public void onServiceDisconnected(ComponentName name) {
16.       // 绑定结束
17.     }
18. }

复制代码

bindService源码：

1. @Override
2. public boolean bindService(Intent service, ServiceConnection conn,
3.         int flags) {
4.     // mMainThread.getHandler()，传入的 handle 是主线程的 Handle
5.     return bindServiceCommon(service, conn, flags, mMainThread.getHandler(),
6.             Process.myUserHandle());
7. }
9. private boolean bindServiceCommon(Intent service, ServiceConnection conn,
10.         int flags, Handler handler, UserHandle user) {
11.     IServiceConnection sd;
12.     if (mPackageInfo != null) {
13.         // 1，将传入的 ServiceConnection 转化为 IServiceConnection 返回
14.         // mPackgeInfo 是 LoadedApk
15.         sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);
16.     }
17.     validateServiceIntent(service);
18.     try {
19.         IBinder token = getActivityToken();
20.         ...
21.         // 2，Binder 调用 AMS 的 bindService 方法，下面具体分析
22.         int res = ActivityManagerNative.getDefault().bindService(
23.             mMainThread.getApplicationThread(), getActivityToken(), service,
24.             service.resolveTypeIfNeeded(getContentResolver()),
25.             sd, flags, getOpPackageName(), user.getIdentifier());
26.         return res != 0;
27.     }
28.     //...
29. }

复制代码

getServiceDispatcher方法

1. public final IServiceConnection getServiceDispatcher(ServiceConnection c,
2.         Context context, Handler handler, int flags) {
4.     synchronized (mServices) {
5.         LoadedApk.ServiceDispatcher sd = null;
6.         // private final ArrayMap<Context,
7.         // ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>> mServices
8.         // 根据当前的 Context 获取 ArrayMap<ServiceConnection,  LoadedApk.ServiceDispatcher>
9.         ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher> map = mServices.get(context);
10.         if (map != null) {
11.             // 如果存在，尝试根据当前的 ServiceConnection 获取 ServiceDispatcher
12.             sd = map.get(c);
13.         }
14.         if (sd == null) {
15.             // 如果与 ServiceConnection 对应的 ServiceDispatcher 不存在，创建一个保存了当前
16.                         // ServiceConnection 的 ServiceDispatcher 对象，
17.             // 并将之前传入的主线的 Handle 保存，同时创建一个 InnerConnection 对象保存
18.             sd = new ServiceDispatcher(c, context, handler, flags);
19.             if (map == null) {
20.                 map = new ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>();
21.                 mServices.put(context, map);
22.             }
23.             // 将该 ServiceConnection 与 ServiceDispatcher 关系保存
24.             map.put(c, sd);
25.         } else {
26.             // 如果最开始就获取到 ServiceDispatcher，比如多次 bindService，
27.             // 就会调用 ServiceDispatcher 的 validate 判断此次 bindService 是否合法
28.             // validate 的判断逻辑比较简单：
29.                         // 1.判断当前的 context 是否和之前 bindService 的一样
30.                         // 2.判断当前 handler 是否是主线程的 handle
31.             // 以上两个条件都满足的情况下正常执行，反之抛出相应的异常
32.             sd.validate(context, handler);
33.         }
34.         return sd.getIServiceConnection();
35.     }
36. }

复制代码

主要看ActivityManagerService.bindService()
2.ActivityManagerService.bindService()

1. public int bindService(IApplicationThread caller, IBinder token, Intent service,
2.         String resolvedType, IServiceConnection connection,
3.         int flags, String callingPackage, int userId) throws TransactionTooLargeException {
5.     //...
6.     synchronized(this) {
7.         // 调用 ActiveServices 的 bindServiceLocked 方法
8.         return mServices.bindServiceLocked(caller, token, service,
9.                 resolvedType, connection, flags, callingPackage, userId);
10.     }
11. }

复制代码

看到这里面调用了ActiveServices 的 bindServiceLocked，往里走：这里面代码长，但是主要调用是这样的：ActiveServices.bindServiceLocked() -> bringUpServiceLocked() -> realStartServiceLocked()
看realStartServiceLocked方法，刚才在我们startService的时候也调用了这个方法，但是因为它是bind的，以是有些许不同

1. private final void realStartServiceLocked(ServiceRecord r, ProcessRecord app,
2.         boolean execInFg) throws RemoteException {
3.     //...
4.     try {
5.         // 第一步，调用 ApplicationThread 的 scheduleCreateService 方法，
6.                 // 之后会实例化 Service 并调用 Service 的 onCreate 方法，这里的过程跟上面 startService 中一样。
7.         // 不会调用 onStartCommand
8.         app.thread.scheduleCreateService(r, r.serviceInfo,
9.                                 mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo),
10.                 app.repProcState);
11.     }
12.     //...
13.     // 第二步，调用 requestServiceBindingLocked
14.     requestServiceBindingLocked(r, execInFg);
15.     updateServiceClientActivitiesLocked(app, null, true);
17.     // 第三步
18.     // If the service is in the started state, and there are no
19.     // pending arguments, then fake up one so its onStartCommand() will
20.     // be called.
21.     if (r.startRequested && r.callStart && r.pendingStarts.size() == 0) {
22.         r.pendingStarts.add(new ServiceRecord.StartItem(r, false,
23.                         r.makeNextStartId(), null, null));
24.     }
25.     // StartItem 的 taskRemoved 如果是 false 的话，
26.         // 调用下面方法会调用 Service 的 onStartCommand
27.     sendServiceArgsLocked(r, execInFg, true);
28. }
30. private final boolean requestServiceBindingLocked(ServiceRecord r,
31.         IntentBindRecord i, boolean execInFg, boolean rebind)
32.         throws TransactionTooLargeException {
33.     if ((!i.requested || rebind) && i.apps.size() > 0) {
34.         try {
35.             // 调用 ApplicationThread 的 scheduleBindService 方法
36.             r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind,
37.                     r.app.repProcState);
38.         }
39.     }
40.     return true;
41. }

复制代码

3.ApplicationThread.scheduleBindService()方法

来来来，看下ApplicationThread.scheduleBindService()方法

• 调用 ApplicationThread 的 scheduleBindService，scheduleBindService 通过 mH 发送一个 H.BIND_SERVICE 消息，mH 收到该消息调用 handleBindService(BindServiceData data)。
  

 

1. private void handleBindService(BindServiceData data) {
2.         Service s = mServices.get(data.token);
3.         if (DEBUG_SERVICE)
4.             Slog.v(TAG, "handleBindService s=" + s + " rebind=" + data.rebind);
5.         if (s != null) {
6.             try {
7.                 data.intent.setExtrasClassLoader(s.getClassLoader());
8.                 data.intent.prepareToEnterProcess();
9.                 try {
10.                     if (!data.rebind) {
11.                    // 调用 Service 的 onBind，返回给客户端调用的 Binder
12.                         IBinder binder = s.onBind(data.intent);
13.                 // 调用 AMS 的 publishService，进而通知客户端连接成功
14.                         ActivityManager.getService().publishService(
15.                                 data.token, data.intent, binder);
16.                     } else {
17.                         s.onRebind(data.intent);
18.                         ActivityManager.getService().serviceDoneExecuting(
19.                                 data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
20.                     }
21.                     ensureJitEnabled();
22.                 } catch (RemoteException ex) {
23.                     throw ex.rethrowFromSystemServer();
24.                 }
25.             } catch (Exception e) {
26.                 if (!mInstrumentation.onException(s, e)) {
27.                     throw new RuntimeException(
28.                             "Unable to bind to service " + s
29.                                     + " with " + data.intent + ": " + e.toString(), e);
30.                 }
31.             }
32.         }
33.     }

复制代码

 


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。