Android应用程序绑定服务（bindService）的过程源代码分析（3）

1. public final class ActivityThread {   
2.     ......   
3.    
4.     public final void scheduleBindService(IBinder token, Intent intent,   
5.             boolean rebind) {   
6.         BindServiceData s = new BindServiceData();   
7.         s.token = token;   
8.         s.intent = intent;   
9.         s.rebind = rebind;   
10.    
11.         queueOrSendMessage(H.BIND_SERVICE, s);   
12.     }   
13.    
14.     ......   
15. }   

       这里调用ActivityThread.handleBindService函数来进一步处理。

         Step 20. ActivityThread.handleBindService

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

1. public final class ActivityThread {   
2.     ......   
3.    
4.     private final void handleBindService(BindServiceData data) {   
5.         Service s = mServices.get(data.token);   
6.         if (s != null) {   
7.             try {   
8.                 data.intent.setExtrasClassLoader(s.getClassLoader());   
9.                 try {   
10.                     if (!data.rebind) {   
11.                         IBinder binder = s.onBind(data.intent);   
12.                         ActivityManagerNative.getDefault().publishService(   
13.                             data.token, data.intent, binder);   
14.                     } else {   
15.                         ......   
16.                     }   
17.                     ......   
18.                 } catch (RemoteException ex) {   
19.                 }   
20.             } catch (Exception e) {   
21.                 ......   
22.             }   
23.         }   
24.     }   
25.    
26.     ......   
27. }   

        在前面的Step 13执行ActivityThread.handleCreateService函数中，已经将这个CounterService实例保存在mServices中，因此，这里首先通过data.token值将它取回来，保存在本地变量s中，接着执行了两个操作，一个操作是调用s.onBind，即CounterService.onBind获得一个Binder对象，另一个操作就是把这个Binder对象传递给ActivityManagerService。

        我们先看CounterService.onBind操作，然后再回到ActivityThread.handleBindService函数中来。

        Step 21. CounterService.onBind

        这个函数定义在Android系统中的广播（Broadcast）机制简要介绍和学习计划中一文中所介绍的应用程序Broadcast的工程目录下的src/shy/luo/broadcast/CounterService.java文件中：

1. public class CounterService extends Service implements ICounterService {   
2.     ......   
3.    
4.     private final IBinder binder = new CounterBinder();     
5.    
6.     public class CounterBinder extends Binder {     
7.         public CounterService getService() {     
8.             return CounterService.this;     
9.         }     
10.     }     
11.    
12.     @Override     
13.     public IBinder onBind(Intent intent) {     
14.         return binder;     
15.     }     
16.    
17.     ......   
18. }   

        这里的onBind函数返回一个是CounterBinder类型的Binder对象，它里面实现一个成员函数getService，用于返回CounterService接口。

        至此，应用程序绑定服务过程中的第二步CounterService.onBind就完成了。

        回到ActivityThread.handleBindService函数中，获得了这个CounterBinder对象后，就调用ActivityManagerProxy.publishService来通知MainActivity，CounterService已经连接好了。
        Step 22. ActivityManagerProxy.publishService

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

1. class ActivityManagerProxy implements IActivityManager   
2. {   
3.     ......   
4.    
5.     public void publishService(IBinder token,   
6.     Intent intent, IBinder service) throws RemoteException {   
7.         Parcel data = Parcel.obtain();   
8.         Parcel reply = Parcel.obtain();   
9.         data.writeInterfaceToken(IActivityManager.descriptor);   
10.         data.writeStrongBinder(token);   
11.         intent.writeToParcel(data, 0);   
12.         data.writeStrongBinder(service);   
13.         mRemote.transact(PUBLISH_SERVICE_TRANSACTION, data, reply, 0);   
14.         reply.readException();   
15.         data.recycle();   
16.         reply.recycle();   
17.     }   
18.    
19.     ......   
20. }   

         这里通过Binder驱动程序就进入到ActivityManagerService的publishService函数中去了。

         Step 23. ActivityManagerService.publishService

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

