Binder的机制
Binder是什么
binder是什么？我们都在Activity通过getSystemService（）方法获取系统的Service（例如：ActivityManagerService，WindowManagerService等），这些Activity一般都是客户端编写的，而系统的这些Service是属于服务端的。显然它们不会在同一进程（一般来说，一个APP单独在一个进程）。两个进程之间怎么通信？Binder就是两个进程通信的中间媒介。
Binder的使用
编写一个定位的Service。
服务端：
public class LocationManagerService extends Binder {
private static final String TAG = "LocationService";
/**
*
* @param code 用于标识客户端期望调用服务端的哪个函数
* @param data 客户端传递的参数
* @param reply 返回给客户端的数据
* @param flags 执行IPC的模式，分为两种一种是双向的，用常量0表示，其含义是服务端执行指定服务后返回一定的数据，另一种是单向的，用常量1表示，其含义不返回任何数据
* @return
* @throws RemoteException
*/
@Override
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
switch (code){
case 101:
data.enforceInterface(TAG);
double lat = data.readDouble();
double lng = data.readDouble();
setLocation(lat,lng);
reply.writeString("Successful");
break;
default:
break;
}
return super.onTransact(code, data, reply, flags);
}
public void getMyLocation(){
}
public void setLocation(double lat,double lng){
}
}
服务的很简单，从代码的角度来看：只需继承Binder类重写onTransact的方法即可。
在onTransact方法里，我们写了一些代码 switch (code)...case 101；这里就有几个问题：
- 为什么101，不是102或者其他的？其实code的变量是用于识别客户端期望调用服务端的哪一个函数。双放需要约定一组code值int类型的。
- 服务端如何知道data变量中的位置？从上面的代码来看为什么第一个参数是lat，第二个lng，为什么不能第一个lng，第二个lat？这也需要双方有个约定。
在上述代码中调用了 data.enforceInterface(TAG);是为了校验与客户端 data.writeInterfaceToken("LocationManagerService");相对应。
客户端：
{
IBinder mRemote = getLocationService("LocationManagerService");
Double lat = 1.2323;
Double lng = 1.2434;
int code = 101;
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken("LocationService");
data.writeDouble(lat);
data.writeDouble(lng);
try {
mRemote.transact(code,data,reply,0);
String replyStr = reply.readString();
} catch (RemoteException e) {
e.printStackTrace();
}
}
在客户端，我们首先远程获取服务端的Binder对象。获取到该变量后，就可以调用该变量到方法transact方法。该方法的原型是： public boolean transact(int code, Parcel data, Parcel reply, int flags)；参数与服务端的onTransact方法的参数相对应。
这里两个很重要的问题：
- 怎么获取远程的Binder对象？
- 客户端需要和服务端约定好两件事
- 服务端不同函数code的值
- 服务端函数参数的顺序。
这两个重要问题是必须要解决的。
对于第一个问题：
当我们扩展系统服务的时候可以使用Service类（四大组件之一的Service）来获取Binder对象。这是系统提供给的。这是非必需的，当然可以自己写一套方法来获取到这个远程的Binder对象。
而当我们是扩展客户端服务是必须基于Service类（四大组件之一的Service）来编写。所谓的系统服务是可以指使用getSystemService（）方法来获取的服务，所谓的客户端服务指的是应用程序提供的自定义服务。
对于第二个问题：系统给我们提供了一个aidl工具，该工具可以把一个aidl文件转换为一个Java类，在该Java类同时重载类transact方法和onTransact方法。从而统一了写入参数的顺序和读取参数的顺序。然而aidl工具也是非必需的，也是完全可以自己写一套方法来统一写入参数和读取参数顺序的算法。
使用系统提供的Service（四大组件之一）和aidl工具来了解Binder的运行的机制。
创建ILocationManager.aidl文件：
interface ILocationManager {
Location getLocation();
void setLocation(double lat,double lng);
}
如果.aidl文件中用到了自定义的Parcelable对象，必须新建一个和它同名的aidl文件，并在其中声明它为Parcelabe类型。
在ILocationManager.aidl中我们使用Location这个类。
创建Location.aidl:
// Location.aidl
package com.example.maimingliang.test;
parcelable Location;
创建aidl的包结构在服务端和客户端要保持一致，否则运行会出错。
aidl只支持声明方法，不支持声明静态常量。
aidl支持的数据类型：
- 基本数据类型（int,long,char,boolean,double）
- String和CharSequence
- List：只支持ArrayList，里面的每个元素都必须能够被aidl支持
- Map：只支持HashMap，里面的每个元素都必须能够被aidl支持，包括key和value。
- Parcelable：所有实现Parcelable接口的对象。
- aidl：所有的aidl接口本身也可以在aidl文件中使用。
我们创建了一个ILocationManager.aidl文件，第一个字母的‘I‘是非必需的，是为了统一程序风格，‘I‘即IInterface类，是一个能够提供远程服务的类。aidl工具以该名称输出一个Java类。我们去看看这个生成的ILocationManager.java文件的代码：
/*
* This file is auto-generated. DO NOT MODIFY.
* Original file: /Users/maimingliang/AndroidStudioProjects/Test/app/src/main/aidl/com/example/maimingliang/test/ILocationManager.aidl
*/
package com.example.maimingliang.test;
public interface ILocationManager extends android.os.IInterface {
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.example.maimingliang.test.ILocationManager {
private static final java.lang.String DESCRIPTOR = "com.example.maimingliang.test.ILocationManager";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.example.maimingliang.test.ILocationManager interface,
* generating a proxy if needed.
*/
public static com.example.maimingliang.test.ILocationManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.example.maimingliang.test.ILocationManager))) {
return ((com.example.maimingliang.test.ILocationManager) iin);
}
return new com.example.maimingliang.test.ILocationManager.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_getLocation: {
data.enforceInterface(DESCRIPTOR);
com.example.maimingliang.test.Location _result = this.getLocation();
reply.writeNoException();
if ((_result != null)) {
reply.writeInt(1);
_result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
}
case TRANSACTION_setLocation: {
data.enforceInterface(DESCRIPTOR);
double _arg0;
_arg0 = data.readDouble();
double _arg1;
_arg1 = data.readDouble();
this.setLocation(_arg0, _arg1);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.example.maimingliang.test.ILocationManager {
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 com.example.maimingliang.test.Location getLocation() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
android.location.Location _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getLocation, _data, _reply, 0);
_reply.readException();
if ((0 != _reply.readInt())) {
_result = com.example.maimingliang.test.Location.CREATOR.createFromParcel(_reply);
} else {
_result = null;
}
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void setLocation(double lat, double lng) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeDouble(lat);
_data.writeDouble(lng);
mRemote.transact(Stub.TRANSACTION_setLocation, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_getLocation = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_setLocation = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public com.example.maimingliang.test.Location getLocation() throws android.os.RemoteException;
public void setLocation(double lat, double lng) throws android.os.RemoteException;
}
该java文件包含了三个类：
定义一个 Java interface内部包含 aidl 文件所声明的服务函数,类名称为 ILocationManager,并且该类基于 IInterface 接口,即需要 供一个 asBinder()函数
Stub类：
基于Binder和实现了ILocationManager接口的一个抽象类，之所以是抽象类也没有实现ILocationManager接口的方法，是因为具体的服务函数必须由程序员实现。
重写了onTransact()统一写入参数顺序和读出参数的顺序。
在Stub类中还定义了一些int常量，这些常量就是onTransact()和 transact()第一个参数code值的来源。
还有一个asInterface（）的方法：返回客户端所需的接口类型对象。这个方法是区分进程的。如果是当前进程：返回Stub对象本身。否则返回Stub.Proxy对象。
Stub.Proxy类
该类是当客户端远程获取Binder对象的使用的代理对象，该代理对象最主要的作用也是统一写入参数的顺序和读取参数的顺序。里面的方法被客户端所调用。
服务端
public class LocationManagerService extends Service {
private static final String TAG = "LocationManagerService";
private Binder mBinder = new ILocationManager.Stub(){
@Override
public Location getLocation() throws RemoteException {
Log.d(TAG,"-------->getLocation");
return null;
}
@Override
public void setLocation(double lat, double lng) throws RemoteException {
Log.d(TAG,"----> lat = " + lat +" --- > lng = " + lng);
}
};
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public void onCreate() {
super.onCreate();
}
服务端代码很简单，继承与四大组件之一的Service。创建一个Binder对象，并在onBind（）方法返回。
在清单文件注册：
<service android:name=".service.LocationManagerService"
android:process=":remote"></service>
让该服务类单独在一个进程，模拟跨进程通信。为了方便测试把服务端代码和客户端代码编写在同一工程。虽然同一工程，但其本质是一样的。
客户端
public class LocationManagerActivity extends AppCompatActivity {
private ServiceConnection mServiceConn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
ILocationManager locationManager = ILocationManager.Stub.asInterface(service);
try {
locationManager.setLocation(1.414,1.321);
locationManager.getLocation();
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_location_manager);
initData();
}
private void initData() {
Intent intent = new Intent(this,LocationManagerService.class);
bindService(intent,mServiceConn, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
unbindService(mServiceConn);
super.onDestroy();
}
}
可以看出，只需绑定一个Service，在ServiceConnection接口的onServiceConnected()方法的第二个变量 service，如果该Service启动正常，AmS会调用ActivityThread类中ApplicationThread对象，回调onServiceConnected()会带上serivce的Binder引用。
可以看到通过Service（四大组件之一）和aidl工具很容易就可以获取到远程到Binder对象，同时参数到写入和读出的顺序也无须关心。
分析整一个调用的流程：
当客户端在onServiceConnected获取到Binder对象后，调用
ILocationManager locationManager = ILocationManager.Stub.asInterface(service);转化我们定义的接口的类型。而locationManager引用的指向的真正类型是Stub.Proxy。
接着调用locationManager.setLocation(1.414,1.321);其实调用了是Stub.Proxy的set Location方法，在看看这个方法：
@Override
public void setLocation(double lat, double lng) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeDouble(lat);
_data.writeDouble(lng);
mRemote.transact(Stub.TRANSACTION_setLocation, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
在这个方法里，aidl工具定义transact（）方法内部给_data和_reply 写入参数的顺序。接着调用transact（）方法来发送远程请求，同时当前的线程会被挂，直到服务端进程返回数据（耗时的操作）。之后会调用Stub类的onTransact（）方法，进入该方法（只看set Location方法）：
case TRANSACTION_setLocation: {
data.enforceInterface(DESCRIPTOR);
double _arg0;
_arg0 = data.readDouble();
double _arg1;
_arg1 = data.readDouble();
this.setLocation(_arg0, _arg1);
reply.writeNoException();
return true;
}
transact（）方法内部_data， _reply的参数顺序是由aidl工具定义，在onTransact（）方法中，aidl工具自然的知道应该怎么读取参数。
END
