AIDL oneway 以及in、out、inout参数的理解

比眉伴天荒 2021-11-09 04:50 223阅读 0赞

# oneway #

oneway可以用来修饰在interface之前，这样会造成interface内所有的方法都隐式地带上oneway；  
oneway也可以修饰在interface里的各个方法之前。  
被oneway修饰了的方法不可以有返回值，也不可以有带out或inout的参数。

## 带oneway的实现 ##

带oneway的方法，不会生成局部变量`_reply`。且Proxy中transact中第四个参数必为`android.os.IBinder.FLAG_ONEWAY`。

//proxy类
        @Override public void testOneway(int pa) throws android.os.RemoteException
        { 
            android.os.Parcel _data = android.os.Parcel.obtain();
            try { 
                _data.writeInterfaceToken(DESCRIPTOR);
                _data.writeInt(pa);
                mRemote.transact(Stub.TRANSACTION_testOneway, _data, null, android.os.IBinder.FLAG_ONEWAY);
            }
            finally { 
                _data.recycle();
            }
        }

//stub类
    	@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    	{ 
    	    case TRANSACTION_testOneway:
    	    { 
    	        data.enforceInterface(descriptor);
    	        int _arg0;
    	        _arg0 = data.readInt();
    	        this.testOneway(_arg0);
    	        return true;
    	    }
    	}

## 不带oneway的实现 ##

不带oneway的方法，会生成局部变量`_reply`，但当方法返回值为void时，不会生成局部变量`_result`，这个才是真正的返回值。且Proxy中transact中第四个参数必为`0`。

//proxy类
    	@Override public byte SerTestIn(byte[] pa) throws android.os.RemoteException
    	{ 
    	    android.os.Parcel _data = android.os.Parcel.obtain();
    	    android.os.Parcel _reply = android.os.Parcel.obtain();
    	    byte _result;
    	    try { 
    	        _data.writeInterfaceToken(DESCRIPTOR);
    	        _data.writeByteArray(pa);
    	        mRemote.transact(Stub.TRANSACTION_SerTestIn, _data, _reply, 0);
    	        _reply.readException();
    	        _result = _reply.readByte();
    	    }
    	    finally { 
    	        _reply.recycle();
    	        _data.recycle();
    	    }
    	    return _result;
    	}

//stub类
    	case TRANSACTION_SerTestIn:
    	{ 
    	    data.enforceInterface(descriptor);
    	    byte[] _arg0;
    	    _arg0 = data.createByteArray();
    	    byte _result = this.SerTestIn(_arg0);
    	    reply.writeNoException();
    	    reply.writeByte(_result);
    	    return true;
    	}

# in、out、inout参数 #

为了测试，定义了如下AIDL文件：

package com.java.prac;
    import com.java.prac.IListener;
    
    interface IService {
        void registerListener(in IListener listener);
        void unregisterListener(in IListener listener);
        byte SerTestIn(in byte[] pa);
        byte SerTestOut(out byte[] pa);
        byte SerTestInout(inout byte[] pa);
    }

为了方便起见，把proxy类称为调用方，stub类称为实现方。在跨进程调用中，参数和返回值肯定都是会有复制的过程的，由于系统的设计，将内核空间再映射到用户空间，这样复制过程只需要一次。下面代码都是从自动生成的java代码抽取而来。

## in参数 ##

//stub类
    @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    {    
    	...
    	case TRANSACTION_SerTestIn:
    	{ 
    	    data.enforceInterface(descriptor);
    	    byte[] _arg0;
    	    _arg0 = data.createByteArray();
    	    byte _result = this.SerTestIn(_arg0);
    	    reply.writeNoException();
    	    reply.writeByte(_result);
    	    return true;
    	}
    	...
    }

*  proxy调用了`_data.writeByteArray(pa);`，说明pa这个参数确实传递到了服务方。但stub里只有`reply.writeByte(_result);`，说明服务方对pa参数的任何改变都不会反应到调用方。

## out参数 ##