1. public final class ActivityManagerService extends ActivityManagerNative   
2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
3.     ......   
4.    
5.     public void publishService(IBinder token, Intent intent, IBinder service) {   
6.         ......   
7.         synchronized(this) {   
8.             ......   
9.             ServiceRecord r = (ServiceRecord)token;   
10.             ......   
11.    
12.             ......   
13.             if (r != null) {   
14.                 Intent.FilterComparison filter   
15.                     = new Intent.FilterComparison(intent);   
16.                 IntentBindRecord b = r.bindings.get(filter);   
17.                 if (b != null && !b.received) {   
18.                     b.binder = service;   
19.                     b.requested = true;   
20.                     b.received = true;   
21.                     if (r.connections.size() > 0) {   
22.                         Iterator<ArrayList<ConnectionRecord>> it   
23.                             = r.connections.values().iterator();   
24.                         while (it.hasNext()) {   
25.                             ArrayList<ConnectionRecord> clist = it.next();   
26.                             for (int i=0; i<clist.size(); i++) {   
27.                                 ConnectionRecord c = clist.get(i);   
28.                                 ......   
29.                                 try {   
30.                                     c.conn.connected(r.name, service);   
31.                                 } catch (Exception e) {   
32.                                     ......   
33.                                 }   
34.                             }   
35.                         }   
36.                     }   
37.                 }   
38.    
39.                 ......   
40.             }   
41.         }   
42.     }   
43.    
44.     ......   
45. }   

      这里传进来的参数token是一个ServiceRecord对象，它是在上面的Step 6中创建的，代表CounterServi

1.    ServiceRecord s = res.record;   
2.    
3.    ......   
4.    
5.    ConnectionRecord c = new ConnectionRecord(b, activity,   
6.     connection, flags, clientLabel, clientIntent);   
7.    
8.    IBinder binder = connection.asBinder();   
9.    ArrayList<ConnectionRecord> clist = s.connections.get(binder);   
10.    
11.    if (clist == null) {   
12. clist = new ArrayList<ConnectionRecord>();   
13. s.connections.put(binder, clist);   
14.    }   

   因此，这里可以从r.connections中将这个ConnectionRecord取出来：

1.    Iterator<ArrayList<ConnectionRecord>> it   
2. = r.connections.values().iterator();   
3.    while (it.hasNext()) {   
4. ArrayList<ConnectionRecord> clist = it.next();   
5. for (int i=0; i<clist.size(); i++) {   
6.         ConnectionRecord c = clist.get(i);   
7.     ......   
8.     try {   
9.         c.conn.connected(r.name, service);   
10.     } catch (Exception e) {   
11.         ......   
12.     }   
13. }   
14.    }   

        每一个ConnectionRecord里面都有一个成员变量conn，它的类型是IServiceConnection，是一个Binder对象的远程接口，这个Binder对象又是什么呢？这就是我们在Step 
4中创建的LoadedApk.ServiceDispatcher.InnerConnection对象了。因此，这里执行c.conn.connected函数后就会进入到LoadedApk.ServiceDispatcher.InnerConnection.connected函数中去了。

        Step 24. InnerConnection.connected

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

1. final class LoadedApk {   
2.     ......   
3.    
4.     static final class ServiceDispatcher {   
5.         ......   
6.    
7.         private static class InnerConnection extends IServiceConnection.Stub {   
8.             ......   
9.    
10.             public void connected(ComponentName name, IBinder service) throws RemoteException {   
11.                 LoadedApk.ServiceDispatcher sd = mDispatcher.get();   
12.                 if (sd != null) {   
13.                     sd.connected(name, service);   
14.                 }   
15.             }   
16.             ......   
17.         }   
18.    
19.         ......   
20.     }   
21.    
22.     ......   
23. }   

     这里它将操作转发给ServiceDispatcher.connected函数。

         Step 25. ServiceDispatcher.connected

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

1. final class LoadedApk {   
2.     ......   
3.    
4.     static final class ServiceDispatcher {   
5.         ......   
6.    
7.         public void connected(ComponentName name, IBinder service) {   
8.             if (mActivityThread != null) {   
9.                 mActivityThread.post(new RunConnection(name, service, 0));   
10.             } else {   
11.                 ......   
12.             }   
13.         }   
14.    
15.         ......   
16.     }   
17.    
18.     ......   
19. }   

        我们在前面Step 4中说到，这里的mActivityThread是一个Handler实例，它是通过ActivityThread.getHandler函数得到的，因此，调用它的post函数后，就会把一个消息放到ActivityThread的消息队列中去了。

        Step 26. H.post

        由于H类继承于Handler类，因此，这里实际执行的Handler.post函数，这个函数定义在frameworks/base/core/java/android/os/Handler.java文件，这里我们就不看了，有兴趣的读者可以自己研究一下，调用了这个函数之后，这个消息就真正地进入到ActivityThread的消息队列去了，与sendMessage把消息放在消息队列不一样的地方是，post方式发送的消息不是由这个Handler的handleMessage函数来处理的，而是由post的参数Runnable的run函数来处理的。这里传给post的参数是一个RunConnection类型的参数，它继承了Runnable类，因此，最终会调用RunConnection.run函数来处理这个消息。

       Step 27. RunConnection.run

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

