Andorid总结 - Bound Services

创建一个Bound Service

想要创建一个提供binding的service，必须提供一个IBinder给client与service进行交互。有三种方式可以定义接口：

继承Binder类

如果service只给自己的应用使用并且不会做跨进程的操作，我们可以继承Binder类并且通过onBind()返回一个它的实例。client接收到这个Binder可以直接使用它开调用service提供的方法。

使用步骤：

创建一个Binder实例，任意实现一种:

在Binder类中包含client可以访问的public方法。

返回一个当前Service的实例，client可以通过这个实例调用Service的public方法。

返回一个封装了service public方法的类对象，client可以调用。

通过onBind()回调函数返回Binder实例。

在client端，通过onServiceConnected()的回调函数接收Binder 对象，通过Binder对象来调用公开的方法。

例子，通过onBinder返回Service对象：

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

使用Messenger

如果service需要与别的进程进行交互，那么可以使用Messenger提供的接口来实现service。这个技术不需要使用AIDL就能实现IPC。

Messenger的使用方法：

service需要实现一个Handler来接收client调用时传递过来的callback。

通过Handler来创建一个 Messenger对象。

这个Messenger 对象创建一个IBinder，提供给onBind()返回给client。

Clients 使用 IBinder来初始化这个Messenger (that references the service’s Handler), client可以使用这个Messenger 来给service发送Message对象。

Service中实现的Handler会接收并处理接收到的Message。

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

一个调用Messenger实现的Service的客服端实例：

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

Using AIDL

Binding to a Service

想要绑定Service，Client需要实现：

实现ServiceConnection接口，必须实现两个方法。

onServiceConnected()，系统会调用这个函数用于返回IBinder。

onServiceDisconnected()，当连接异常断掉之后，系统会调用这个函数。unbind的时候不会调用。

调用bindSercie，把ServiceConnection 作为参数传递过去。

当系统调用onServiceConnected() 之后，就可以 通过获取到的IBinder来调用service公开的方法。

调用unbindService()来断开连接。

实现ServiceConnection的实例：

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

调用bindService()：

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

bindService的第三个参数指示binding时的选项。通常应该设置为BIND_AUTO_CREATE 。还可以为BIND_DEBUG_UNBIND 和BIND_NOT_FOREGROUND, 或者设为0代表什么都不选.

Additional notes

binding to a service的时候有几个注意事项：

应该总是捕捉DeadObjectException 异常, 这种异常会在链接被破坏掉的时候抛出来。 这是远程方法会抛出的唯一的一种异常。

跨进程处理的时候，Object的引用会被计数。

需要在client的生命周期中成对的使用binding和unbinging。例如:

如果只需要在Activity可见的时候使用service，应该在onStart的时候bind servcie，在onStop的时候unbind srvice。

如果想Activity在后台的时候也与service交互，那么在onCreate的时候bind service，在onDestroy的时候unbind service。

管理Bound Service的生命周期