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

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

       在Android系统中，每一个应用程序都是由一些Activity和Service组成的，一般Service运行在独立的进程中，而Activity有可能运行在同一个进程中，也有可能运行在不同的进程中；本文继续介绍在应用程序进程内部启动Service的过程，这种过程又可以称在应用程序进程内部绑定服务（bindService）的过程，这样，读者应该就可以对Android应用程序启动Activity和Service有一个充分的认识了。

        我们先简单回顾一下这个应用程序实例绑定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实例的**erviceConnected函数，并把这个Binder对象以参数的形式传到**erviceConnected函数里面，于是，MainActivity就可以调用这个Binder对象的getService函数来获得CounterService的接口了。

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

        Step 1. ContextWrapper.bindService

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

• class ContextImpl extends Context {
•     ......
•     @Override
•     public boolean bindService(Intent service, ServiceConnection conn,
•             int flags) {
•         IServiceConnection sd;
•         if (mPackageInfo != null) {
•             sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(),
•                 mMainThread.getHandler(), flags);
•         } else {
•             ......
•         }
•         try {
•             int res = ActivityManagerNative.getDefault().bindService(
•                 mMainThread.getApplicationThread(), getActivityToken(),
•                 service, service.resolveTypeIfNeeded(getContentResolver()),
•                 sd, flags);
•             ......
•             return res != 0;
•         } catch (RemoteException e) {
•             return false;
•         }
•     }
•     ......
• }
  

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

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

        Step 3. ActivityThread.getHandler

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

• final class LoadedApk {
•     ......
•     public final IServiceConnection getServiceDispatcher(ServiceConnection c,
•             Context context, Handler handler, int flags) {
•         synchronized (mServices) {
•             LoadedApk.ServiceDispatcher sd = null;
•             HashMap<ServiceConnection, LoadedApk.ServiceDispatcher> map = mServices.get(context);
•             if (map != null) {
•                 sd = map.get(c);
•             }
•             if (sd == null) {
•                 sd = new ServiceDispatcher(c, context, handler, flags);
•                 if (map == null) {
•                     map = new HashMap<ServiceConnection, LoadedApk.ServiceDispatcher>();
•                     mServices.put(context, map);
•                 }
•                 map.put(c, sd);
•             } else {
•                 sd.validate(context, handler);
•             }
•             return sd.getIServiceConnection();
•         }
•     }
•     ......
•     static final class ServiceDispatcher {
•         private final ServiceDispatcher.InnerConnection mIServiceConnection;
•         private final ServiceConnection mConnection;
•         private final Handler mActivityThread;
•         ......
•         private static class InnerConnection extends IServiceConnection.Stub {
•             final WeakReference<LoadedApk.ServiceDispatcher> mDispatcher;
•             ......
•             InnerConnection(LoadedApk.ServiceDispatcher sd) {
•                 mDispatcher = new WeakReference<LoadedApk.ServiceDispatcher>(sd);
•             }
•             ......
•         }
•         ......
•         ServiceDispatcher(ServiceConnection conn,
•                 Context context, Handler activityThread, int flags) {
•             mIServiceConnection = new InnerConnection(this);
•             mConnection = conn;
•             mActivityThread = activityThread;
•             ......
•         }
•         ......
•         IServiceConnection getIServiceConnection() {
•             return mIServiceConnection;
•         }
•         ......
•     }
•     ......
• }
  

         在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文件中：

• public final class ActivityManagerService extends ActivityManagerNative
•         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
•     ......
•     public int bindService(IApplicationThread caller, IBinder token,
•             Intent service, String resolvedType,
•             IServiceConnection connection, int flags) {
•         ......
•         synchronized(this) {
•             ......
•             final ProcessRecord callerApp = getRecordForAppLocked(caller);
•             ......
•             ActivityRecord activity = null;
•             if (token != null) {
•                 int aindex = mMainStack.indexOfTokenLocked(token);
•                 ......
•                 activity = (ActivityRecord)mMainStack.mHistory.get(aindex);
•             }
•             ......
•             ServiceLookupResult res =
•                 retrieveServiceLocked(service, resolvedType,
•                 Binder.getCallingPid(), Binder.getCallingUid());
•             ......
•             ServiceRecord s = res.record;
•             final long origId = Binder.clearCallingIdentity();
•             ......
•             AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
•             ConnectionRecord c = new ConnectionRecord(b, activity,
•                 connection, flags, clientLabel, clientIntent);
•             IBinder binder = connection.asBinder();
•             ArrayList<ConnectionRecord> clist = s.connecti**.get(binder);
•             if (clist == null) {
•                 clist = new ArrayList<ConnectionRecord>();
•                 s.connecti**.put(binder, clist);
•             }
•             clist.add(c);
•             b.connecti**.add(c);
•             if (activity != null) {
•                 if (activity.connecti** == null) {
•                     activity.connecti** = new HashSet<ConnectionRecord>();
•                 }
•                 activity.connecti**.add(c);
•             }
•             b.client.connecti**.add(c);
•             clist = mServiceConnecti**.get(binder);
•             if (clist == null) {
•                 clist = new ArrayList<ConnectionRecord>();
•                 mServiceConnecti**.put(binder, clist);
•             }
•             clist.add(c);
•             if ((flags&Context.BIND_AUTO_CREATE) != 0) {
•                 ......
•                 if (!bringUpServiceLocked(s, service.getFlags(), false)) {
•                     return 0;
•                 }
•             }
•             ......
•         }
•         return 1;
•     }
•     ......
• }
  

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

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

