Android应用程序组件Service与Activity一样，既可以在新的进程中启动，也可以在应用程序进程内部启动；前面我们已经分析了在新的进程中启动Service的过程，本文将要介绍在应用程序内部绑定Service的过程，这是一种在应用程序进程内部启动Service的方法。

在前面一篇文章Android进程间通信（IPC）机制Binder简要介绍和学习计划中，我们就曾经提到，在Android系统中，每一个应用程序都是由一些Activity和Service组成的，一般Service运行在独立的进程中，而Activity有可能运行在同一个进程中，也有可能运行在不同的进程中；在接下来的文章中，Android系统在新进程中启动自定义服务过程（startService）的原理分析一文介绍了在新的进程中启动Service的过程，Android应用程序启动过程源代码分析一文介绍了在新的进程中启动Activity的过程，而Android应用程序内部启动Activity过程（startActivity）的源代码分析一文则介绍了在应用程序进程内部启动Activity的过程；本文接过最后一棒，继续介绍在应用程序进程内部启动Service的过程，这种过程又可以称在应用程序进程内部绑定服务（bindService）的过程，这样，读者应该就可以对Android应用程序启动Activity和Service有一个充分的认识了。

这里仍然是按照老规矩，通过具体的例子来分析Android应用程序绑定Service的过程，而所使用的例子便是前面我们在介绍Android系统广播机制的一篇文章Android系统中的广播（Broadcast）机制简要介绍和学习计划中所开发的应用程序Broadcast了。

我们先简单回顾一下这个应用程序实例绑定Service的过程。在这个应用程序的MainActivity的onCreate函数中，会调用bindService来绑定一个计数器服务CounterService，这里绑定的意思其实就是在MainActivity内部获得CounterService的接口，所以，这个过程的第一步就是要把CounterService启动起来。当CounterService的onCreate函数被调用起来了，就说明CounterService已经启动起来了，接下来系统还要调用CounterService的onBind函数，跟CounterService要一个Binder对象，这个Binder对象是在CounterService内部自定义的CounterBinder类的一个实例，它继承于Binder类，里面实现一个getService函数，用来返回外部的CounterService接口。系统得到这个Binder对象之后，就会调用MainActivity在bindService函数里面传过来的ServiceConnection实例的onServiceConnected函数，并把这个Binder对象以参数的形式传到onServiceConnected函数里面，于是，MainActivity就可以调用这个Binder对象的getService函数来获得CounterService的接口了。

这个过程比较复杂，但总体来说，思路还是比较清晰的，整个调用过程为MainActivity.bindService->CounterService.onCreate->CounterService.onBind->MainActivity.ServiceConnection.onServiceConnection->CounterService.CounterBinder.getService。下面，我们就先用一个序列图来总体描述这个服务绑定的过程，然后就具体分析每一个步骤。

Step 1. ContextWrapper.bindService

这个函数定义在frameworks/base/core/java/android/content/ContextWrapper.java文件中：

        
                
  1. publicclassContextWrapperextendsContext{
    2.             
  2. ContextmBase;
    3.             
  3. ......
    4.             
    5.             
  5. @Override
    6.             
  6. publicbooleanbindService(Intentservice,ServiceConnectionconn,
    7.             
  7. intflags){
    8.             
  8. returnmBase.bindService(service,conn,flags);
    9.             
  9. }
    10.             
    11.             
  11. ......
    12.             
  12. }
    13.

这里的mBase是一个ContextImpl实例变量，于是就调用ContextImpl的bindService函数来进一步处理。

Step 2.ContextImpl.bindService

这个函数定义在frameworks/base/core/java/android/app/ContextImpl.java文件中：

        
                
  1. classContextImplextendsContext{
    2.             
  2. ......
    3.             
    4.             
  4. @Override
    5.             
  5. publicbooleanbindService(Intentservice,ServiceConnectionconn,
    6.             
  6. intflags){
    7.             
  7. IServiceConnectionsd;
    8.             
  8. if(mPackageInfo!=null){
    9.             
  9. sd=mPackageInfo.getServiceDispatcher(conn,getOuterContext(),
    10.             
  10. mMainThread.getHandler(),flags);
    11.             
  11. }else{
    12.             
  12. ......
    13.             
  13. }
    14.             
  14. try{
    15.             
  15. intres=ActivityManagerNative.getDefault().bindService(
    16.             
  16. mMainThread.getApplicationThread(),getActivityToken(),
    17.             
  17. service,service.resolveTypeIfNeeded(getContentResolver()),
    18.             
  18. sd,flags);
    19.             
  19. ......
    20.             
  20. returnres!=0;
    21.             
  21. }catch(RemoteExceptione){
    22.             
  22. returnfalse;
    23.             
  23. }
    24.             
  24. }
    25.             
    26.             
  26. ......
    27.             
    28.             
  28. }
    29.

