绑定式Service在CS结构中扮演着Server的角色。绑定式Service允许其他组件（如Activity）绑定该Service、发送请求、接收响应、甚至IPC通信（ interprocess communication）。绑定式Service通常服务于其他应用程序的组件、且没有明确的后台的概念（does not run in the background indefinitely）。

绑定式Service基础（The Basics）

创建绑定式Service（Creating a Bound Service）

• 继承Binder类（Extending the Binder class）：Binder是一个实现了IBinder接口的类。若Service只允许被本应用所在的进程访问（这是大多数情况），您需要继承Binder类，并将该对象作为onBind()方法的返回值。这样，与Service绑定的组件就可以通过该返回对象访问Binder的继承类中的public方法、甚至是Service中的方法（to directly access public methods available in either the Binder implementation or even the Service）。

  若在您的应用程序中，Service仅作为一个在后台工作的组件，那么这种方式最好不过了。除非您需要Service进行跨进程通信。

• 使用Messenger（Using a Messenger）：如需要使用IBinder进行跨进程通信，您应当为Service创建一个Messenger对象。这样，Service可以定义一个Handler对象以接受不同类型的Message。Handler是Messenger的基础，它可以在客户端与IBinder共享（This Handler is the basis for a Messenger that can then share an IBinder with the client），并允许使用Message对象向Service端发送指令（allowing the client to send commands to the service using Message objects）。除此之外，亦可以在client端定义Messenger，这样Service端可以回传信息。

• 使用AIDL（Using AIDL）：AIDL（Android Interface Definition Language）是Android接口定义语言的缩写。大多数应用程序并不应该使用AIDL创建bound Service，因为这需要应用程序有处理多线程的能力，而这会使应用程序变得复杂，在本文中并不打算具体介绍AIDL，如需访问有关AIDL的官方原文，您可以点击这个链接：《Android Interface Definition Language (AIDL)》。

继承Binder类（Extending the Binder class）

1. 在Service类中创建一个继承于Binder的内部类。在Service类中定义public方法，以便client端可以访问。在继承于Binder的内部类中返回该Service实例。将该内部类实例作为onBind()返回参数。
2. 在客户端中的onServiceConnected()回调方法中接受Binder对象，并访问Service中的public方法。

public class LocalService extends Service {
    // Binder given to clients
    private final IBinder mBinder = new LocalBinder();
    // Random number generator
    private final Random mGenerator = new Random();

    /**
     * Class used for the client Binder.  Because we know this service always
     * runs in the same process as its clients, we don‘t need to deal with IPC.
     */
    public class LocalBinder extends Binder {
        LocalService getService() {
            // Return this instance of LocalService so clients can call public methods
            return LocalService.this;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    /** method for clients */
    public int getRandomNumber() {
      return mGenerator.nextInt(100);
    }
}

public class BindingActivity extends Activity {
    LocalService mService;
    boolean mBound = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to LocalService
        Intent intent = new Intent(this, LocalService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

    /** Called when a button is clicked (the button in the layout file attaches to
      * this method with the android:onClick attribute) */
    public void onButtonClick(View v) {
        if (mBound) {
            // Call a method from the LocalService.
            // However, if this call were something that might hang, then this request should
            // occur in a separate thread to avoid slowing down the activity performance.
            int num = mService.getRandomNumber();
            Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
        }
    }

    /** Defines callbacks for service binding, passed to bindService() */
    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // We‘ve bound to LocalService, cast the IBinder and get LocalService instance
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBound = false;
        }
    };
}

使用Messenger绑定Service（Using a Messenger）

• 继承Handler类，并实现回调方法handleMessage()，每当client端访问Service中的方法时，handleMessage()都将回调（receives a callback for each call from a client）。
• 需在Service中创建一个Messenger对象，构造该对象需传入一个Handler参数。
• 调用Messenger的getBinder()返回一个IBinder对象，将该对象作为onBind()回调方法的返回值。
• client端通过onServiceConnected()回传的IBinder参数，构造Messenger对象，并将Message信息传入Messenger对象，发送给Service。
• Service在Handler的handleMessage()方法中接收Message信息。

public class MessengerService extends Service {
    /** Command to the service to display a message */
    static final int MSG_SAY_HELLO = 1;

    /**
     * Handler of incoming messages from clients.
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */
    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
        return mMessenger.getBinder();
    }
}

public class ActivityMessenger extends Activity {
    /** Messenger for communicating with the service. */
    Messenger mService = null;

    /** Flag indicating whether we have called bind on the service. */
    boolean mBound;

    /**
     * Class for interacting with the main interface of the service.
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // This is called when the connection with the service has been
            // established, giving us the object we can use to
            // interact with the service.  We are communicating with the
            // service using a Messenger, so here we get a client-side
            // representation of that from the raw IBinder object.
            mService = new Messenger(service);
            mBound = true;
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            mService = null;
            mBound = false;
        }
    };

    public void sayHello(View v) {
        if (!mBound) return;
        // Create and send a message to the service, using a supported ‘what‘ value
        Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to the service
        bindService(new Intent(this, MessengerService.class), mConnection,
            Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }
}

绑定一个Service（Binding to a Service）

• 实现ServiceConnection接口；
  • 实现onServiceConnected()方法：当client与Service建立绑定时，系统回调该方法，并将onBind()返回的IBinder参数回传至该方法中；
  • 实现onServiceDisconnected()方法：当绑定的Service意外终止时（ unexpectedly lost），系统回调该方法，如Service被进程kill或Service崩溃（crashed）。系统若回调unBindService()方法，将不会回调onServiceDisconnected()方法。

• 调用bindService()，并传入ServiceConnection的实现类对象；

• 当系统回调onServiceConnected()时，表示client与Service已绑定，此时可以访问Service中的public方法。

• 系统回调unbindService()，解除绑定。
  • ！请注意：当client与Service绑定时，系统destroy掉client端，这将破坏绑定状态（destruction causes the client to unbind）。好的做法是只要client与Service交互完成，就解除绑定（to unbind the client as soon as it is done interacting with the service）。

LocalService mService;
private ServiceConnection mConnection = new ServiceConnection() {
    // Called when the connection with the service is established
    public void onServiceConnected(ComponentName className, IBinder service) {
        // Because we have bound to an explicit
        // service that is running in our own process, we can
        // cast its IBinder to a concrete class and directly access it.
        LocalBinder binder = (LocalBinder) service;
        mService = binder.getService();
        mBound = true;
    }

    // Called when the connection with the service disconnects unexpectedly
    public void onServiceDisconnected(ComponentName className) {
        Log.e(TAG, "onServiceDisconnected");
        mBound = false;
    }
};

Intent intent = new Intent(this, LocalService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

需要额外注意的地方（Additional notes）

• 当连接错误时，系统会抛出DeadObjectException异常，这也是在client端调用Service中的方法时可能抛出的唯一异常（This is the only exception thrown by remote methods）。
• binding 和 unbinding应成对出调用。
  • 若当Activity在前台处于运行状态时，需要与绑定的Service交互，那么应在onStart()方法中bindService()，在onStop()中unbindService()。
  • 若当Activity在后台处于stop状态时，那么应在onCreate()方法中bindService()，在onDestroy()中unbindService()。此时系统将更易kill该Service。

管理Bound Service的生命周期（Managing the Lifecycle of a Bound Service）