【Android深入源码分析理解Aidl整体调用流程（雷惊风）】相逢意气为君饮，系马高楼垂柳边。这篇文章主要讲述Android深入源码分析理解Aidl整体调用流程（雷惊风）相关的知识，希望能为你提供帮助。
2017年开始上班的第一天，
老不想工作了，
假期感觉还没开始就已经结束了，
唉，
时间就是这样，
新的一年开始了，
虽然很不想干正事，
没办法，
必须干起来，
因为后边的路还很长，
距离六十岁还很远。刚上班也没什么事，
复习一下之前的东西，
看了一下Aidl相关的知识，
仔细瞅了瞅Aidl的调用流程，
这里写篇文章整理一下，
帮助大家的同时，
自己也加深一下印象。对Aidl不太了解的童鞋可以先看一下我之前的一篇文章，
链接如下：
http://blog.csdn.net/liuyonglei1314/article/details/54317902
案例下载链接：
http://download.csdn.net/detail/liuyonglei1314/9734165 。
在上篇文章中我们已经说过了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<
Person>
CREATOR =
new Creator<
Person>
() {
@
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、final的CREATOR跟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.aidl.aidldemo.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中的CREATOR的createFromParcel（ ） 方法， 咦， 这里又用到了Parcelable的东西。看一下这个方法：
public static final Creator<
Person>
CREATOR =
new Creator<
Person>
() {
@
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 {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_outPerson, _data, _reply, 0);
_reply.readException();
_result =
_reply.readString();
if ((0 !=
_reply.readInt())) {
p.readFromParcel(_reply);
}
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}有了上边对inPerson（ ） 方法的了解这个相对就简单多了， 同样生成两个Parcel对象， 作用相同， 不同的是用out修饰后没有对传入的p做null判断， 也没有取值保存到data中， 而是直接调用了mRemote.transact(Stub.TRANSACTION_outPerson, _data, _reply, 0)方法， 那好， 通过前边我们直接去Stub中找onTransact（ ） 方法吧：
case TRANSACTION_outPerson: {
data.enforceInterface(DESCRIPTOR);
com.jason.aidl.aidldemo.Person _arg0;
_arg0 =
new com.jason.aidl.aidldemo.Person();
java.lang.String _result =
this.outPerson(_arg0);
reply.writeNoException();
reply.writeString(_result);
if ((_arg0 !=
null)) {
reply.writeInt(1);
_arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
}我们只要out方法相关信息， 这里系统通过new Person（ ） 的方式创建了一个person对象实例赋值个_arg0,这个对象与我们调用时传进来的对象没有一点关系， 然后直接调用了this.outPerson()方法， 通过inPerson（ ） 的介绍我们就知道这里直接调用了服务端outPerson（ ） 实现：
@
Override
public String outPerson(Person p) throws RemoteException {
//这里的p是空的，
因为在IMyAidlInterface的Stub类中onTransact（
）
方法中没有写入；
// _arg0 =
new com.jason.aidl.aidldemo.Person();
//java.lang.String _result =
this.outPerson(_arg0);
String old =
"
name:"
+
p.getName() +
"
age:"
+
p.getAge();
Log.d("
Log_LYL:outPerson_"
, old);
p.setName("
周六"
);
p.setAge(20);
return "
name:"
+
p.getName() +
"
age:"
+
p.getAge();
}这里可以知道old是没有赋值的， 下面赋值return， 回到Stub中：
java.lang.String _result =
this.outPerson(_arg0);
reply.writeNoException();
reply.writeString(_result);
if ((_arg0 !=
null)) {
reply.writeInt(1);
_arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
将处理结果写入reply中， 判断_arg0是否为null， 不是， 写入1， 这里又一次用到了writeToParcel（ ） 方法， 通过上边inPerson（ ） 方法介绍可知这里是将_arg0的值付给reply； 如果为null， reply中赋值0。回到Proxy中：
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_outPerson, _data, _reply, 0);
_reply.readException();
_result =
_reply.readString();
if ((0 !=
_reply.readInt())) {
p.readFromParcel(_reply);
}
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
执行完transact（ ） 方法后从_reply中读出服务端操作返回结果， 判断写入的int值， 如果不为0， 说明_reply中写入了服务端产生的person信息， 则将通过readFromParcel（ ） 方法将新的_reply中保存的服务端的person信息写入到客户端传入的p中， 这样客户端就收到了服务端的person信息。总结一下out修饰符， 即使我们在服务端将p的值写好， 服务端也不会接收我们的客户端信息， 可以说服务端根本不关系客户端传入的信息， 服务端通过new Person（ ） 方式产生新对象， 并返回给客户端， 客户端的p通过readFromParcel（ ） 方法获得服务端值， 并没有做对象的交换。
下边看一下inout修饰符代码：
String inOutPerson(inout Person p);
//.aidl文件中；
mService.inOutPerson(p3)；
//客户端调用；
同样看一下Proxy中相应方法：
@
Override
public java.lang.String inOutPerson(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_inOutPerson, _data, _reply, 0);
_reply.readException();
_result =
_reply.readString();
if ((0 !=
_reply.readInt())) {
p.readFromParcel(_reply);
}
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}case TRANSACTION_inOutPerson: {
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.inOutPerson(_arg0);
reply.writeNoException();
reply.writeString(_result);
if ((_arg0 !=
null)) {
reply.writeInt(1);
_arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
}可以看到在inout修饰符时判断了传入的p对象， 也就是说服务端接收了保存了客户端的p对象， 操作类似与in修饰符， 也是通过Person.CREATOR.createFromParcel(data)创建新对象， 在Proxy中同样判断了_reply中写入的int值， 也就是说， 客户端也能收到服务端对对象的修改， 也就是说， inout操作符是int、out操作符的合体。到这里相信大家已经明白in、out、inout操作符的区别了， 并且连实现都明白了。
到现在今天要跟大家分享的东西就写完了， 相信您看完这篇文章会对Android中的Aidl有一个新的了解， 对in、out、inout修饰也明白了， 对实现Parcelable接口有了新的认识， 如果是这样， 那我这篇文章就没白写， 谢谢大家。
推荐阅读
- Android之Activity系列总结--Activity的四种启动模式
- Android 官方示例（android-architecture 学习笔记之todo-mvp）
- Android之Activity系列总结--任务和返回栈
- 解决sdk更新时候报错 http://dl-ssl.google.com/android上不去，链接拒绝
- 电脑没有音频设备怎样办,图文详细说明电脑没有音频设备怎样处理
- 谷歌浏览器怎样设置首页,图文详细说明谷歌浏览器怎样设置首页
- 无法加载插件,图文详细说明怎样处理浏览器显示无法加载插件
- 电脑分辨率低,图文详细说明电脑分辨率低怎样办
- excel词典xllex.dll文件失去或损坏,图文详细说明excel词典xllex.dll文件失去或损坏怎样处理