Binder解析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

interface BookController {

    List<Book> getBookList();

    void addBookInOut(inout Book book);

    void addBookIn(in Book book);

    void addBookOut(out Book book);
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//包名与项目包名一致
package com.vee.aidltest;

/**
*   自动生成的接口
**/
public interface IMyAidlInterface extends android.os.IInterface{

    /**
    *    我们自己声明的业务函数
    **/
    public java.lang.String getName() throws android.os.RemoteException;
  
    
    /**
    * 本接口的默认实现，其中业务方法`getName`返回null;
    **/
    public static class Default implements com.vee.aidltest.IMyAidlInterface{

        ...
    }


    /**
    *   静态内部类，继承自`android.os.Binder.Stub`类型，也遵循AIDL接口
    **/
    public static abstract class Stub extends android.os.Binder implements com.vee.aidltest.IMyAidlInterface{

        /**
        * 用来标记当前Binder，所以采用全类名表示
        **/
        private static final java.lang.String DESCRIPTOR = "com.vee.aidltest.IMyAidlInterface";
    
        /**
        *   构造方法中调用对象方法。
        **/
        public Stub(){
        this.attachInterface(this, DESCRIPTOR);
        }
        /**
        *  用于将服务端的Binder对象转换成客户端所需的AIDL接口类型的对象，这种转换过* 程是区分进程的，如果客户端和服务端位于同一进程，那么此方法返回的就是服务端*的Stub对象本身，否则返回的是系统封装后的Stub.proxy对象 
        */
        public static com.vee.aidltest.IMyAidlInterface asInterface(android.os.IBinder obj){
        if ((obj==null)) {
            return null;
        }
        android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
        if (((iin!=null)&&(iin instanceof com.vee.aidltest.IMyAidlInterface))) {
            return ((com.vee.aidltest.IMyAidlInterface)iin);
        }
        return new com.vee.aidltest.IMyAidlInterface.Stub.Proxy(obj);
        }

        /**
        * 返回当前Binder对象
        **/
        @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{
        java.lang.String descriptor = DESCRIPTOR;
        
        switch (code){
            case INTERFACE_TRANSACTION:
            {
            reply.writeString(descriptor);
            return true;
            }
            case TRANSACTION_getName:
            {
            data.enforceInterface(descriptor);
            java.lang.String _arg0;
            _arg0 = data.readString();
            java.lang.String _result = this.getName(_arg0);
            reply.writeNoException();
            reply.writeString(_result);
            return true;
            }
            default:
            {
            return super.onTransact(code, data, reply, flags);
            }
        }
        }

        /**
        *   自动生成的静态代理，在客户端回调
        **/
        private static class Proxy implements com.vee.aidltest.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 getName() 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);
            boolean _status = mRemote.transact(Stub.TRANSACTION_getName, _data, _reply, 0);
            if (!_status && getDefaultImpl() != null) {
                return getDefaultImpl().getName();
            }
            _reply.readException();
            _result = _reply.readString();
            }
            finally {
            _reply.recycle();
            _data.recycle();
            }
            return _result;
        }
        public static com.vee.aidltest.IMyAidlInterface sDefaultImpl;
        }
    
        /**
        *   用来标记我们自己定义的方法，前缀确定
        **/
        static final int TRANSACTION_getName = (android.os.IBinderFIRST_CALL_TRANSACTION + 0);
        

        /**
        * 当处于客户端时调用，这里就是生成代理
        **/
        public static boolean setDefaultImpl(com.vee.aidltest.IMyAidlInterface impl) {
        if (Stub.Proxy.sDefaultImpl != null) {
            throw new IllegalStateException("setDefaultImpl() called twice");
        }
        if (impl != null) {
            Stub.Proxy.sDefaultImpl = impl;
            return true;
        }
        return false;
        }

        /**
        *   当处于客户端时用来获取代理对象
        **/
        public static com.vee.aidltest.IMyAidlInterface getDefaultImpl() {
        return Stub.Proxy.sDefaultImpl;
        }
}

1
2
3
4

/**
*   用来标记我们自己定义的方法，前缀确定
**/
static final int TRANSACTION_getName = (android.os.IBinderFIRST_CALL_TRANSACTION + 0);