第七章 架构演化 - 爱奇艺 App

1. 声明提供服务的AIDL接口。
2. 创建Service，并在onBind方法返回实现Stub接口的Binder对象。
3. Client端通过intent bindService，并传入ServiceConnection对象，在onServiceConnected回调获取Service提供的Binder对象。本质上是将Binder对象（准确的说是代理对象）在进程间进行传递，而Service只是一个载体。在组件化的大业务背景下，模块间的通信接口数量可能很多，按这套方案会有很多问题。
4. 需要书写AIDL文件和Service类。
5. bindService是异步操作，需要写回调，与本地服务调用方式不统一。
6. 没用统一的Binder管理者，如何处理Binder Die，如何实现Binder缓存等问题。这样我们可以总结出一个好的组件化通信框架需要具备特点或者说要实现的诉求。

• 可不可以不写AIDL文件，用声明普通接口类的方式声明一个远程服务接口；可不可以不写Service，因为IPC通信的本质只是传递Binder而已。
• 我们希望像调用本地服务一样调用远程服务，避免回调地狱，即远程服务的获取是阻塞式调用。
• 如何管理各个进程提供的远程服务，保证高可用。

• 加入了跨进程通信的事件总线，即跨进程版EventBus。
• 加入了对增强进程稳定性的考量，通过为各个进程预先插桩Service，在获取远程服务时用前台UI组件（Activity/Fragment/View）绑定插桩的Service，最终提升后台服务进程优先级。
• 支持IPCCallback。
• 支持配置Binder分发管理中心（Dispatcher）所属进程。

//注册本地服务 第一个参数是接口class将来用作key，第二参数为接口实现类。
Andromeda.registerLocalService(ICheckApple.class, new CheckApple());
//使用本地服务
ICheckApple checkApple = Andromeda.getLocalService(ICheckApple.class);
------------------------------
//注册远程服务 第二个参数为IBinder类型，将来会在进程间传递
Andromeda.registerRemoteService(IBuyApple.class, BuyAppleImpl.getInstance());
//使用远程服务，传入UI组件(this)尝试提升远程服务进程的优先级
Andromeda.with(this).getRemoteService(IBuyApple.class);

# IDispatcher.aidl
interface IDispatcher {
//通过服务名称获取Binder包装类BinderBean
BinderBean getTargetBinder(String serviceCanonicalName);
//保留接口暂时为空实现
IBinder fetchTargetBinder(String uri);
//注册本地的RemoteTransfer
void registerRemoteTransfer(int pid,IBinder remoteTransferBinder);
//注册/反注册远程服务
void registerRemoteService(String serviceCanonicalName,String processName,IBinder
Binder);
void unregisterRemoteService(String serviceCanonicalName);
//发送事件
void publish(in Event event);
}

#主工程的build.gradle添加声明
dispatcher{
  process ":downloader"
}

#IRemoteTransfer.aidl
interface IRemoteTransfer {
  //① 将Dispatcher代理返回给RemoteTransfer
  oneway void registerDispatcher(IBinder dispatcherBinder);
  oneway void unregisterRemoteService(String serviceCanonicalName);
  oneway void notify(in Event event);
}
#IRemoteServiceTransfer.java
public interface IRemoteServiceTransfer {
  //②获取远程服务包装
  BinderBean getRemoteServiceBean(String serviceCanonicalName);
  //注册/反注册 远程服务
  void registerStubService(String serviceCanonicalName, IBinder stubBinder);
  void unregisterStubService(String serviceCanonicalName);
}

• ① 方法的调用方在Dispatcher中，这样就把Dispatcher的远程代理回传给了当前进程，之后注册远程服务就可以通过这个DispatcherProxy完成。
• ② 无论是注册还是获取远程服务，都是不能直接传递Binder的，因为Binder并没有实现Parcelable接口，因此需要将Binder包装在一个实现了Parcelable接口的类中传递，BinderBean就是其中一个包装类。

• 通过ContentProvider方式同步的获取Dispatcher的代理，这个ContentProvider属于Dispatcher进程，且通过插桩的方式织入manifeset文件。
• 获取远程服务时传递当前进程的Activity或Fragment，并bind预先插桩好的StubService，这个StubService属于远程服务所在进程。

# LocalServiceHub
public class LocalServiceHub implements ILocalServiceHub {
  private Map<String, Object> serviceMap = new ConcurrentHashMap<>();
  @Override
  public Object getLocalService(String module) {
    return serviceMap.get(module);
  }
  @Override
  public void registerService(String module, Object serviceImpl) {
    serviceMap.put(module, serviceImpl);
  }
  @Override
  public void unregisterService(String module) {
    serviceMap.remove(module);
  }
}

1. 客户端通过 registerRemoteService(String serviceCanonicalName, TstubBinder) 注册本进程可提供的远程服务，stubBinder即服务实现类。
2. 调用RemoteTransfer的registerStubService方法。
3. registerStubService内部先初始化DispatcherProxy，如果为空跳转3.1。
   1. 3.1-3.2 要实现服务的同步注册，本质上是同步获取DispatcherProxy，这是一次IPC通信，Andromeda的方案是在Dispatcher进程插桩一个ContentProvider，然后返回一个包含DispatcherProxy的Cursor给客户端进程，客户端解析Cursor拿到DispatcherProxy。
4. RemoteTransfer请求RemoteServiceTransfer帮忙完成真正的注册。
5. RemoteServiceTransfer通过第3步获取的DispatcherProxy，做一次IPC通信，将Binder传递到Dispatcher进程。
6. Dispatcher进程请求ServiceDispatcher类帮忙完成服务的注册，其实就是将Binder存储在一个Map当中。

