Android 开发指南（二） 服务绑定 Bound Service

一个绑定服务是客户端与服务端之间的一个接口。一个绑定服务允许组件和其进行绑定，并通过这个绑定服务，可以接受请求，发送请求，甚至完成进程间的通信。绑定服务的生命周期以来其绑定的客户端，并非无限期的运行下去。

基本原理

一个绑定服务，就是一个实现了类Service，并允许其它应用程序与其绑定及与之交互的的组件。提供一个绑定服务，你必须实现onBind()方法，这个方法返回一个IBinder对象，这个对象就是定义用来客户端与服务交互的接口。

客户端通过bindService()方法绑定服务。另外，客户端还必须提供一个ServiceConnection的实现对象，用以监控与服务Service间的连接情况。bindService()无返回值，但系统在客户端与服务端连接之间，会调用在ServiceConnect对象中的onServiceConnected()方法，并传递一个客户端与服务端可以交互的IBinder接口。

多个客户端同时连接Service时，系统只在第一个客户端连接时调用你的onBind()方法并返回一个IBinder对象，系统在其他客户端进行连接时返回相同的IBinder对象，而不再去调用onBind().

当最后一个客户端调用与服务解除绑定时,系统将销毁服务,除非这个服务启动时,也调用了startService()方法.

 

如何创建绑定服务

有3种方式进行服务绑定:

1、  继承Binder类

如果你的服务只针对你自己的应用程序，且与客户端处于同一个进程当中，那么可以使用继承这种方式。此时，你应该创建一个继续与Binder接口的类，并实现其onBind()，然后返回一个你创建的服务的实例。然后客户端就可以接收到Binder，并可以使用这个Binder访问Binder的public方法及Service的public方法。

2、  使用信使者Messenger

如果你的Service要求跨越不同的进程，那么你需要为你的Service创建一个Messenger成员，同时定义一个可以响应不同类型消息Messge对象Handler对象。

Hander对象是为Messenger对象提供基础的，这样Hander就可以共享一个IBinder对象给客户端了，并允许客户端使用Message对象给服务发送命令。此外，客户端也可以定义一个自己的Messenger，这样客户端就可以将消息发送到服务端了。

3、  使用AIDL

比较复杂的一种，在Messenger基础上支持多线程并发处理。以后在讨论。

继承Binder

1、  在你的服务类中，创建一个满足以下3点中1点的Binder实例：

l  包含一个public方法，以便客户端可以调用

l  在一个public方法中返回当前服务实例给客户端使用

l  在公共方法中返回继承于Service类的其他Service实例

2、  在onBind()方法中，返回Binder对象实例

3、  在客户端，从onServiceConnected()回调方法接收Binder对象，并调用绑定服务中提供的方法。

服务类的写法：
  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

1、  实现一个用以接收客户端回调的Handler对象；

2、  Handler做为Messenger对象创建的参数；

3、  Messenger从onBind()方法创建一个IBinder对象与客户端交互；

4、  客户端使用IBinder对象实例化Messenger对象，通过Messenger对象，向服务发送消息；

5、  服务在Handler中接收客户端发送过来的消息，并处理之；

服务端：

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;

        }

    }

}