Android深入理解分析Aidl调用作业流程.docx

Android深入了解分析Aidl调用步骤
开始上班第一天，老不想工作了，假期感觉还没开始就已经结束了，唉，时间就是这么，新十二个月开始了，即使很不想干正事，没措施，必需干起来，因为后边路还很长，距离六十岁还很远。刚上班也没什么事，复习一下之前东西，看了一下Aidl相关知识，仔细瞅了瞅Aidl调用步骤，这里写篇文章整理一下，帮助大家同时，自己也加深一下印象。对Aidl不太了解童鞋能够先看一下我之前一篇文章，链接以下： 案例下载链接： 。
在上篇文章中我们已经说过了Android中Aidl简单应用及对象传输方法，还包含了在AS中进行Aidl开发会碰到部分问题及决解方法，本篇文章针对使用方法我们不在多说，我们将以传输对象为例深入剖析Aidl具体调用步骤，继续以上文中传输Person对象为例展开，经过本片文章学习你会学到以下相关知识：1.Aidl工作调用步骤；2.Aidl传输对象时修饰符in、out、inout深入了解。3.对实现Parcelable接口对象中需要实现方法深入了解。
首先看一下我们要传输对象代码：
public class Person implements Parcelable {
private String name;
private int age;

public Person() {
}

protected Person(Parcel in) {
name = in.readString();
age = in.readInt();
}

public static final Creator CREATOR = new Creator() {
@Override
public Person createFromParcel(Parcel in) {
return new Person(in);
}

@Override
public Person[] newArray(int size) {
return new Person[size];
}
};

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

@Override
public int describeContents() {
return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(age);
}
public void readFromParcel(Parcel dest) {
name = dest.readString();
age = dest.readInt();
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
Person类实现了parcelable接口，有两个结构方法，有name、age两个组员变量，编译器能够帮我们生成一个static、finalCREATOR跟writeToParcel（）方法，我们自己写readFromParcel（）方法，这里切记次序要和writeToParcel（）方法一直。

下边再看一下我们.aidl文件代码：
import com.jason.aidl.aidldemo.Person;
interface IMyAidlInterface {
String inPerson(in Person p);
String outPerson(out Person p);
String inOutPerson(inout Person p);
}
这里需要注意我们Person也需要写对应Person.aidl文件，并在build.gradle中配置，具体信息就不介绍了，上篇文章中进行了具体讲解，在这里看到了修饰符in、out、inout，后文会做具体讲解。

我们继续看Aidl文件生成对应.java文件一个整体架构。缩略代码以下：
public interface IMyAidlInterface extends android.os.IInterface {
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.jason.aidl.aidldemo.IMyAidlInterface {
private static final java.lang.String DESCRIPTOR = "com.jason.aidl.aidldemo.IMyAidlInterface";

/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}

/**
* Cast an IBinder object into an com.jason.aidl.aidldemo.IMyAidlInterface interface,
* generating a proxy if needed.
*/
public static com.jason.aidl.aidldemo.IMyAidlInterface asInterface(android.os.IBinder 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 {
//...
return super.onTransact(code, data, reply, flags);
}

private static class Proxy implements com.jason.aidlaidldemo.IMyAidlInterface {
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 inPerson(com.jason.aidl.aidldemo.Person p) throws android.os.RemoteException {
//...
return _result;
}

@Override
public java.lang.String outPerson(com.jason.aidl.aidldemo.Person p) throws android.os.RemoteException {
//...
return _result;
}

@Override
public java.lang.String inOutPerson(com.jason.aidl.aidldemo.Person p) throws android.os.RemoteException {
//...
return _result;
}
}

static final int TRANSACTION_inPerson = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_outPerson = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_inOutPerson = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
}

public java.lang.String inPerson(com.jason.aidl.aidldemo.Person p) throws android.os.RemoteException;

public java.lang.String outPerson(com.jason.aidl.aidldemo.Person p) throws android.os.RemoteException;

public java.lang.String inOutPerson(com.jason.aidl.aidldemo.Person p) throws android.os.RemoteException;
}
大致分为三部分，一个interface（最外层类）两个内部类（Stub、Proxy），先看interface，它跟我们定义.aidl文件名字相同，继承了IInterface，它内容分为两部分：一个内部类Stub及我们定义Person抽象操作方法，每一个全部抛出RemoteException。接下来看她内部类Stub,它是一个抽象类，继承了Binder类，实现了外层Interface，她比较关键是一个asInterface（）方法和onTransact（）方法，它还有一个static内部类Proxy，它也实现了最外层Interface，另外有一个需要传输Ibinder结构函数，还有就是和我们在Aidl类中定义方法名称相同方法。这就是我们生成.java文件一个大致架构。由上边可知最外层Interface是IInterface子类，而Stub和Proxy是最外层Interface实现类，Stub继承了Binder，她们之间存在这么关系。下面我们就对代码调用步骤进行具体讲解。

首先我们在应用Aidl时经过用户端绑定方法来获取我们IMyAidlInterface，并经过它来调用服务端方法进行通信，以下代码：
private IMyAidlInterface mService;

Intent intent = new Intent();
intent.setAction("com.lyl.aidl");
Intent intent1 = new Intent(createExplicitFromImplicitIntent(this, intent));//兼容5.0以后版本
bindService(intent1, mServiceC, Context.BIND_AUTO_CREATE);

ServiceConnection mServiceC = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = IMyAidlInterface.Stub.asInterface(service);
}

@Override
public void onServiceDisconnected(ComponentName name) {

}
};
public void do(View v) {
try {
Person p1 = new Person();
p1.setName("刘大");
p1.setAge(3);
Person p2 = new Person();
p2.setName("赵二");
p2.setAge(3);
Person p3 = new Person();
p3.setName("张三");
p3.setAge(3);

tv.setText("" + mService.inPerson(p1) + "\n" + mService.outPerson(p2) + "\n" + mService.inOutPerson(p3));

} catch (RemoteException e) {
e.printStackTrace();
}
}

