Android深入源码分析理解Aidl整体调用流程(雷惊风)

        2017年开始上班的第一天,老不想工作了,假期感觉还没开始就已经结束了,唉,时间就是这样,新的一年开始了,虽然很不想干正事,没办法,必须干起来,因为后边的路还很长,距离六十岁还很远。刚上班也没什么事,复习一下之前的东西,看了一下Aidl相关的知识,仔细瞅了瞅Aidl的调用流程,这里写篇文章整理一下,帮助大家的同时,自己也加深一下印象。对Aidl不太了解的童鞋可以先看一下我之前的一篇文章,

链接如下:http://blog.csdn.net/liuyonglei1314/article/details/54317902 

案例下载链接:http://download.csdn.net/detail/liuyonglei1314/9734165 

   在上篇文章中我们已经说过了AndroidAidl的简单应用及对象的传递方式,还包含了在AS中进行Aidl开发会遇到的一些问题及决解方法,本篇文章针对使用方法我们不在多说,我们将以传递对象为例深入的剖析Aidl的详细调用流程,继续以上文中传递Person对象为例展开,通过本片文章的学习你会学到以下相关知识:1.Aidl工作调用流程;2.Aidl传递对象时修饰符inoutinout的深入理解。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接口,有两个构造方法,有nameage两个成员变量,编译器可以帮我们生成一个staticfinalCREATORwriteToParcel()方法,我们自己写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中配置,详细信息就不介绍了,上篇文章中进行了详细讲解,在这里看到了修饰符inoutinout,后文会做详细讲解。

我们继续看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(最外层的类)两个内部类(StubProxy),先看interface,它跟我们定义的.aidl文件名字相同,继承了IInterface,它的内容分为两部分:一个内部类Stub及我们定义的Person抽象操作方法,每一个都抛出RemoteException。接下来看他的内部类Stub,它是一个抽象类,继承了Binder类,实现了外层的Interface,他比较重要的是一个asInterface()方法和onTransact()方法,它还有一个static的内部类Proxy,它也实现了最外层的Interface,另外有一个需要传递Ibinder的构造函数,还有就是与我们在Aidl类中定义的方法名称相同的方法。这就是我们生成的.java文件的一个大致的架构。由上边可知最外层InterfaceIInterface的子类,而StubProxy是最外层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文件的一个实例。我们接着看IMyAidlInterfaceStub.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类继承了BinderBinder实现了Ibinder接口,所以传递Stub的实例在这里没问题。上述代码首先判断了obj是否为空,不为空往下走,第二个if判断是在判断通过obj获取的iin是否属于当前程序运行的进程,如果是,直接返回,这里也就是说我们要调用的服务与我们当前程序在同一进程,不需要远程通信,直接调用就行。如果不是可以看见系统新生成了一个Proxy对象实例,并把我们的stub实例对象传递进去,看一下Proxy的构造函数,代码如下:

private android.os.IBinder mRemote;

Proxy(android.os.IBinder remote) {
    mRemote = remote;
}

可以看到通过构造函数将Stub实例又一次传到了Proxy中并赋值给mRemotemRemote也变成了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();
    }
}

我们首先分析第一个inPersonp1);这个方法我们在定义时的修饰符为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修饰后没有对传入的pnull判断,也没有取值保存到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有一个新的了解,对inoutinout修饰也明白了,对实现Parcelable接口有了新的认识,如果是这样,那我这篇文章就没白写,谢谢大家。

    原文作者:Android源码分析
    原文地址: https://blog.csdn.net/liuyonglei1314/article/details/54849197
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