这里的mMainThread是一个ActivityThread实例，通过它的getHandler函数可以获得一个Handler对象，有了这个Handler对象后，就可以把消息分发到ActivityThread所在的线程消息队列中去了，后面我们将会看到这个用法，现在我们暂时不关注，只要知道这里从ActivityThread处获得了一个Handler并且保存在下面要介绍的ServiceDispatcher中去就可以了。

我们先看一下ActivityThread.getHandler的实现，然后再回到这里的bindService函数来。

Step 3. ActivityThread.getHandler

这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

        
                
  1. publicfinalclassActivityThread{
    2.             
  2. ......
    3.             
    4.             
  4. finalHmH=newH();
    5.             
    6.             
  6. ......
    7.             
    8.             
  8. privatefinalclassHextendsHandler{
    9.             
  9. ......
    10.             
    11.             
  11. publicvoidhandleMessage(Messagemsg){
    12.             
  12. ......
    13.             
  13. }
    14.             
    15.             
  15. ......
    16.             
  16. }
    17.             
    18.             
  18. ......
    19.             
    20.             
  20. finalHandlergetHandler(){
    21.             
  21. returnmH;
    22.             
  22. }
    23.             
    24.             
  24. ......
    25.             
  25. }
    26.

这里返回的Handler是在ActivityThread类内部从Handler类继承下来的一个H类实例变量。

回到Step 2中的ContextImpl.bindService函数中，获得了这个Handler对象后，就调用mPackageInfo.getServiceDispatcher函数来获得一个IServiceConnection接口，这里的mPackageInfo的类型是LoadedApk，我们来看看它的getServiceDispatcher函数的实现，然后再回到ContextImpl.bindService函数来。

Step 4. LoadedApk.getServiceDispatcher

这个函数定义在frameworks/base/core/java/android/app/LoadedApk.java文件中：

        
                
  1. finalclassLoadedApk{
    2.             
  2. ......
    3.             
    4.             
  4. publicfinalIServiceConnectiongetServiceDispatcher(ServiceConnectionc,
    5.             
  5. Contextcontext,Handlerhandler,intflags){
    6.             
  6. synchronized(mServices){
    7.             
  7. LoadedApk.ServiceDispatchersd=null;
    8.             
  8. HashMap<ServiceConnection,LoadedApk.ServiceDispatcher>map=mServices.get(context);
    9.             
  9. if(map!=null){
    10.             
  10. sd=map.get(c);
    11.             
  11. }
    12.             
  12. if(sd==null){
    13.             
  13. sd=newServiceDispatcher(c,context,handler,flags);
    14.             
  14. if(map==null){
    15.             
  15. map=newHashMap<ServiceConnection,LoadedApk.ServiceDispatcher>();
    16.             
  16. mServices.put(context,map);
    17.             
  17. }
    18.             
  18. map.put(c,sd);
    19.             
  19. }else{
    20.             
  20. sd.validate(context,handler);
    21.             
  21. }
    22.             
  22. returnsd.getIServiceConnection();
    23.             
  23. }
    24.             
  24. }
    25.             
    26.             
  26. ......
    27.             
    28.             
  28. staticfinalclassServiceDispatcher{
    29.             
  29. privatefinalServiceDispatcher.InnerConnectionmIServiceConnection;
    30.             
  30. privatefinalServiceConnectionmConnection;
    31.             
  31. privatefinalHandlermActivityThread;
    32.             
  32. ......
    33.             
    34.             
  34. privatestaticclassInnerConnectionextendsIServiceConnection.Stub{
    35.             
  35. finalWeakReference<LoadedApk.ServiceDispatcher>mDispatcher;
    36.             
  36. ......
    37.             
    38.             
  38. InnerConnection(LoadedApk.ServiceDispatchersd){
    39.             
  39. mDispatcher=newWeakReference<LoadedApk.ServiceDispatcher>(sd);
    40.             
  40. }
    41.             
    42.             
  42. ......
    43.             
  43. }
    44.             
    45.             
  45. ......
    46.             
    47.             
  47. ServiceDispatcher(ServiceConnectionconn,
    48.             
  48. Contextcontext,HandleractivityThread,intflags){
    49.             
  49. mIServiceConnection=newInnerConnection(this);
    50.             
  50. mConnection=conn;
    51.             
  51. mActivityThread=activityThread;
    52.             
  52. ......
    53.             
  53. }
    54.             
    55.             
  55. ......
    56.             
    57.             
  57. IServiceConnectiongetIServiceConnection(){
    58.             
  58. returnmIServiceConnection;
    59.             
  59. }
    60.             
    61.             
  61. ......
    62.             
  62. }
    63.             
    64.             
  64. ......
    65.             
  65. }
    66.

