在上一篇博客深入理解Service（一）——服务生命周期中了解了Service会有启动和绑定两种状态，对应着这两种状态会有不同的生命周期：开启服务与停止服务的方式均有所不同。这篇博客主要介绍绑定服务相关的内容，以及如果服务与调用者，比如Activity处于不同进程时该如何操作，即通常意义上所说的IPC。
绑定服务的实现
什么时候需要使用绑定服务呢？我的理解是调用者在启动完服务后，还需要以后与服务打交道，还要控制服务，而不是像启动服务一样任服务自由自在不受控制。常见的一个场景，Service播放音乐，界面上有上一曲，下一曲、暂停、播放等按钮，通过这些按钮还可以控制Service操作，这种情景就是使用的绑定，本篇博客的例子也将实现一个简单的demo。
1.定义服务
绑定服务，需要重写onBind()方法，并且返回一个IBinder对象，该IBinder客户端再绑定服务成功后可以获取一个该对象，因此客户端可以通过IBinder来控制服务。IBinder是一个接口，一般我们不会直接实现该接口，而是会继承Binder类，Binder类实现了IBinder类。
下面是该播放服务的示例：
**
* 播放音乐服务
*/
public class PlayMusicService extends Service {
public PlayMusicService() {
}
public class PlayMusicBinder extends Binder {
/**
* 播放音乐
*/
public void play() {
playMusic();
}
/**
* 暂停播放
*/
public void pause() {
pauseMusic();
}
/**
* 暂停播放
*/
public void stop() {
stopMusic();
}
}
private PlayMusicBinder mBinder = new PlayMusicBinder();
private MediaPlayer mediaPlayer;
@Override
public void onCreate() {
super.onCreate();
mediaPlayer = MediaPlayer.create(this, R.raw.diamonds);
}
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public void onDestroy() {
super.onDestroy();
if (mediaPlayer != null)
mediaPlayer.release();
}
private void playMusic() {
mediaPlayer.start();
}
private void pauseMusic() {
mediaPlayer.pause();
}
private void stopMusic() {
mediaPlayer.stop();
}
}其中PlayMusicBinder继承自Binder类，并且提供了三个接口，分别是播放音乐、暂停音乐以及停止播放；在onBind()方法中返回这样一个实例。播放音乐用到了MediaPlayer，音乐文件直接直接放在了res/raw/目录下。至此，服务端就完成了，主要工具就是编写一个Binder类提供给客户端操作的接口。
从上面可以看到，定义服务端主要包括两步：
1. 扩展Binder类，实现接口
2. 在onBind()方法返回一个IBinder实例
2.定义调用者（Activity）
在定义完服务端后，再来定义客户端，bindService方法中第二个参数是一个ServiceConnection接口，当服务连接成功以及失去连接时会分别回调两个方法。下面是Activity的定义：
public class PlayMusicActivity extends AppCompatActivity {
private PlayMusicService.PlayMusicBinder musicBinder;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//在服务连接成功后保存PlayeMusicBinder对象，控制服务端
musicBinder = (PlayMusicService.PlayMusicBinder) service;
}
@Override
public void onServiceDisconnected(ComponentName name) {
musicBinder = null;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_play_music);
}
@Override
protected void onStart() {
super.onStart();
bindService(new Intent(this, PlayMusicService.class), connection, Service.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(connection);
}
public void playMusic(View view) {
if (musicBinder != null)
musicBinder.play();
}
public void pauseMusic(View view) {
if (musicBinder != null)
musicBinder.pause();
}
public void stopMusic(View view) {
if (musicBinder != null)
musicBinder.stop();
}
}从上面的代码可以看出，在onStart中绑定服务，一旦服务绑定成功，则保存PlayMusicBinder对象。界面上有三个按钮，分别是播放、暂停和停止，接下来就可以控制后台服务播放音乐了。
从上面可以看到，定义客户端主要有三步：
1. 定义ServiceConnection对象，在onServiceConnect回调中保存IBinder对象
2. 绑定服务
3. 使用onServiceConnect回调中保存的IBinder对象操作Service
在服务中扩展Binder这种方式适用于服务端和客户端在同一个进程中，那么如果客户端和服务端在不同进程中，那么该如何实现了？也就是通常意义上的IPC，IPC的方式有很多，比如管道、共享内存、Socket等等，但是在Android中有一种特殊的机制：Binder机制。下面首先介绍Binder机制的两种表现形式，Messenger和定义AIDL接口。下面分别就这两种方法就行介绍。
Messenger
Messenger对Binder进行了封装，适用于服务端单线程的情况，因为服务端会定义一个Handler用于顺序处理客户端发送过来的Message，在服务的onBind中返回内部的Binder。
Messenger用于发送消息，Handler用于处理消息，一般我们使用服务端作为处理消息，所以服务端需要Messenger和Handler，并且在onBind方法中返回Messenger内部的Binder，这样客户端就可以根据绑定服务后得到Messenger，可看做是服务端的Messenger，然后就可以通过它来发送消息了；那么如果服务端会在处理完客户端的消息后回复客户端，并且客户端也需要处理这个消息，那么该如何实现呢？
根据上面的分析，既然服务端需要回复客户端，也就得拿到客户端的Messenger，然后客户端需要处理消息，也需要一个Handler，所以说客户端也需要一个Messenger和一个Handler。下面我们以一个例子来详细说明，客户端向服务端发送两个整形数，服务端将和返回给客户端。
1.服务端的定义
/**
* 使用Messenger，适合应用与服务在不同进程中
*/
public class MessengerService extends Service {
//Handler用于处理客户端发送来的消息，不存在线程安全问题
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 0:
int a = msg.arg1;
int b = msg.arg2;
int sum = a + b;
//得到客户端的Messenger，回复消息
Messenger replyTo = msg.replyTo;
Message message = Message.obtain();
message.what = 1;
message.arg1 = sum;
try {
replyTo.send(message);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
}
}
};
private Messenger messenger = new Messenger(mHandler);
public MessengerService() {
}
@Override
public IBinder onBind(Intent intent) {
//返回Messenger内部的Binder
return messenger.getBinder();
}
}从上面的代码可以看到，服务端主要包括三步：
1. 定义Handler用于处理消息
2. 根据Handler声明Messenger对象
3. 在onBind方法中返回Messenger的Binder
如何将一个服务开启在另一个进程呢？
这个只需要在清单文件中注册服务时，添加一个process属性即可，如下：
<service
android:name=".MessengerService"
android:enabled="true"
android:exported="true"
android:process=":remote" />process属性可以为服务指定任意进程，remote前面的“：”的含义是使完整的进程名使用包名+remote。
2.客户端的定义
在定义完服务端之后，我们再来看下客户端的定义，客户端主要完成绑定服务，发送数据以及接受数据的功能。如下：
public class MainActivity extends AppCompatActivity {
private TextView resultShowTv;
private Messenger messenger;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//得到服务端的Messenger，发送消息
messenger = new Messenger(service);
Message msg = Message.obtain(handler, 0, 5, 10);
msg.replyTo = replyTo;//将客户端的Messenger对象赋给replyTo字段
try {
messenger.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
resultShowTv = (TextView) findViewById(R.id.result_show_tv);
}
//客户端中接受消息的Messenger
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
int sum = msg.arg1;
resultShowTv.setText(String.valueOf(sum));
break;
}
}
};
private Messenger replyTo = new Messenger(handler);
public void messenger(View view) {
Intent bindService = new Intent(this, MessengerService.class);
bindService(bindService, connection, BIND_AUTO_CREATE);
}
}从上面的代码可以看到，客户端主要有三步：
1. 编写ServiceConnection类，在onServiceConnect回调中得到服务端的Messenger，一旦得到了该对象，就发送Message对象，并且将客户端这边的Messenger带了过去
2. 编写客户端处理消息的Handler以及Messenger
3. 绑定服务
下图是效果：
并且可以在Android Studio上看到两个进程名，如下：
从上图可以看到，一个进程名为com.xks.binderdemo,一个进程名为com.xks.binderdemo.remote，这就是清单文件中“：”的效果。
使用AIDL
AIDL是Android Interface Define Language（Android接口定义语言）的简称。所谓接口定义，就是在通信双方定义一个规则，你可以这样发数据，我就可以接受数据。
使用AIDL时有如下三步：
1. 定义.aidl文件
在.aidl文件中编写接口
2. 实现接口
Android SDK工具会根据.aidl文件生成一个Java类，而开发者需要做的是继承其内部的一个Stub抽象类并实现.aidl中的接口
3. 向客户端公开接口
在onBind方法中返回Binder
1.定义.aidl文件
.aidl文件语法类似于Java，只能位于src/目录下，每个.aidl文件都必须定义单个接口，并且只需包含接口声明和方法签名。
默认情况下，AIDL支持以下类型：
- Java的基本类型，如int、float、double、boolean等
- String类型和Charsequence
- List
List包含元素的类型必须是AIDL支持的，并且另一端实际接收到的ArrayList类型，但生成的方法使用的是List接口
- Map
Map中的所有元素的类型必须是AIDL支持的，另一端实际接收到的是HashMap类型，但生成的方法使用的Map接口
- Parcelable类型
另外，如果需要使用非以上类型，都必须使用import语句，即使这些类型与AIDL位于同一个包中。
定义服务接口时，请注意：
- 方法可带零个或多个参数，返回值或空值
- 所有非基本类型的参数都㤇指示数据走向的方向标记。可以是in、out或inout。基本类型默认为in，不能是其他方向
注意：应该将方向限定为真正需要的方向
- .aidl文件中包括的所有代码注释都包含在生成的IBinder接口中(import和package语句之前的注释除外)
- 只支持方法；不能公开AIDL中的静态字段。
下面为了演示例子，首先定义一个Book类，主要有两个字段，isbn和name，实现了Parcelable接口，如下：
public class Book implements Parcelable {
private int isbn;
private String name;
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(this.isbn);
dest.writeString(this.name);
}
public Book() {
}
protected Book(Parcel in) {
this.isbn = in.readInt();
this.name = in.readString();
}
public static final Creator<Book> CREATOR = new Creator<Book>() {
@Override
public Book createFromParcel(Parcel source) {
return new Book(source);
}
@Override
public Book[] newArray(int size) {
return new Book[size];
}
};
@Override
public String toString() {
return "Book{" +
"isbn=" + isbn +
", name='" + name + '\'' +
'}';
}
}实现Parcelable接口的类需要在其内部提供一个CREATOR的常量，然后在src/目录下定义Book的aidl文件，如下：
// Book.aidl
package com.xks.binderdemo;
parcelable Book;接下来，定义BookManager.aidl文件，如下：
// IMyAidlInterface.aidl
package com.xks.binderdemo;
// Declare any non-default types here with import statements
import com.xks.binderdemo.Book;
interface BookManager {
/**
* 打印书籍
*/
String printBook(in Book book);
/**
* 添加书籍
*/
void addBook(in Book book);
/**
*得到书籍数量
*/
int getBookSize();
/**
* 根据索引取书
*/
Book get(int index);
}
主要有四个接口，分别是打印书籍，添加书籍，得到书籍数量以及根据索引取书，在编写完.aidl文件后，同步一下，可以得到一个BookManager的接口，如下：
/*
* This file is auto-generated. DO NOT MODIFY.
* Original file: E:\\Workspace\\Android\\BlogDemo\\servicedemo\\src\\main\\aidl\\com\\xks\\binderdemo\\BookManager.aidl
*/
package com.xks.binderdemo;
public interface BookManager extends android.os.IInterface {
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.xks.binderdemo.BookManager {
private static final java.lang.String DESCRIPTOR = "com.xks.binderdemo.BookManager";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.xks.binderdemo.BookManager interface,
* generating a proxy if needed.
*/
public static com.xks.binderdemo.BookManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.xks.binderdemo.BookManager))) {
return ((com.xks.binderdemo.BookManager) iin);
}
return new com.xks.binderdemo.BookManager.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_printBook: {
data.enforceInterface(DESCRIPTOR);
com.xks.binderdemo.Book _arg0;
if ((0 != data.readInt())) {
_arg0 = com.xks.binderdemo.Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
java.lang.String _result = this.printBook(_arg0);
reply.writeNoException();
reply.writeString(_result);
return true;
}
case TRANSACTION_addBook: {
data.enforceInterface(DESCRIPTOR);
com.xks.binderdemo.Book _arg0;
if ((0 != data.readInt())) {
_arg0 = com.xks.binderdemo.Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_getBookSize: {
data.enforceInterface(DESCRIPTOR);
int _result = this.getBookSize();
reply.writeNoException();
reply.writeInt(_result);
return true;
}
case TRANSACTION_get: {
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
com.xks.binderdemo.Book _result = this.get(_arg0);
reply.writeNoException();
if ((_result != null)) {
reply.writeInt(1);
_result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.xks.binderdemo.BookManager {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* 打印书籍
*/
@Override
public java.lang.String printBook(com.xks.binderdemo.Book book) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.lang.String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((book != null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_printBook, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* 添加书籍
*/
@Override
public void addBook(com.xks.binderdemo.Book book) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((book != null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
@Override
public int getBookSize() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookSize, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* 根据索引取书
*/
@Override
public com.xks.binderdemo.Book get(int index) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
com.xks.binderdemo.Book _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(index);
mRemote.transact(Stub.TRANSACTION_get, _data, _reply, 0);
_reply.readException();
if ((0 != _reply.readInt())) {
_result = com.xks.binderdemo.Book.CREATOR.createFromParcel(_reply);
} else {
_result = null;
}
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
static final int TRANSACTION_printBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_getBookSize = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
static final int TRANSACTION_get = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
}
/**
* 打印书籍
*/
public java.lang.String printBook(com.xks.binderdemo.Book book) throws android.os.RemoteException;
/**
* 添加书籍
*/
public void addBook(com.xks.binderdemo.Book book) throws android.os.RemoteException;
public int getBookSize() throws android.os.RemoteException;
/**
* 根据索引取书
*/
public com.xks.binderdemo.Book get(int index) throws android.os.RemoteException;
}
从上面可以看到BookManager内部有一个叫做Stub的抽象类实现了BookManager接口，并且将接口方法都变成了abstract，子类必须实现这些方法，至于其他Binde通信的细节，Android都已经帮我们实现了。
Stub中有个adInterface的方法，该方法主要用于客户端从IBinder对象得到BookManager接口，这样就可以通过该接口与服务端通信。
实现接口
在定义完接口后，在BookService中实现BookManager.Stub类，实现那几个抽象方法，如下:
public class BookService extends Service {
private List<Book> bookList = new ArrayList<>();
public class BookBinder extends BookManager.Stub {
@Override
public String printBook(Book book) throws RemoteException {
return book.toString();
}
@Override
public void addBook(Book book) throws RemoteException {
bookList.add(book);
}
@Override
public int getBookSize() throws RemoteException {
return bookList.size();
}
@Override
public Book get(int index) throws RemoteException {
return bookList.get(index);
}
}
private BookBinder bookBinder = new BookBinder();
public BookService() {
}
@Override
public IBinder onBind(Intent intent) {
return bookBinder;
}
}可以看到BookService的实现很简单，与单纯使用Binder类似，只不过这里继承的是BookManager.Stub，而不是Binder。最后在onBind方法中返回声明的对象即可。
3.向客户端公开接口
客户端这里使用的是Activity，界面上有四个按钮，分别对应于四个方法，最下面有个TextView用于显示信息，Activity的实现如下：
public class BookActivity extends AppCompatActivity {
private TextView infoShowTv;
private BookManager bookManager;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
bookManager = BookManager.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
bookManager = null;
}
};
private Book[] books = {
new Book(1, "Java编程思想"),
new Book(2, "第一行代码"),
new Book(3, "Anroid开发艺术探索")
};
private int index = 0;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_book);
infoShowTv = (TextView) findViewById(R.id.info_show_tv);
}
@Override
protected void onStart() {
super.onStart();
bindService(new Intent(this, BookService.class), connection, Service.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(connection);
}
/**
* 添加书籍
*
* @param view
*/
public void addBook(View view) {
if (bookManager != null)
try {
bookManager.addBook(books[index++ % books.length]);
} catch (RemoteException e) {
e.printStackTrace();
}
}
public void printBook(View view) {
if (bookManager != null)
try {
infoShowTv.setText(bookManager.printBook(books[index % books.length]));
} catch (RemoteException e) {
e.printStackTrace();
}
}
public void getSize(View view) {
if (bookManager != null)
try {
infoShowTv.setText(String.valueOf(bookManager.getBookSize()));
} catch (RemoteException e) {
e.printStackTrace();
}
}
public void getFirst(View view) {
if (bookManager != null)
try {
infoShowTv.setText(bookManager.printBook(bookManager.get(0)));
} catch (RemoteException e) {
e.printStackTrace();
}
}
}下图是效果：
上图中，首先获取List的尺寸为0，然后加入一本书后，尺寸就变成了1，然后打印，继续加书获取尺寸。
使用AIDL的时候，需要注意的是，调用服务端的方法都是同步调用的，所以如果说如果操作很耗时的话，那么客户端调用需要放到线程中操作；另外，服务端需要注意线程安全问题，因为多个客户端调用时会有并发问题，而Messenger内部就不需要了，因为Handler确保了消息的同步性。
总结
从上面可以看到，绑定服务时，如果服务和客户端在同一个进程中，那么直接在服务端扩展Binder即可；如果服务和客户端不在同一个进程中，那么可以使用Messenger或AIDL。Messenger是进行IPC的最简单方式，并且Android用Handler帮我们实现了一个队列，不需要考虑线程安全问题；而使用AIDL的方式则更加通用，需要开发者自己考虑线程安全问题。
对于进程间通信或客户端和服务端在同一个进程中，底层使用的都是Binder。可以认为只有当客户端得到服务端Binder的一个句柄后，才可以通过该句柄来控制服务端，与服务端进行通信。对上述三种情况分别为：
- 客户端和服务在同一个进程中，客户端在ServiceConnection的onServiceConnected中得到服务端的Binder对象
- 使用Messenger时，客户端同样在ServiceConnection的onServiceConnect回调中得到服务端的Messenger,然后使用Messenger发送消息
- 使用AIDL时，与客户端和服务在同一个进程中一样
本文的代码可以查看我的Github地址
扫一扫
694
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