上边代码经过IMyAidlInterface.Stub.asInterface(service)获取了我们IMyAidlInterface,do（）方法中经过它才调用了我们服务端代码，那我们先看一下这个asInterface方法中参数是什么，我们知道当经过绑定方法获取binder是我们在服务中onBind（）方法中返回，看一下我们服务端代码：
public class MyAidlService extends Service {

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i("Log_LYL", "Onstart");
return super.onStartCommand(intent, flags, startId);

}

@Override
public IBinder onBind(Intent intent) {
return stub;
}

IMyAidlInterface.Stub stub = new IMyAidlInterface.Stub() {

@Override
public String inPerson(Person p) throws RemoteException {
...
}

@Override
public String outPerson(Person p) throws RemoteException {
...
}

@Override
public String inOutPerson(Person p) throws RemoteException {
...
}
};
}
经过以上服务端代码能够知道我们返回是一个stub 事例，而它是我们.aidl文件自动生成.java文件中Stub一个实例对象。现在我们知道IMyAidlInterface.Stub.asInterface(service)中service是编译器为我们生成.java文件一个实例。我们接着看IMyAidlInterface中Stub.asInterface(service)方法，代码以下：
public static com.jason.aidl.aidldemo.IMyAidlInterface asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.jason.aidl.aidldemo.IMyAidlInterface))) {
return ((com.jason.aidl.aidldemo.IMyAidlInterface) iin);
}
return new com.jason.aidl.aidldemo.IMyAidlInterface.Stub.Proxy(obj);
}
因为我们Stub类继承了Binder，Binder实现了Ibinder接口，所以传输Stub实例在这里没问题。上述代码首先判定了obj是否为空，不为空往下走，第二个if判定是在判定经过obj获取iin是否属于目前途序运行进程，假如是，直接返回，这里也就是说我们要调用服务和我们目前途序在同一进程，不需要远程通信，直接调用就行。假如不是能够看见系统新生成了一个Proxy对象实例，并把我们stub实例对象传输进去，看一下Proxy结构函数，代码以下：
private android.os.IBinder mRemote;

Proxy(android.os.IBinder remote) {
mRemote = remote;
}
能够看到经过结构函数将Stub实例又一次传到了Proxy中并赋值给mRemote，mRemote也变成了Stub实例。
到这里绑定服务获取ImyAidlInterface对象就介绍完了，做一下总结：经过绑定方法获取到了在服务端系统生成.aidl文件对应.java文件中子类Stub一个实例，调用Stub类中asInterface（）方法判定Stub实例所在进程和目前进程是否为同一个，是直接能够操作，不是生成一个Proxy实例并将Stub传入。

