AIDL跨进程通信

// ISumServiceInterface.aidl
package com.example.server;

// Declare any non-default types here with import statements
interface ISumServiceInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);

    //此处声明对外提供的服务方法
    int sum(int a, int b);
}

public class SumService extends Service {
    @Nullable
    public static final String TAG = "aidl";
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "server端：onBind");
        return iBinder;
    }

    //ISumServiceInterface.Stub是AIDL自动生成的静态内部类，iBinder将返回给client端
    private IBinder iBinder = new ISumServiceInterface.Stub() {
        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

        }

        @Override
        public int sum(int a, int b) throws RemoteException {
            Log.e(TAG,"server端：收到Client端请求:a=" + a + ",b=" + b );
            return a + b;
        }
    };
}

       <service android:name=".SumService"
            android:process=":remote"
            android:exported="true">
            <intent-filter>
                <action android:name="com.example.server.sum_service"/> <!--client端绑定服务时需使用相同的action-->
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
        </service>

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "aidl";
    private EditText a = null;
    private EditText b = null;
    private TextView display;
    private Button sum;
    private Button bind;
    private ISumServiceInterface sumServiceInterface;
    private ServiceConnection conn = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.i(TAG, "client端：服务已绑定！");
            //这里调用Stub.asInterface实际上获得了server端ISumServiceInterface.Stub的远程对象
            sumServiceInterface = ISumServiceInterface.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "client端：服务已断开！");
            sumServiceInterface = null;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        a = findViewById(R.id.a);
        b = findViewById(R.id.b);
        sum = findViewById(R.id.sum);
        bind = findViewById(R.id.bind);
        display = findViewById(R.id.display);
        sum.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    int n1 = Integer.parseInt(a.getText().toString().trim());
                    int n2 = Integer.parseInt(b.getText().toString().trim());

                    //sumServiceInterface是server端ISumServiceInterface.Stub的远程对象
                    //通过它就可以调用server端的sum方法
                    int result = sumServiceInterface.sum(n1, n2);
                    Log.i(TAG, "client端：收到server端返回结果：" + result);
                    display.setText("结果：" + result);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        bind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bindService();
            }
        });
    }

    private void bindService() {
        Log.i(TAG, "client端：开始绑定SumService...");
        Intent intent = new Intent();
        //这里的Action和Server端配置的必须保持一致
        intent.setAction("com.example.server.sum_service");
        //要求显示调用，指定包名
        intent.setComponent(new ComponentName("com.example.server", "com.example.server.SumService"));
        //绑定并自动创建服务
        bindService(intent, conn, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}

I aidl    : client端：开始绑定SumService...
I aidl    : server端：onBind
I aidl    : client端：服务已绑定！
E aidl    : server端：收到Client端请求:a=55,b=45
I aidl    : client端：开始绑定SumService...
I aidl    : server端：onBind
I aidl    : client端：服务已绑定！
E aidl    : server端：收到Client端请求:a=55,b=45
I aidl    : client端：收到server端返回结果：100

public interface ISumServiceInterface extends android.os.IInterface {
  /**
   * Local-side IPC implementation stub class.
   */
  public static abstract class Stub extends android.os.Binder implements com.example.server.ISumServiceInterface {

    //DESCRIPTOR是Binder服务的唯一标志，一般用完全类名表示
    private static final java.lang.String DESCRIPTOR = "com.example.server.ISumServiceInterface";

    /**
     * Construct the stub at attach it to the interface.
     * Stub构造函数，在SumService的onBind()时实例化并作为IBinder返回给client
     */
    public Stub() {
      //表示将Stub实例绑定为ISumServiceInterface的本地实现，此后，queryLocalInterface(DESCRIPTOR)将返回此本地实现，而不是null
      this.attachInterface(this, DESCRIPTOR);
    }

    /**
     * Cast an IBinder object into an com.example.server.ISumServiceInterface interface,
     * generating a proxy if needed.
     * 这个方法在client端调用，用于将SumService返回的IBinder转化成ISumServiceInterface实例，分两种情况：
     * 1.client有ISumServiceInterface的本地对象，那就直接返回，也就不需要IPC了
     * 2.本例中Stub构造函数是在Server端SumService的onBind()时调用的，client端没有本地对象，
     * 所以需要生成并返回一个Proxy，即远程对象，然后，远程对象和本地对象通过transact方法通信（由Binder驱动实现）
     */
    public static com.example.server.ISumServiceInterface asInterface(android.os.IBinder obj) {
      if ((obj == null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      //判断是否有本地实现，有，则返回本地对象，不需要IPC
      if (((iin != null) && (iin instanceof com.example.server.ISumServiceInterface))) {
        return ((com.example.server.ISumServiceInterface) iin);
      }
      //没有，则生成并返回Proxy，即远程对象，然后，远程对象和本地对象通过transact方法通信（由Binder驱动实现）
      return new com.example.server.ISumServiceInterface.Stub.Proxy(obj);
    }

    @Override
    public android.os.IBinder asBinder() {
      return this;
    }

    /**
     * 这是本地对象接收数据的方法，当远程对象发起请求后，经过Binder驱动的封装处理，最终会调到server端的这个方法
     *
     * @param code  server端通过code来确定client端请求的目标方法，比如TRANSACTION_sum表示调用client端希望调用server端的sum方法
     * @param data  方法参数的封装，比如，data.readInt()得到参数a，再次调用data.readInt()得到参数b
     * @param reply 结果返回的地方，比如，sum方法得到a+b=100，就将100写入replay，replay通过Binder驱动的传送，返回给正在挂起等待结果的client端
     * @param flags 一般没什么卵用
     * @return
     * @throws android.os.RemoteException
     */
    @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) {
        //client希望调用sum方法
        case TRANSACTION_sum: {
          data.enforceInterface(descriptor);
          int _arg0;
          _arg0 = data.readInt(); //读取参数a
          int _arg1;
          _arg1 = data.readInt(); //读取参数b
          int _result = this.sum(_arg0, _arg1); //调用本地对象的sum方法，这个this很明白了吧，就是Server端在SumService的onBind()时实例化的那个Stub
          reply.writeNoException();
          reply.writeInt(_result); //结果写入reply，经Binder驱动传送给正在挂起等待的client
          return true;
        }
      }
      return true;
    }

    //Proxy是远程对象，通过transact向Binder驱动发送数据，并最终通过onTransact发送给Server端
    private static class Proxy implements com.example.server.ISumServiceInterface {
      private android.os.IBinder mRemote;

      /**
       * Proxy构造函数，client端调用
       *
       * @param remote 指明是哪个Binder的代理，这里的remote是Server端SumServcie的onBind()方法返回的IBinder，即Server端的Stub
       * @return
       */
      Proxy(android.os.IBinder remote) {
        mRemote = remote;
      }

      @Override
      public android.os.IBinder asBinder() {
        return mRemote;
      }

      public java.lang.String getInterfaceDescriptor() {
        return DESCRIPTOR;
      }

      @Override
      //client端调用远程对象的sum方法，最终会调到server端的sum方法
      public int sum(int a, int b) throws android.os.RemoteException {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        int _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR); //指明向哪个Binder请求服务
          _data.writeInt(a);  //写入参数a
          _data.writeInt(b);  //写入参数b
          boolean _status = mRemote.transact(Stub.TRANSACTION_sum, _data, _reply, 0); //通过transact向server端发起TRANSACTION_sum请求，即sum方法
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().sum(a, b);
          }
          _reply.readException();
          _result = _reply.readInt(); //读取server端返回的结果，至此，一个完整的IPC通信结束。
        } finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }

      public static com.example.server.ISumServiceInterface sDefaultImpl;
    }

    static final int TRANSACTION_basicTypes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_sum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
  }
}