创建一个BoundService——翻译总结自developer.android.com

简述

继承Binder类

在onBind中创建一个继承Binder类，并返回。这样接到这个Binder的终端就可以直接使用它来访问Binder或者Service当中的共有方法。

当你的Service在幕后工作，并且仅仅被你自己的应用程序使用的时候，我们就推荐你使用这样的方法。如果你要使用你的服务可以被其他的应用程序访问或跨进程通信，你才需要用其他的方法。

使用Messenger

跨进程用这种方法。这种方式里面Service会定义一个Handler来处理不同类型的Message对象。Handler是Messager得以和client分享IBinder的基础，使得客户端可以使用Message对象向Service发送请求。客户端可以以自己定义一个Messenger，service也可以回送消息。

这是使用跨进程方式通信的最简单的办法，因为Messenger将所有的请求排队到一个单一的线程，不用费心去设计自己的service线程安全。

使用AIDL

Android接口定义语言，做了所有把对象分解为一个个操作系统能够识别的基础元素，并且可以使得他们跨进程。上一个Mesenger的技术，其实是使用AIDL来作为其基础的结构的。如之前提到的，Messenger创建一个所有客户端请求的队列，所以service可以一次接受一个请求。然而如果你想要service同时接收多个请求，那么你可以直接使用AIDL。在时你的Service要能够负载多线程并且线程安全。

想要直接使用AIDL，你必须创建一个 .ail文件，其中定义了编程的接口。Android sdk使用这个文件来生成一个抽象类，其中构建了结构并且处理IPC，在你的Service中拓展它。

提示：

大多数的app不应该使用AIDL来创建一个service，因为这需要多线程的负载能力，并且它的构建也更加复杂。所以，AIDL不适合于大多数的应用，并且在这里没有论述在你的service中怎样使用。如果你确定你想直接使用AIDL，查看AIDL的文档吧。

拓展Binder类

提示：比如一个音乐播放器需要将Activity和一个后台的Service进行绑定，就很适合使用这样的方法。

下面是开始的方法：

1.在你的Service中创建一个Binder的实例，至少包括以下一项：

- 客户端可以调用的公共方法。

- 返回当前service的实例，其中包含客户端可以调用的公有方法。

- 或者返回一个包含客户端可以调用的公有方法的service的内部类。

2.从onBind回调函数中返回Binder实例。

3.在客户端，从onServiceConnected回调方法中接收Binder对象，并且调用其中的方法来和service通信。

提示：之所以要在一个应用程序里面的原因，是这样的话客户端才可以获取到返回的对象并且调用API。Servie和客户端必须在相同的进程当中，因为这个技术不可以进程。

取个例子，下面是一个通过构建一个Binder使得客户端可以和servise通信的例子。

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);
    }
}

在LocalBinder中定义了一个getService方法，可以让客户端检索到LocalServce的实例。这使得客户端可以调用service中的公有方法。例如，客户端可以调用来自service的getRandomNumber方法。

下面是一个binds了LocalService的Activity，当按钮按下时候调用getRandomNumber。

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;
        }
    };
}

上面这个例子展示了客户端是怎样使用一个ServiceConnection的构造和回调onServiceConnected来绑定service的。下一个部分我们将介绍更多绑定service 的方法。

提示：在上面的例子里面，onStop方法将client从service上面解绑。客户端应该在合适的时机从service上面解绑，入宫在Additional Notes中讨论的那样。

更多的示例代码可以查看LocalSercie.java和LocalServiceAcitivities.java，在ApiDemos中。

使用一个Messenger

如果需要你的service跟远程的进程通信，那么你可以使用一个Messenger来提供你的service的接口。这个技术让你不使用AIDL就可以进行IPC。

下面是怎样使用Messenger的一个总结：

- 在service中构建一个Handler，其可以从客户端接受每一个调用的回调。

- Handler被用来创建一个Message对象（其实是一个Handler的引用）

- Messenger创建一个IBinder，也就是在onBind中service返回给客户端的那个。

- 客户端使用IBinder来初始化Messenger（它引用了服务的Handler），客户端使用这个Messsenger来给service发送Message对象。

- service在它的Handler中接收每一个Message。具体而言实在handleMessge方法中。

用这种方法，就没有了客户端能够调用的service的方法了。取而代之的是，客户端发送messages，也即是Message对象，service它的Handler中接收。

下面是使用Messenger接口的一个简单的service示例。

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();
    }
}

注意到这个例子中并没有膳食出srevice是如何应答客户端的，如果你要service去应答，那么你需要在客户端里面创建一个Messenger。那么当客户单接收到onServiceConnected的回调的时候，他就会想service发送Message，其中在send函数的reply参数中包含客户端的Messenger。