• public final class ActivityManagerService extends ActivityManagerNative
•         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
•     ......
•     private final boolean bringUpServiceLocked(ServiceRecord r,
•             int intentFlags, boolean whileRestarting) {
•         ......
•         final String appName = r.processName;
•         ProcessRecord app = getProcessRecordLocked(appName, r.appInfo.uid);
•         if (app != null && app.thread != null) {
•             try {
•                 realStartServiceLocked(r, app);
•                 return true;
•             } catch (RemoteException e) {
•                 ......
•             }
•         }
•         // Not running -- get it started, and enqueue this service record
•         // to be executed when the app comes up.
•         if (startProcessLocked(appName, r.appInfo, true, intentFlags,
•             "service", r.name, false) == null) {
•                 ......
•         }
•         ......
•     }
•     ......
• }
  

      我们没有在程序的AndroidManifest.xml配置文件中设置CounterService的process属性值，因此，它默认就为application标签的process属性值，而application标签的process属性值也没有设置，于是，它们就默认为应用程序的包名了，即这里的appName的值为"shy.luo.broadcast"。接下来根据appName和应用程序的uid值获得一个ProcessRecord记录，由于之前在启动MainActivity的时候，已经根据这个appName和uid值创建了一个ProcessReocrd对象，因此，这里取回来的app和app.thread均不为null，于是，就执行realStartServiceLocked函数来执行下一步操作了。

        如果这里得到的ProcessRecord变量app为null，又是什么情况呢？在这种情况下，就会执行后面的startProcessLocked函数来创建一个新的进程，然后在这个新的进程中启动这个Service了

        Step 8. ActivityManagerService.realStartServiceLocked

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

• class ApplicationThreadProxy implements IApplicationThread {
•     ......
•     public final void scheduleCreateService(IBinder token, ServiceInfo info)
•             throws RemoteException {
•         Parcel data = Parcel.obtain();
•         data.writeInterfaceToken(IApplicationThread.descriptor);
•         data.writeStrongBinder(token);
•         info.writeToParcel(data, 0);
•         mRemote.transact(SCHEDULE_CREATE_SERVICE_TRANSACTION, data, null,
•             IBinder.FLAG_ONEWAY);
•         data.recycle();
•     }
•     ......
• }
  

         这里通过Binder驱动程序就进入到ApplicationThread的scheduleCreateService函数去了。

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

• public final class ActivityThread {
•     ......
•     // if the thread hasn't started yet, we don't have the handler, so just
•     // save the messages until we're ready.
•     private final void queueOrSendMessage(int what, Object obj) {
•         queueOrSendMessage(what, obj, 0, 0);
•     }
•     private final void queueOrSendMessage(int what, Object obj, int arg1) {
•         queueOrSendMessage(what, obj, arg1, 0);
•     }
•     private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
•         synchronized (this) {
•             ......
•             Message msg = Message.obtain();
•             msg.what = what;
•             msg.obj = obj;
•             msg.arg1 = arg1;
•             msg.arg2 = arg2;
•             mH.sendMessage(msg);
•         }
•     }
•     ......
• }
  

        这个消息最终是通过mH.sendMessage发送出去的，这里的mH是一个在ActivityThread内部定义的一个类，继承于Hanlder类，用于处理消息的。

        Step 12. H.sendMessage

        由于H类继承于Handler类，因此，这里实际执行的Handler.sendMessage函数，这个函数定义在frameworks/base/core/java/android/os/Handler.java文件，这里我们就不看了，有兴趣的读者可以自己研究一下，调用了这个函数之后，这个消息就真正地进入到ActivityThread的消息队列去了，最终这个消息由H.handleMessage函数来处理，这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

• public final class ActivityThread {
•     ......
•     private final void handleCreateService(CreateServiceData data) {
•         ......
•         LoadedApk packageInfo = getPackageInfoNoCheck(
•         data.info.applicationInfo);
•         Service service = null;
•         try {
•             java.lang.ClassLoader cl = packageInfo.getClassLoader();
•             service = (Service) cl.loadClass(data.info.name).newInstance();
•         } catch (Exception e) {
•             ......
•         }
•         try {
•             ......
•             ContextImpl context = new ContextImpl();
•             context.init(packageInfo, null, this);
•             Application app = packageInfo.makeApplication(false, mInstrumentation);
•             context.setOuterContext(service);
•             service.attach(context, this, data.info.name, data.token, app,
•                 ActivityManagerNative.getDefault());
•             service.onCreate();
•             mServices.put(data.token, service);
•             ......
•         } catch (Exception e) {
•             ......
•         }
•     }
•     ......
• }
  

         这个函数的工作就是把CounterService类加载到内存中来，然后调用它的onCreate函数。

         Step 14. CounterService.onCreate

         这个函数定义在应用程序Broadcast的工程目录下的src/shy/luo/broadcast/CounterService.java文件中：

• public final class ActivityManagerService extends ActivityManagerNative
•         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
•     ......
•     private final void requestServiceBindingsLocked(ServiceRecord r) {
•         Iterator<IntentBindRecord> bindings = r.bindings.values().iterator();
•         while (bindings.hasNext()) {
•             IntentBindRecord i = bindings.next();
•             if (!requestServiceBindingLocked(r, i, false)) {
•                 break;
•             }
•         }
•     }
•     private final boolean requestServiceBindingLocked(ServiceRecord r,
•             IntentBindRecord i, boolean rebind) {
•         ......
•         if ((!i.requested || rebind) && i.apps.size() > 0) {
•           try {
•               ......
•               r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind);
•               ......
•           } catch (RemoteException e) {
•               ......
•           }
•         }
•         return true;
•     }
•     ......
• }