标签： 技术

绑定到一个Service

应用组件 (客户端)可以调用bindService()绑定到一个service．

Android系统之后调用service的onBind()方法，它返回一个用来与service交互的IBinder,绑定是异步的．

bindService()会立即返回，它不会返回IBinder给客户端．

要接收IBinder，客户端必须创建一个ServiceConnection的实例并传给bindService()．

ServiceConnection包含一个回调方法，系统调用这个方法来传递要返回的IBinder．

注：只有activities,services,和contentproviders可以绑定到一个service,你不能从一个broadcastreceiver绑定到service．

所以，从你的客户端绑定到一个service，你必须：

１.实现ServiceConnection

你的实现必须重写两个回调方法：

onServiceConnected()

系统调用这个来传送在service的onBind()中返回的IBinder．

OnServiceDisconnected()

Android系统在同service的连接意外丢失时调用这个．比如当service崩溃了或被强杀了．当客户端解除绑定时，这个方法不会被调用．

２.调用bindService()，传给它ServiceConnection的实现

３.当系统调用你的onServiceConnected()方法时，你就可以使用接口定义的方法们开始调用service了

４.要与service断开连接，调用unbindService()

当你的客户端被销毁，它将从service解除绑定，但是你必须总是在你完成与service的交互时或当你的activity暂停或是service在不被使用时可以关闭此两种情况下解除绑定． (下面会讨论更多在适当的时候绑定和解除绑定的问题．)

下面是＂派生Binder类＂中创建的代码片段，它把客户端连接到了service．

所需要做的就是把返回的IBinder强制转换(向下转型)到LocalBinder类并且请求LocalService实例：

private ServiceConnection mConnection = new ServiceConnection() {
    // 当与service的连接建立后(bindService)被调用  
    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;
    }
    // 当与service的连接意外断开时被调用  
    public void onServiceDisconnected(ComponentName className) {
        Log.e(TAG, "onServiceDisconnected");
        mBound = false;
    }
};

使用这个ServiceConnection，客户端可以绑定到一个service，通过把它传给bindService()．例如：

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

第一个bindService()的参数是一个明确指定了要绑定的service的Intent．

第二个参数是ServiceConnection对象．

第三个参数是一个标志，它表明绑定中的操作．它一般应是BIND_AUTO_CREATE，这样就会在service不存在时创建一个．其它可选的值是BIND_DEBUG_UNBIND和BIND_NOT_FOREGROUND,

不想指定时设为0即可．

补充事项下面是一些关于绑定到service的重要事项：

你总是需要捕获DeadObjectException异常．它会在连接被打断时抛出．这是被远程方法抛出的唯一异常．

对象引用计数是跨进程的作用的．

你应该在客户端的生命期内使绑定和解除绑定配对进行，例如：

如果你需要在你的activity可见时与service交互，你应该在onStart()绑定并在onStop()中解除绑定．

如果你想让你的activity即使在它停止时也能接收回应，那么你可以在onCreate()中绑定并在onDestroy()中解除绑定．

注意这意味着你的activity需要使用在自己整个运行期间使用service(即使位于后台)，所以如果service在另一个进程中，那么你增加了这个进程的负担而使它变得更容易被系统杀掉．

注：你一般不应该在你的activity的onResume()和onPause()中绑定和解除绑定到service，因为这些回调方法,出现在每个生命期变化中，并且你需要使发生在这些变化中的处理最小化．还有，如果你应用中的多个activity绑定到同一个service，并且有一个变化发生在其中两个activity之间，service可能在当前activity解除绑定 (pause中)和下一个绑定前 (rusume中)被销毁又重建．

管理BoundService的生命期　　当一个service的所有客户端都解除绑定，Android系统就销毁它 (除非它是从onStartCommand()启动)．如果你的service是一个纯boundservice，你不需管理它的生命期—Android系统会为你管理它．

然而，如果你选择了实现onStartCommand()回调方法，那么你必须明确地停止service，因为service现在被认为是＂开始的＂．在此情况下，service会一直运行，直到service使用stopSelf()停止它自己或另外的组件调用了stopService()停止了它，不管是否有客户端绑定了它．

另外，如果你的service已经启动并且接受绑定，那么当系统调用你的onUnbind()方法，你可以选择返回true表示你想在客户端下一次绑定到service时接受一个对onRebind()的调用 (而不是一个对onBind()的调用)．onRebind()返回void，但是客户端依然会在它的onServiceConnected()回调中接收到IBinder．下图演示了这种生命其的逻辑：

图１.一个已开始并已绑定的service的生命期

1.Context.startService()方式启动

Context.startService()方式的生命周期：