1. final class LoadedApk {   
2.     ......   
3.    
4.     static final class ServiceDispatcher {   
5.         ......   
6.    
7.         private final class RunConnection implements Runnable {   
8.             ......   
9.    
10.             public void run() {   
11.                 if (mCommand == 0) {   
12.                     doConnected(mName, mService);   
13.                 } else if (mCommand == 1) {   
14.                     ......   
15.                 }   
16.             }   
17.    
18.             ......   
19.         }   
20.    
21.         ......   
22.     }   
23.    
24.     ......   
25. }   

这里的mCommand值为0，于是就执行ServiceDispatcher.doConnected函数来进一步操作了。

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

1. final class LoadedApk {   
2.     ......   
3.    
4.     static final class ServiceDispatcher {   
5.         ......   
6.    
7.         public void doConnected(ComponentName name, IBinder service) {   
8.             ......   
9.    
10.             // If there is a new service, it is now connected.   
11.             if (service != null) {   
12.                 mConnection.onServiceConnected(name, service);   
13.             }   
14.         }   
15.    
16.    
17.         ......   
18.     }   
19.    
20.     ......   
21. }   

       这里主要就是执行成员变量mConnection的onServiceConnected函数，这里的mConnection变量的类型的ServiceConnection，它是在前面的Step 4中设置好的，这个ServiceConnection实例是MainActivity类内部创建的，在调用bindService函数时保存在LoadedApk.ServiceDispatcher类中，用它来换取一个IServiceConnection对象，传给ActivityManagerService。

        Step 29. ServiceConnection.onServiceConnected

        这个函数定义在Android系统中的广播（Broadcast）机制简要介绍和学习计划中一文中所介绍的应用程序Broadcast的工程目录下的src/shy/luo/broadcast/MainActivity.java文件中：

1. public class MainActivity extends Activity implements OnClickListener {     
2.     ......   
3.    
4.     private ServiceConnection serviceConnection = new ServiceConnection() {     
5.         public void onServiceConnected(ComponentName className, IBinder service) {     
6.             counterService = ((CounterService.CounterBinder)service).getService();     
7.    
8.             Log.i(LOG_TAG, "Counter Service Connected");     
9.         }     
10.         ......   
11.     };     
12.        
13.     ......   
14. }   

        这里传进来的参数service是一个Binder对象，就是前面在Step 21中从CounterService那里得到的ConterBinder对象，因此，这里可以把它强制转换为CounterBinder引用，然后调用它的getService函数。

        至此，应用程序绑定服务过程中的第三步MainActivity.ServiceConnection.onServiceConnection就完成了。

        Step 30. CounterBinder.getService

        这个函数定义在Android系统中的广播（Broadcast）机制简要介绍和学习计划中一文中所介绍的应用程序Broadcast的工程目录下的src/shy/luo/broadcast/CounterService.java文件中：

1. public class CounterService extends Service implements ICounterService {     
2.     ......   
3.    
4.     public class CounterBinder extends Binder {     
5.         public CounterService getService() {     
6.             return CounterService.this;     
7.         }     
8.     }     
9.    
10.     ......   
11. }   

        这里就把CounterService接口返回给MainActivity了。

        至此，应用程序绑定服务过程中的第四步CounterService.CounterBinder.getService就完成了。

        这样，Android应用程序绑定服务（bindService）的过程的源代码分析就完成了，总结一下这个过程：

        1. Step 1 -  Step 14，MainActivity调用bindService函数通知ActivityManagerService，它要启动CounterService这个服务，ActivityManagerService于是在MainActivity所在的进程内部把CounterService启动起来，并且调用它的onCreate函数；

        2. Step 15 - Step 21，ActivityManagerService把CounterService启动起来后，继续调用CounterService的onBind函数，要求CounterService返回一个Binder对象给它；

        3. Step 22 - Step 29，ActivityManagerService从CounterService处得到这个Binder对象后，就把它传给MainActivity，即把这个Binder对象作为参数传递给MainActivity内部定义的ServiceConnection对象的onServiceConnected函数；

        4. Step 30，MainActivity内部定义的ServiceConnection对象的onServiceConnected函数在得到这个Binder对象后，就通过它的getService成同函数获得CounterService接口。