Bound Services邦定服务

Bound Services邦定服务html

1. In your service, create an instance of Binder that either: 在你的服务里，建立下面之一的Binder实例:
   • contains public methods that the client can call包括一个客户端调用的公共方法
   • returns the current Service instance, which has public methods the client can call返回当前Service实例，它有客户端能够调用的公共方法
   • or, returns an instance of another class hosted by the service with public methods the client can call返回一个service持有的类的实例，它带有一个客户端可调用的公共方法
2. Return this instance of Binder from the onBind() callback method.从onBind()回调方法返回Binder的this实例.
3. In the client, receive the Binder from the onServiceConnected() callback method and make calls to the bound service using the methods provided.在客户端，接收来自onServiceConnected()回调的Binder,而且用它提供的方法产生对service的调用.

publicclassLocalServiceextendsService{

    // Binder given to clients给客户端的Binders

    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.用于客户端的类，由于咱们知道这个服务老是与它的客户端运行在同一个进程中的，因此咱们不须要处理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);
     }
 }

publicclassBindingActivityextendsActivity{

    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) 

      *当一个按钮被点击时，被调用这个按钮在布局文件用经过android:onClick属性加入进来的

*/

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

定义一service binding的回调方法,传递给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咱们已经邦定到LocalService,转换IBinder而且，获取LocalService实例

            LocalBinder binder = (LocalBinder) service;
             mService = binder.getService();
             mBound = true;
         }
 
         @Override
         public void onServiceDisconnected(ComponentName arg0) {
             mBound = false;
         }
     };
 }

• The service implements a Handler that receives a callback for each call from a client.服务实现一个Handler，用于接收来自某个客户端的每一个回调
• The Handler is used to create a Messenger object (which is a reference to the Handler).该Handler经常使用于建立一个Messenger对象(它是Handler的引用)
• The Messenger creates an IBinder that the service returns to clients from onBind().该Messenger建立一个IBinder,服务从onBind().方法返回它给客户端.
• Clients use the IBinder to instantiate the Messenger (that references the service's Handler), which the client uses to send Message objects to the service.客户端用IBinder实例化Messenger(它是服务的Handler引用)，客户端用它来发送Message对象给服务.
• The service receives each Message in its Handler—specifically, in the handleMessage() method.服务在Handler接收它的每一个Message—具体是在handleMessage()方法中.

publicclassMessengerServiceextendsService{

    /** 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

                    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.当邦定到服务，咱们返回一个接口到咱们的messenger.用于发送消息到服务

     */
     @Override
     public IBinder onBind(Intent intent) {
         Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
         return mMessenger.getBinder();
     }
 }

publicclassActivityMessengerextendsActivity{

    /** Messenger for communicating with the service. 与服务通讯的Messenger*/

    Messenger mService = null;
 
     /** Flag indicating whether we have called bind on the service. 标志，表示是否咱们对Service调用bind*/

    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.

            //当与服务创建了联接，给予咱们与服务进行交互的对象时，这个方法被调用，咱们使用一个Messenger与服务通讯,因此这里咱们获得一个来自raw IBinder对象的客户端的reprentation

            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使用支持的’what’值，建立并发送一个消息给服务

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

1. Implement ServiceConnection. 实现服务联接

2. Call bindService(), passing the ServiceConnection implementation. 调用bindService()方法，传递ServiceConnection的实现
3. When the system calls your onServiceConnected() callback method, you can begin making calls to the service, using the methods defined by the interface.当系统调用你的onServiceConnected()回访方法时,你可使用由接口定义的方法，对服务发起一个调用.
4. To disconnect from the service, call unbindService(). 要从服务解除联接，调用unbindService()

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 =newIntent(this,LocalService.class);

bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

• The first parameter of bindService() is an Intent that explicitly names the service to bind (thought the intent could be implicit). bindService()方法的第一个参数,是一个Intent，它是邦定到服务的显式名字(但这个意图也能够是隐式的)
• The second parameter is the ServiceConnection object.第二个参数是ServiceConnection对象.
• The third parameter is a flag indicating options for the binding. It should usually be BIND_AUTO_CREATE in order to create the service if its not already alive. Other possible values are BIND_DEBUG_UNBIND and BIND_NOT_FOREGROUND, or 0 for none.第三个参数是邦定标记选项，BIND_AUTO_CREATE它一般指示若是它的服务不存活时，能够建立服务.其它能够的值是BIND_DEBUG_UNBIND和BIND_NOT_FOREGROUND,或0没有参数.

• You should always trap DeadObjectException exceptions, which are thrown when the connection has broken. This is the only exception thrown by remote methods.你应该老是处理（trap）DeadObjectException异常.当联接崩溃时，惟一由远程方法抛出的异常
• Objects are reference counted across processes. 跨进程的对象引用计数
• You should usually pair the binding and unbinding during matching bring-up and tear-down moments of the client's lifecycle. For example: 你一般应将邦定和解除邦定，成对的出如今客户端生命周期相对应的时刻。好比:
  • If you only need to interact with the service while your activity is visible, you should bind during onStart() and unbind during onStop().若是只有当你的活动可见时才须要与服务交互，那么你应该在方法中邦定，在方法中解除邦定
  • If you want your activity to receive responses even while it is stopped in the background, then you can bind during onCreate() and unbind during onDestroy(). Beware that this implies that your activity needs to use the service the entire time it's running (even in the background), so if the service is in another process, then you increase the weight of the process and it becomes more likely that the system will kill it.若是你但愿你的活动，即便中止在后台，也能接收响应，那么你能够在方法中邦定，在方法中销毁。注意，这意味着，在你的活动的整个运行时间都要使用服务(即便是活动在后台)，因此若是服务在其余的进程中，那么你可能增长你服务的比重(weight),而且它可能变得极有可能被杀掉.