下面我们看一下调用代码实现：
public void do(View v) {
try {
Person p1 = new Person();
p1.setName("刘大");
p1.setAge(3);
Person p2 = new Person();
p2.setName("赵二");
p2.setAge(3);
Person p3 = new Person();
p3.setName("张三");
p3.setAge(3);

tv.setText("" + mService.inPerson(p1) + "\n" + mService.outPerson(p2) + "\n" + mService.inOutPerson(p3));

} catch (RemoteException e) {
e.printStackTrace();
}
}
我们首先分析第一个inPerson（p1）；这个方法我们在定义时修饰符为in，及String inPerson(in Person p);下边我们看一下它实现过程，经过上边介绍能够知道mService假如不是在同一个进程中是返回Proxy对象实例，那么我们就进入Proxy中查找对应方法，代码以下：
@Override
public java.lang.String inPerson(com.jason.aidl.aidldemo.Person p) 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 ((p != null)) {
_data.writeInt(1);
p.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_inPerson, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
能够看到系统生成了_data、_reply两个Parcel类型对象，然后操作_data，写入Token，判定假如传入Person对象不为空写入了一个1，接下来调用了person类writeToParcel（）方法，传入了_data，咦，注意这里，我们就知道了实现Parcelable接口时writeToParcel（）方法在这里会用到。好，我们跟进看一下，代码以下：
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeInt(age);
}
这一步看来就是给_data赋值，将我们从开始调用inPerson(com.jason.aidl.aidldemo.Person p) p实例中值以writeString、writeInt方法保留到_data中，假如传入p为null则写入一个0。继续往下走，我标红那句是关键，也是这句进行了binder通信，相关binder通讯机制有很多很多东西，因为本人能力有限在这里就不多讲了，感爱好能够去了解一下。经过前边能够知道mRemote为asInterface方法传入service，及Stub实例，而Stub中根本没有transact（）方法，而它是Binder子类，好，我们去Binder中找，还真有：
public final boolean transact(int code, Parcel data, Parcel reply,
int flags) throws RemoteException {
if (false) Log.v("Binder", "Transact: " + code + " to " + this);

if (data != null) {
data.setDataPosition(0);
}
boolean r = onTransact(code, data, reply, flags);
if (reply != null) {
reply.setDataPosition(0);
}
return r;
}
能够看到，在这里调用了onTransact(code, data, reply, flags);我们知道在Stub类中我们实现了这个方法，我们看一下Stub类中这个方法：
@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_inPerson: {
data.enforceInterface(DESCRIPTOR);
com.jason.aidl.aidldemo.Person _arg0;
if ((0 != data.readInt())) {
_arg0 = com.jason.aidl.aidldemo.Person.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
java.lang.String _result = this.inPerson(_arg0);
reply.writeNoException();
reply.writeString(_result);
return true;
}

}
return super.onTransact(code, data, reply, flags);
}
在这里我们只摘取了inPerson（）方法相关内容，先了解一下传入四个参数：1.code 每一个方法对应一个code，我们定义了多少方法就会有多少code，经过它来做不一样处理；2.data、reply为在proxy对应方法中生成两个Parcel对象；3.flags 通常为1，这个不用管先。 首先经过code找到对应方法操作，判定data中写入int值是否为0，不为0说明之前p不为null，而且已经存入到data中，调用Person中CREATORcreateFromParcel（）方法，咦，这里又用到了Parcelable东西。看一下这个方法：
public static final Creator CREATOR = new Creator() {
@Override
public Person createFromParcel(Parcel in) {
return new Person(in);
}
@Override
public Person[] newArray(int size) {
return new Person[size];
}
};
protected Person(Parcel in) {
name = in.readString();
age = in.readInt();
}

能够看到，系统在这里创建了一个Person实例，传入了我们之前data（保留有person信息），并将data中信息赋值给新person对象。回到Stub类onTransace（）方法中继续往下看：
java.lang.String _result = this.inPerson(_arg0);
reply.writeNoException();
reply.writeString(_result);
return true;
接着系统调用了this.inPerson(_arg0)方法，_arg0为上边经过createFromParcel（）方法新生成person（包含传输过来person值）对象，我们知道Stub为抽象类，她实现了我们外层Interface类，不过没有实现inPerson（）方法，那么我们就需要它子类实现，而我们mRemote.transace（）中mRemote就是服务端返回Stub一个实现子类，也就是说这里调用this.inPerson(_arg0)方法实际是调用了服务端那个Stub实现类里边inPerson()方法，看一下我们之前服务端inPerson()方法具体实现：
@Override
public String inPerson(Person p) throws RemoteException {
String old = "name:" + p.getName() + " age:" + p.getAge();
Log.d("Log_LYL:iPerson_", old);
p.setName("李四");
p.setAge(13);
return "name:" + p.getName() + " age:" + p.getAge();
}
经过以上分析，大家就知道了这里 Log.d("Log_LYL:iPerson_", old); 是为何有值了，因为我们一开始就将传入person值附到了Parcel类型data中了，然后又经过createFromParcel（）方法将data中值付给了新person对象。 然后回到Stub类onTransace（）方法，会看到调用了reply.writeNoException();reply.writeString(_result);两个方法，将服务端处理完后返回信息写入了reply中。最终return。再回到Proxy类中inPerson（）方法中：
mRemote.transact(Stub.TRANSACTION_inPerson, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
将服务端返回信息读出来并付给_result，最终返回，这么我们在activity中就能够得到服务端处理后结果了，到现在为止，我们就应该明白了，经过in修饰符传输person后服务端生成了新person对象，并对新person对象进行处理，这么话不管服务端怎样修改person对象我们用户端person对象是不会受任何影响，为何，因为不是一个对象。这就是in操作符。
下面我们分析一下out操作符，直接看代码：
String outPerson(out Person p);//.aidl文件中定义；
mService.outPerson(p2)//用户端调用；
我们在用户端直接经过绑定时返回Stub实例调用outPerson（）方法，经过上边对inPerson（）方法介绍我们知道不是同一个进程中会最终调用到Proxy中对应方法中，那我们直接看Proxy中代码：
@Override
public java.lang.String outPerson(com.jason.aidl.aidldemo.Person p) 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