//proxy类
        @Override public byte SerTestOut(byte[] pa) throws android.os.RemoteException
        { 
            android.os.Parcel _data = android.os.Parcel.obtain();
            android.os.Parcel _reply = android.os.Parcel.obtain();
            byte _result;
            try { 
                _data.writeInterfaceToken(DESCRIPTOR);
                if ((pa==null)) { 
                    _data.writeInt(-1);
                }
                else { 
                    _data.writeInt(pa.length);
                }
                mRemote.transact(Stub.TRANSACTION_SerTestOut, _data, _reply, 0);
                _reply.readException();
                _result = _reply.readByte();
                _reply.readByteArray(pa);
            }
            finally { 
                _reply.recycle();
                _data.recycle();
            }
            return _result;
        }

//stub类
    @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    {    
    	...
        case TRANSACTION_SerTestOut:
        { 
            data.enforceInterface(descriptor);
            byte[] _arg0;
            int _arg0_length = data.readInt();
            if ((_arg0_length<0)) { 
                _arg0 = null;
            }
            else { 
                _arg0 = new byte[_arg0_length];
            }
            byte _result = this.SerTestOut(_arg0);
            reply.writeNoException();
            reply.writeByte(_result);
            reply.writeByteArray(_arg0);
            return true;
        }
    	...
    }

*  proxy类里面，发现读取参数的时候，仅仅是`_data.writeInt(pa.length);`读取一下数组的长度，而不是读取数组的内容。
 *  stub类里面，发现它居然用之前读取的数组长度新建了一个数组`_arg0 = new byte[_arg0_length];`，然后把这个新建的同样长度的数组传递给了真正的方法，难道我们pa参数这个数组的内容都不重要吗，仅仅是为了告诉对方数组的长度吗？（你眉头一皱发现事情并不简单==）事实上，就是这么简单，pa数组的长度才是有用信息。
 *  stub类里面，开始设置返回值时，发现多了一步`reply.writeByteArray(_arg0);`，其实是服务方对新建的数组赋值了，然后要作为返回值返回。
 *  proxy类里面，既然服务方要返回调用方一个数组，那就接受吧，`_reply.readByteArray(pa);`，然后把pa进行赋值。

## inout参数 ##

//proxy类
        @Override public byte SerTestInout(byte[] pa) throws android.os.RemoteException
        { 
            android.os.Parcel _data = android.os.Parcel.obtain();
            android.os.Parcel _reply = android.os.Parcel.obtain();
            byte _result;
            try { 
                _data.writeInterfaceToken(DESCRIPTOR);
                _data.writeByteArray(pa);
                mRemote.transact(Stub.TRANSACTION_SerTestInout, _data, _reply, 0);
                _reply.readException();
                _result = _reply.readByte();
                _reply.readByteArray(pa);
            }
            finally { 
                _reply.recycle();
                _data.recycle();
            }
            return _result;
        }

//stub类
    @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    {    
    	...
        case TRANSACTION_SerTestInout:
        { 
            data.enforceInterface(descriptor);
            byte[] _arg0;
            _arg0 = data.createByteArray();
            byte _result = this.SerTestInout(_arg0);
            reply.writeNoException();
            reply.writeByte(_result);
            reply.writeByteArray(_arg0);
            return true;
        }
    	...
    }

*  分析和上面类似了。
 *  服务方会完好无损地收到调用方发来的pa数组。
 *  服务方可能会对pa数组进行修改，然后再返回给调用方。

## 总结 ##

*  in参数使得实参顺利传到服务方，但服务方对实参的任何改变，不会反应回调用方。
 *  out参数使得实参不会真正传到服务方，只是传一个实参的初始值过去（这里实参只是作为返回值来使用的，这样除了return那里的返回值，还可以返回另外的东西），但服务方对实参的任何改变，在调用结束后会反应回调用方。
 *  inout参数则是上面二者的结合，实参会顺利传到服务方，且服务方对实参的任何改变，在调用结束后会反应回调用方。
 *  其实inout，都是相对于服务方。in参数使得实参传到了服务方，所以是in进入了服务方；out参数使得实参在调用结束后从服务方传回给调用方，所以是out从服务方出来。