启动时，startService–>onCreate()–>onStart()

停止时，stopService– > onDestroy()

如果调用者直接退出而没有停止Service，

则Service会一直在后台运行Context.startService()方法启动服务。

在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。

如果调用startService()方法前服务已经被创建，

多次调用startService()方法并不会导致多次创建服务，

但会导致多次调用onStart()方法。

采用startService()方法启动的服务，

只能调用Context.stopService()方法结束服务，

服务结束时会调用onDestroy()方法。

2.Context.bindService()方式启动

Context.bindService()方式的生命周期：绑定时,

bindService->onCreate()–>onBind()调用者退出了，即解绑定时,

Srevice就会unbindService–>onUnbind()–>onDestory() 

Context.bindService()方式启动Service的方法：

绑定Service需要三个参数：bindService(intent, conn, Service.BIND_AUTO_CREATE);

第一个：Intent对象

第二个：ServiceConnection对象，创建该对象要实现它的onServiceConnected()和onServiceDisconnected()来判断连接成功或者是断开连接

第三个：如何创建Service，一般指定绑定的时候自动创建附代码

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import com.dada.test.BindService.MyBinder;
public class TestActivity extends Activity {
    private boolean flag;
    private static final String TAG = "TestActivity";
    /** Called when the activity is first created. */
    @Override public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Button btnStart = (Button) findViewById(R.id.btnStart);
        Button btnStop = (Button) findViewById(R.id.btnStop);
        btnStart.setOnClickListener(new View.OnClickListener() {@Override public void onClick(View v) {
                //启动service 方式2  
                bindService();
            }
        });
        btnStop.setOnClickListener(new View.OnClickListener() {
            @Override public void onClick(View v) {
                //停止service 方式2  
                unBindService();
            }
        });
    }
    //启动service 方式2  
    //  
    private void bindService() {
        Intent intent = new Intent(TestActivity.this, BindService.class);
        Log.i(TAG, "bindService()");
        bindService(intent, conn, Context.BIND_AUTO_CREATE);
    }
    private void unBindService() {
        Log.i(TAG, "unBindService() start....");
        if (flag == true) {
            Log.i(TAG, "unBindService() flag");
            unbindService(conn);
            flag = false;
        }
    }
    private ServiceConnection conn = new ServiceConnection() {
        @Override public void onServiceDisconnected(ComponentName name) {
            // TODO Auto-generated method stub  
            Log.i(TAG, "onServiceDisconnected()");
        }
        @Override public void onServiceConnected(ComponentName name, IBinder service) {
            // TODO Auto-generated method stub  
            Log.i(TAG, "onServiceConnected()");
            MyBinder binder = (MyBinder) service;
            BindService bindService = binder.getService1();
            bindService.MyMethod();
            flag = true;
        }
    };
}

service:

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;
public class BindService extends Service {
    private static final String TAG = "BindService";
    private MyBinder myBinder = new MyBinder();
    public void MyMethod() {
        Log.i(TAG, "BindService-->MyMethod()");
    }
    
    @Override public IBinder onBind(Intent intent) {
        Log.i(TAG, "BindService-->onBind()");
        return myBinder;
    }
    
    public class MyBinder extends Binder {
        public BindService getService1() {
            return BindService.this;
        }
    }
    
    @Override public void onCreate() {
        Log.i(TAG, "BindService-->onCreate()");
        super.onCreate();
    }
    @Override public void onStart(Intent intent, int startId) {
        Log.i(TAG, "BindService-->onStart()");
        super.onStart(intent, startId);
    }
    @Override public void onDestroy() {
        Log.i(TAG, "BindService-->onDestroy()");
        super.onDestroy();
    }
    @Override public boolean onUnbind(Intent intent) {
        Log.i(TAG, "BindService-->onUnbind()");
        return super.onUnbind(intent);
    }
}

运行日志点击启动

点击停止

没有打出onServiceDisconnected的日志的原因：

注：SDK上是这么说的：This is called when the connection with the service has been unexpectedly disconnected–that is,

its process crashed.Because it is running in our same process,

we should never see this happen.

所以说，只有在service因异常而断开连接的时候，这个方法才会用到

其他

由于Service的onStart()方法只有在startService()启动Service的情况下才调用，故使用onStart()的时候要注意这点。

与Service通信并且让它持续运行如果我们想保持和Service的通信，又不想让Service随着Activity退出而退出呢？

你可以先startService()然后再bindService()。

当你不需要绑定的时候就执行unbindService()方法，执行这个方法只会触发Service的onUnbind()而不会把这个Service销毁。

这样就可以既保持和Service的通信，也不会随着Activity销毁而销毁了。