Binder Pool

从图中可知，每个aidl在Binder连接池中都有一个对应的Binder实例。在BinderPool中提供一个根据code查询对应Binder的query方法。

1. 服务端创建三个aidl文件

// ISecurityCenter.aidl
interface ISecurityCenter {
  String encrypt(String content);
  String decrypt(String password);
}

// ICompute.aidl
interface ICompute {
    int add(int a, int b);
}

// IBinderPool.aidl
interface IBinderPool {
   IBinder queryBinder(int binderCode);
}

2. 服务端实现对应Binder实例

public class SecurityCenterImpl extends ISecurityCenter.Stub {

  private static final char SECRET_CODE = '^';

  @Override public String encrypt(String content) throws RemoteException {
    char[] chars = content.toCharArray();
    for (int i = 0; i < chars.length; i++) {
      chars[i] ^= SECRET_CODE;
    }
    return new String(chars);
  }

  @Override public String decrypt(String password) throws RemoteException {
    return encrypt(password);
  }
}

public class ComputeImpl extends ICompute.Stub {
  @Override public int add(int a, int b) throws RemoteException {
    return a + b;
  }
}

public class BinderPool {
  public static final int BINDER_NONE = -1;
  public static final int BINDER_COMPUTE = 0;
  public static final int BINDER_SECURITY_CENTER = 1;

  private Context mContext;
  private IBinderPool mBinderPool;
  private static volatile BinderPool sInstance;
  private CountDownLatch mConnectBinderPoolCountDownLatch;
  //sync operation,Prevent the conflicts of binding.

  private ServiceConnection mBinderPoolConnection = new ServiceConnection() {
    @Override public void onServiceConnected(ComponentName name, IBinder service) {
      mBinderPool = IBinderPool.Stub.asInterface(service);
      try {
        mBinderPool.asBinder().linkToDeath(mBinderDeathRecipient, 0);//Prevent unexpected exit
      } catch (RemoteException e) {
        e.printStackTrace();
      }
      mConnectBinderPoolCountDownLatch.countDown();
    }

    @Override public void onServiceDisconnected(ComponentName name) {

    }
  };
  private IBinder.DeathRecipient mBinderDeathRecipient = new IBinder.DeathRecipient() {
    @Override public void binderDied() {
      Log.i("TAG", "binderDied: ");
      mBinderPool.asBinder().unlinkToDeath(mBinderDeathRecipient, 0);
      mBinderPool = null;
      connectBinderPoolService();
    }
  };
  private BinderPool(Context context) {
    mContext = context.getApplicationContext();
    connectBinderPoolService();//Begin conncect service
  }
  public static BinderPool getInsance(Context context) {
    if (sInstance == null) {
      synchronized (BinderPool.class) {
        if (sInstance == null) {
          sInstance = new BinderPool(context);
        }
      }
    }
    return sInstance;
  }
  private synchronized void connectBinderPoolService() {
    mConnectBinderPoolCountDownLatch = new CountDownLatch(1);//Only one client can bind service
    Intent service = new Intent(mContext, BinderPoolService.class);
    mContext.bindService(service, mBinderPoolConnection, Context.BIND_AUTO_CREATE);
    try {
      mConnectBinderPoolCountDownLatch.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  public IBinder queryBinder(int bindCode) {
    IBinder binder = null;
    if (mBinderPool != null) {
      try {
        binder = mBinderPool.queryBinder(bindCode);
      } catch (RemoteException e) {
        e.printStackTrace();
      }
    }
    return binder;
  }
  public static class BinderPoolImpl extends IBinderPool.Stub {
    public BinderPoolImpl() {
      super();
    }

    @Override public IBinder queryBinder(int binderCode) throws RemoteException {
      IBinder binder = null;
      switch (binderCode) {
        case BINDER_SECURITY_CENTER:
          binder = new SecurityCenterImpl();
          break;
        case BINDER_COMPUTE:
          binder = new ComputeImpl();
          break;
        default:
          break;
      }
      return binder;
    }
  }
}

3. 服务端返回Binder连接池

//Service
public class BinderPoolService extends Service {


  private Binder mBinderPool = new BinderPool.BinderPoolImpl();

  @Override
  public void onCreate() {
    Log.i("TAG", "service:onCreate: ");
    super.onCreate();
  }

  @Override
  public IBinder onBind(Intent intent) {
    Log.d("TAG", "onBind");
    return mBinderPool;
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
  }

}

4.客户端通过BinderPool获得对应Binder。再从Binder中获取已被服务器实现了的接口。

public class BinderPoolActivity extends AppCompatActivity {
  private ISecurityCenter mSecurityCenter;
  private ICompute mCompute;

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    new Thread(new Runnable() {

      @Override
      public void run() {
        doWork();
      }
    }).start();
  }

  private void doWork() {
    BinderPool binderPool = BinderPool.getInsance(BinderPoolActivity.this);
    IBinder securityBinder = binderPool
        .queryBinder(BinderPool.BINDER_SECURITY_CENTER);
    ;
    mSecurityCenter = (ISecurityCenter) SecurityCenterImpl
        .asInterface(securityBinder);//Get implemented interface
    Log.d("TAG", "visit ISecurityCenter");
    String msg = "helloworld-安卓";
    System.out.println("content:" + msg);
    try {
      String password = mSecurityCenter.encrypt(msg);
      System.out.println("encrypt:" + password);
      System.out.println("decrypt:" + mSecurityCenter.decrypt(password));
    } catch (RemoteException e) {
      e.printStackTrace();
    }

    Log.d("TAG", "visit ICompute");
    IBinder computeBinder = binderPool
        .queryBinder(BinderPool.BINDER_COMPUTE);
    ;
    mCompute = ComputeImpl.asInterface(computeBinder);
    try {
      System.out.println("3+5=" + mCompute.add(3, 5));
    } catch (RemoteException e) {
      e.printStackTrace();
    }
  }
}