# RemoteTransfer
private void initDispatchProxyLocked() {
  if (null == dispatcherProxy) {
    //从contentprovider取Binder
    IBinder dispatcherBinder = getIBinderFromProvider();
    if (null != dispatcherBinder) {
      //取出后asInterface创建远程代理对象
      dispatcherProxy = IDispatcher.Stub.asInterface(dispatcherBinder);
      registerCurrentTransfer();
    }
  }
...
}
private void registerCurrentTransfer() {
  //向Dispatcher注册自己这个进程的RemoteTransfer Binder
  dispatcherProxy.registerRemoteTransfer(android.os.Process.myPid(), this.asBinder());
  ...
}
private IBinder getIBinderFromProvider() {
  Cursor cursor = null;
  try {
    //通过contentprovider拿到cursor
    cursor = context.getContentResolver().query(getDispatcherProviderUri(),
    DispatcherProvider.PROJECTION_MAIN, null, null, null);
    if (cursor == null) {
      return null;
    }
    return DispatcherCursor.stripBinder(cursor);
  } finally {
    IOUtils.closeQuietly(cursor);
  }
}

public class DispatcherProvider extends ContentProvider {
  ...
  @Override
  public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    //将Binder封装到cursor中返回
    return DispatcherCursor.generateCursor(Dispatcher.getInstance().asBinder());
  }
}

1. Andromeda入口通过getRemoteService获取远程服务。2-4. 与提升进程优先级有关，我们暂且不讨论。
2. 向RemoteTransfer请求获取远程服务的包装bean。6-7. RemoteTransfer请求RemoteServiceTransfer帮忙先从本进程的缓存中查找目标Binder，如果找到直接返回。7.2. 如果没有命中缓存调用getAndSaveIBinder方法，通过方法名可知，获取后会将Binder缓存起来，这就是6-7步读取的缓存。
3. RemoteServiceTransfer通过DispatcherProxy发起IPC通信，请求远程服务Binder。9-10. Dispatcher请ServiceDispatcher帮忙查找进程中的服务注册表。
4. 回到客户端进程将Binder缓存。
5. 将Binder返回给调用方。同样图中蓝色的节点表示获取服务的进程，也就是Client进程，红色节点表示Dispatcher进程。至此，远程服务的注册与获取流程分析结束。

public class CommuStubService extends Service {
  public CommuStubService() {}
  @Override
  public IBinder onBind(Intent intent) {
    return new ICommuStub.Stub() {
      @Override
      public void commu(Bundle args) throws RemoteException {
        //do nothing now
      }
    };
  }
  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    //这样可以使Service所在进程的保活效果好一点
    return Service.START_STICKY;
  }
  public static class CommuStubService0 extends CommuStubService {}
  public static class CommuStubService1 extends CommuStubService {}
  public static class CommuStubService2 extends CommuStubService {}
  ...
  public static class CommuStubService14 extends CommuStubService {}
}

1. 蓝色表示Client进程，发起获取远程服务请求。
2. 浅灰色表示Server进程，它事先将服务注册到Dispatcher中。
3. 紫色表示Dispatcher进程，内部缓存了各个进程的服务的Binder对象。

public static IRemoteManager with(android.app.Fragment fragment) {
  return getRetriever().get(fragment);
}
public static IRemoteManager with(Fragment fragment) {
  return getRetriever().get(fragment);
}
public static IRemoteManager with(FragmentActivity fragmentActivity) {
  return getRetriever().get(fragmentActivity);
}
public static IRemoteManager with(Activity activity) {
  return getRetriever().get(activity);
}
public static IRemoteManager with(Context context) {
  return getRetriever().get(context);
}
public static IRemoteManager with(View view) {
  return getRetriever().get(view);
}

1. 具备生命周期的UI组件，最终是Activity或Fragment。
2. ApplicationContext。

//订阅事件，这里MainActivity实现了EventListener接口
Andromeda.subscribe(EventConstants.APPLE_EVENT,MainActivity.this);
//发布事件
Bundle bundle = new Bundle();
bundle.putString("Result", "gave u five apples!");
Andromeda.publish(new Event(EventConstants.APPLE_EVENT, bundle));

public class Event implements Parcelable {
  private String name;
  private Bundle data;
  ...
}

注意：这里的监听器常常使用的是Activity，但显然RemoteTransfer是属于进程生命周期的，因此保存监听器时需使用弱引用。

1. 将属于Dispatcher进程的DispatcherProvider和DispatcherService插入到manifest中（StubServiceGenerator）。
2. 将各个进程的预置StubService插入到manifest中（StubServiceGenerator）。
3. 将进程名与StubService的关系表插入到StubServiceMatcher类的map中（StubServiceMatchInjector）。

• 一是DispatcherProvider伪造的DispatcherCursor继承MatrixCursor，它通常用于返回几条固定的已知记录，不需要从数据库查询这种场景。
• 二是跨进程传递bundle对象时，如果bundle中存放了parcelable对象需要手动设置setClassLoader。

#DispatcherCursor
public static IBinder stripBinder(Cursor cursor) {
  if (null == cursor) {
    return null;
  }
  Bundle bundle = cursor.getExtras();
  //从cursor中取出bundle需要设置classLoader
  bundle.setClassLoader(BinderWrapper.class.getClassLoader());
  BinderWrapper BinderWrapper = bundle.getParcelable(KEY_Binder_WRAPPER);
  return null != BinderWrapper ? BinderWrapper.getBinder() : null;
}

• 服务需要手动注册，这个时机不好把握。最好能提供一个自动注册服务的开关，上层不需要关注服务的注册。
• 发送一次事件需要多次IPC调用效率低，有优化空间。
• 仍需要书写AIDL文件。