在getServiceDispatcher函数中，传进来的参数context是一个MainActivity实例，先以它为Key值在mServices中查看一下，是不是已经存在相应的ServiceDispatcher实例，如果有了，就不用创建了，直接取出来。在我们这个情景中，需要创建一个新的ServiceDispatcher。在创建新的ServiceDispatcher实例的过程中，将上面传下来ServiceConnection参数c和Hanlder参数保存在了ServiceDispatcher实例的内部，并且创建了一个InnerConnection对象，这是一个Binder对象，一会是要传递给ActivityManagerService的，ActivityManagerServic后续就是要通过这个Binder对象和ServiceConnection通信的。

函数getServiceDispatcher最后就是返回了一个InnerConnection对象给ContextImpl.bindService函数。回到ContextImpl.bindService函数中，它接着就要调用ActivityManagerService的远程接口来进一步处理了。

Step 5. ActivityManagerService.bindService

这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

        
                
  1. classActivityManagerProxyimplementsIActivityManager
    2.             
  2. {
    3.             
  3. ......
    4.             
    5.             
  5. publicintbindService(IApplicationThreadcaller,IBindertoken,
    6.             
  6. Intentservice,StringresolvedType,IServiceConnectionconnection,
    7.             
  7. intflags)throwsRemoteException{
    8.             
  8. Parceldata=Parcel.obtain();
    9.             
  9. Parcelreply=Parcel.obtain();
    10.             
  10. data.writeInterfaceToken(IActivityManager.descriptor);
    11.             
  11. data.writeStrongBinder(caller!=null?caller.asBinder():null);
    12.             
  12. data.writeStrongBinder(token);
    13.             
  13. service.writeToParcel(data,0);
    14.             
  14. data.writeString(resolvedType);
    15.             
  15. data.writeStrongBinder(connection.asBinder());
    16.             
  16. data.writeInt(flags);
    17.             
  17. mRemote.transact(BIND_SERVICE_TRANSACTION,data,reply,0);
    18.             
  18. reply.readException();
    19.             
  19. intres=reply.readInt();
    20.             
  20. data.recycle();
    21.             
  21. reply.recycle();
    22.             
  22. returnres;
    23.             
  23. }
    24.             
    25.             
  25. ......
    26.             
  26. }
    27.

这个函数通过Binder驱动程序就进入到ActivityManagerService的bindService函数去了。

Step 6. ActivityManagerService.bindService