你可以在例子中看见怎样提供一种双工通信，在MessengerService.java（Service）和MessengerServiceActivities.java（client）的例子中。

绑定一个Service

应用组件（客户端）可以通过调用bindeService来绑定service。Android 系统随后调用service的onBinde方法，它返回一个用来和service交互的IBinder。绑定是异步的过程。bindService即时返回，并且不向客户端返回IBinder。为了接受IBinder，客户端必须创建一个ServiceConnection实例，并且把它传入给bindService。ServiceConnection中包含一个回调方法，系统调用它来传送IBinder。

提示：只有activity，service和content providers可以绑定一个service，你不能让一个broadcast receiver来绑定service。

所以，从你的客户端去绑定service，你必须做：

1.构建ServiceConnection

你的构建必须重写两个回调函数：

onServiceConnected（）

系统通过调用它来传递service的onBind返回的IBinder。

onServiceDisconnected（）

Android系统在和service 的连接以外地中断时候调用该函数。比如说当service崩溃了或者被杀掉了。当客户端解绑的时候，这个方法不会被调用。

2.调用bindService，将构建的ServiceConnection传入。

3.当系统调用你的onServieConnected的回调方法的时候，你可以开始和service通信 ，使用你在接口中定义的方法。

4.要断开和service的连接，就调用unbindeService（）。

如果你的客户端在你的应用销毁客户端的时候仍然和service连接，那么销毁会使客户端解绑。在客户端完成和service的交互的时候解绑，这样做更好。

例如，下面的代码片展示了从客户单到service的连接，servise使用上面的extending the Binder 类的方法构建，所以所有他要做的事情就是获取返回的IBinder并传递到LocalService类中，并且请求LocalService实例。

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;
    }
};

有了ServiceConnetion，客户端可以通过传递以这个对象给bindService方法来绑定一个service。例如：

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

- bindService的第一个参数是一个Intent，显式地说明了要绑定的service的名字。（尽管intent也可以是隐式）

- 第二个参数是ServiceConnection的对象。

- 第三个参数是一个标志位，它指示了绑定的选项。一般为BIND_AUTO_CREATE，用来创建一个service，如果这个service还没有创建。

- 其他的可能值为BIND_DEBUG_UNBIND和BIND_NOT_FOREGROUND，或者是0表示什么也不做。

附加提示

下面是一些关于绑定服务的重点：

- 你应该一直注意捕捉DeadObjectException的异常，当connection断开的时候就可能捕获。这是远程方法唯一可能抛出的异常。

- 对象是被认为是跨进程的引用。

- bind和unbind应该成双成对，当你在客户端的声明周期里面建立匹配和断开匹配的时候。举个例子：

 * 如果你只在你的activity可见的时候和service通信，你应该在onStart方法中bind，在onStop中unbind。

* 如果你想要你的activity在他stop在后台的时候，仍然接收回应，那么你可以在onCreate方法中bind，在onDestroy方法中unbind。你要意识到，这意味着你的activity需要在他运行的时候一直都使用service，包括在background的时候，所以如果service在其他的进程中，那么你增大了这个进程的负担，它很有可能被系统回收掉。

提示：请不要在onResume和onPause中来bind和unbind，因为这些调用在每一个生命周期转换的时候都会发生，而你应该把发生在转换过程中发生的进程数量控制到最小。并且如果你的应用中的多个activity都bind了同一个service，并且其中的两个activity之间发生跳转，那么当当前的（在pause的时候）activity解绑和下一个绑定（在resume时候）之间，服务将会被销毁并且重新创建。（Activity之间的转化过程如何协调，可以参见Activity文档）。

更多关于如何bind service的示例代码，请查看ApiDemos里面的RemoteService。

管理一个绑定的Service的生命周期

当一个service从所有的客户端解绑的时候，Android系统会销毁它（ 除非他使用了onStartCommand启动的）。这样的话，你不需要管理你的service的生命周期，如果它只是单纯的一个绑定的service，android系统会帮你管理它，基于是够有客户端跟他绑定。

但是，如果你选择构建一个onStartCommand的回调方法，那么你必须显式地停止你的service，因为这个service现在被当做started（已启动）。在这种情况下，这个service会一直运行，除非他自己停止，比如说用stopSelf方法，或者另一个组件调用了stopService方法，无论其是否和客户端绑定。

除此之外，如果你的service启动了并且接受了bind，当系统调用了你的onUnbind方法时候，你可以选择返回true，如果你想在下次有客户端绑定service的时候被调用onRebind方法。onRebind返回一个空，但是客户单仍然在他的onSericeConnected回调方法中接收到IBinder。下面的图1表示了这种生命周期的逻辑。

关于service生命周期的更多信息，请看Service文档。