这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

        
                
  1. publicfinalclassActivityManagerServiceextendsActivityManagerNative
    2.             
  2. implementsWatchdog.Monitor,BatteryStatsImpl.BatteryCallback{
    3.             
  3. ......
    4.             
    5.             
  5. publicintbindService(IApplicationThreadcaller,IBindertoken,
    6.             
  6. Intentservice,StringresolvedType,
    7.             
  7. IServiceConnectionconnection,intflags){
    8.             
  8. ......
    9.             
    10.             
  10. synchronized(this){
    11.             
  11. ......
    12.             
  12. finalProcessRecordcallerApp=getRecordForAppLocked(caller);
    13.             
  13. ......
    14.             
    15.             
  15. ActivityRecordactivity=null;
    16.             
  16. if(token!=null){
    17.             
  17. intaindex=mMainStack.indexOfTokenLocked(token);
    18.             
  18. ......
    19.             
  19. activity=(ActivityRecord)mMainStack.mHistory.get(aindex);
    20.             
  20. }
    21.             
    22.             
  22. ......
    23.             
    24.             
  24. ServiceLookupResultres=
    25.             
  25. retrieveServiceLocked(service,resolvedType,
    26.             
  26. Binder.getCallingPid(),Binder.getCallingUid());
    27.             
    28.             
  28. ......
    29.             
    30.             
  30. ServiceRecords=res.record;
    31.             
    32.             
  32. finallongorigId=Binder.clearCallingIdentity();
    33.             
    34.             
  34. ......
    35.             
    36.             
  36. AppBindRecordb=s.retrieveAppBindingLocked(service,callerApp);
    37.             
  37. ConnectionRecordc=newConnectionRecord(b,activity,
    38.             
  38. connection,flags,clientLabel,clientIntent);
    39.             
    40.             
  40. IBinderbinder=connection.asBinder();
    41.             
  41. ArrayList<ConnectionRecord>clist=s.connections.get(binder);
    42.             
    43.             
  43. if(clist==null){
    44.             
  44. clist=newArrayList<ConnectionRecord>();
    45.             
  45. s.connections.put(binder,clist);
    46.             
  46. }
    47.             
  47. clist.add(c);
    48.             
  48. b.connections.add(c);
    49.             
  49. if(activity!=null){
    50.             
  50. if(activity.connections==null){
    51.             
  51. activity.connections=newHashSet<ConnectionRecord>();
    52.             
  52. }
    53.             
  53. activity.connections.add(c);
    54.             
  54. }
    55.             
  55. b.client.connections.add(c);
    56.             
  56. clist=mServiceConnections.get(binder);
    57.             
  57. if(clist==null){
    58.             
  58. clist=newArrayList<ConnectionRecord>();
    59.             
  59. mServiceConnections.put(binder,clist);
    60.             
  60. }
    61.             
    62.             
  62. clist.add(c);
    63.             
    64.             
  64. if((flags&Context.BIND_AUTO_CREATE)!=0){
    65.             
  65. ......
    66.             
  66. if(!bringUpServiceLocked(s,service.getFlags(),false)){
    67.             
  67. return0;
    68.             
  68. }
    69.             
  69. }
    70.             
    71.             
  71. ......
    72.             
  72. }
    73.             
    74.             
  74. return1;
    75.             
  75. }
    76.             
    77.             
  77. ......
    78.             
  78. }
    79.

函数首先根据传进来的参数token是MainActivity在ActivityManagerService里面的一个令牌，通过这个令牌就可以将这个代表MainActivity的ActivityRecord取回来了。

接着通过retrieveServiceLocked函数，得到一个ServiceRecord，这个ServiceReocrd描述的是一个Service对象，这里就是CounterService了，这是根据传进来的参数service的内容获得的。回忆一下在MainActivity.onCreate函数绑定服务的语句：

        
                
  1. IntentbindIntent=newIntent(MainActivity.this,CounterService.class);
    2.             
  2. bindService(bindIntent,serviceConnection,Context.BIND_AUTO_CREATE);
    3.

这里的参数service，就是上面的bindIntent了，它里面设置了CounterService类的信息（CounterService.class），因此，这里可以通过它来把CounterService的信息取出来，并且保存在ServiceRecord对象s中。

接下来，就是把传进来的参数connection封装成一个ConnectionRecord对象。注意，这里的参数connection是一个Binder对象，它的类型是LoadedApk.ServiceDispatcher.InnerConnection，是在Step 4中创建的，后续ActivityManagerService就是要通过它来告诉MainActivity，CounterService已经启动起来了，因此，这里要把这个ConnectionRecord变量c保存下来，它保在在好几个地方，都是为了后面要用时方便地取回来的，这里就不仔细去研究了，只要知道ActivityManagerService要使用它时就可以方便地把它取出来就可以了，具体后面我们再分析。

最后，传进来的参数flags的位Context.BIND_AUTO_CREATE为1（参见上面MainActivity.onCreate函数调用bindService函数时设置的参数），因此，这里会调用bringUpServiceLocked函数进一步处理。

更多相关文章

  1. Android视图加载到窗口的过程
  2. Android(安卓)耳机系统综述
  3. 【读书笔记】Android(安卓)应用程序进程的启动过程
  4. Android架构分析之Android智能指针（一）
  5. Android系统启动流程简析
  6. 从零开始--系统深入学习android(已完成部分的目录--带链接)
  7. 基于Google Android(安卓)操作系统的机顶盒
  8. [置顶] 介绍下什么是android呢？
  9. android 优化之字节对齐

随机推荐

  1. Python学习系列（六）(模块)
  2. 校招录取之后前往公司实习，现在感觉自己前
  3. 如何将dict转换为spark map输出
  4. 当使用一个传送到另一个的python文件时，我
  5. matplotlib绘制符合论文要求的图片
  6. classmethod，staticmethod，还有类里面一般
  7. Python文件操作大全，随机删除文件夹内的任
  8. 获取错误“ValueError：int（）的无效文字，基数
  9. C++各大有名库的介绍——准标准库Boost
  10. 从Python中的列表元素中删除URL