万物RxJava(1)：封装高德地图API

自从去年开始接触RxJava,深深的被rxjava的设计吸引，粗略的阅读了RxJava1的源码之后，感触颇深，今年年初项目更是转用了RxJava2，对RxJava这种函数式编程更加感兴趣，不过本文的重点不在于源码解析，如果想看源码解析，可以出门到这里–>:zxt0601
如果你上文已经看完了，那么我们不难发现，其实RxJava本身是观察者模式，通过Observable订阅者subscribe方法订阅observer观察者，我们首先看一下Observable中的create方法：

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
       ObjectHelper.requireNonNull(source, "source is null");
       return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
   }

首先我们先看ObservableOnSubscribe参数，这是一个接口，内部实现也很简单：

public interface ObservableOnSubscribe<T> {
    /**
     * Called for each Observer that subscribes.
     * @param e the safe emitter instance, never null
     * @throws Exception on error
     */
    void subscribe(@NonNull ObservableEmitter<T> e) throws Exception;
}

而ObservableEmitter也是一个接口类，而他的作用就比较明显了，我们这里主要看一个ObservableEmitter的父类Emitter：

public interface Emitter<T> {
    /**
     * Signal a normal value.
     * @param value the value to signal, not null
     */
    void onNext(@NonNull T value);
    /**
     * Signal a Throwable exception.
     * @param error the Throwable to signal, not null
     */
    void onError(@NonNull Throwable error);
    /**
     * Signal a completion.
     */
    void onComplete();
}

到这里可能很多人会一头雾水，摸不着头脑，接下来我们找到ObservableCreate这个类中，就能很直观的看到其调用关系：

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);
        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

我们知道Observable在进行subscribe的时候真正内部调用的是抽象方法subscribeActual，这里我们很清晰的看到 observer.onSubscribe(parent)与source.subscribe(parent)两个关键的方法，前者是observer是否disposed，而后者则是实现了ObservableOnSubscribe接口的方法，当我们调用subscribe，便会调用这两个方法，那么我们回过头来看CreateEmitter，这个类内部实现了ObservableEmitter与Disposable两个接口，对于我们来说比较有用的可能就是以下的代码–>

final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
    this.observer = observer;
}
@Override
public void onNext(T t) {
    if (t == null) {
        onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
        return;
    }
    i
    f (!isDisposed()) {
        observer.onNext(t);
    }
}
@Override
public void onError(Throwable t) {
    if (!tryOnError(t)) {
        RxJavaPlugins.onError(t);
    }
}
@Override
public boolean tryOnError(Throwable t) {
    if (t == null) {
        t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
    }
    if (!isDisposed()) {
        try {
            observer.onError(t);
        } finally {
            dispose();
        }
        return true;
    }
    return false;
}
@Override
public void onComplete() {
    if (!isDisposed()) {
        try {
            observer.onComplete();
        } finally {
            dispose();
        }
    }
}
@Override
public void setDisposable(Disposable d) {
    DisposableHelper.set(this, d);
}
@Override
public void setCancellable(Cancellable c) {
    setDisposable(new CancellableDisposable(c));
}
@Override
public void dispose() {
    DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
    return DisposableHelper.isDisposed(get());
}

看到这里各位看官大佬可能就比较明白了，当我们调用source.subscribe(parent)内部parent接口的各个方法时，其实最终还是调用了observer的的方法。
到这里之后，其实不难发现，如果我们想要对第三方的api进行封装，完成rxjava式的封装，也是轻而易举的。今天首先我们先尝试对高德地图的Api进行封装，首先这里是demo地址–>github
首先是高德官方定位的demo，请往这里看–>高德定位
我们通过demo分析，我们最终需要调用的是AMapLocation对象，而AMapLocation对象是在接口AMapLocationListener中进行调用，那么我们首先定义一个Observable如下：

public class LocationObservable extends Observable<AMapLocation> {
    private final  AMapLocationClient aMapLocationClient;
    public LocationObservable(AMapLocationClient aMapLocationClient) {
        this.aMapLocationClient = aMapLocationClient;
    }
    @Override
    protected void subscribeActual(Observer<? super AMapLocation> observer) {
        AMapCallBack callBack=new AMapCallBack(aMapLocationClient,observer);
        aMapLocationClient.setLocationListener(callBack);
        observer.onSubscribe(callBack);
        aMapLocationClient.startLocation();
    }
 }

这里基本就是对ObservableCreate类的改造，通过AMapLocationClient.setLocationListener进行注册监听，而AMapCallBack中对observer进行onNext、onComplete、onError的方法调用：

private static final class AMapCallBack implements AMapLocationListener, Disposable {
      private boolean isDisposed = false;
      private final AMapLocationClient aMapLocationClient;
      private final Observer<? super AMapLocation> observer;
      public AMapCallBack(AMapLocationClient aMapLocationClient, Observer<? super AMapLocation> observer) {
          this.aMapLocationClient = aMapLocationClient;
          this.observer = observer;
      }
      @Override
      public void onLocationChanged(AMapLocation aMapLocation) {
          try {
              if (aMapLocation != null) {
                  if (aMapLocation.getErrorCode() == 0) {
                      observer.onNext(aMapLocation);
                      if(isDisposed){
                          observer.onComplete();
                      }
                  }else {
                      try {
                          observer.onError(new AMapLocationException(aMapLocation.getErrorCode(),aMapLocation.getErrorInfo()));
                      } catch (Throwable inner) {
                          Exceptions.throwIfFatal(inner);
                          RxJavaPlugins.onError(new CompositeException(new AMapLocationException(aMapLocation.getErrorCode(),aMapLocation.getErrorInfo()), inner));
                      }
                  }
              }
          }catch (Throwable t){
              if(isDisposed){
                  RxJavaPlugins.onError(t);
              }else {
                  try {
                      observer.onError(t);
                  } catch (Throwable inner) {
                      Exceptions.throwIfFatal(inner);
                      RxJavaPlugins.onError(new CompositeException(t, inner));
                  }
              }
          }
      }
      @Override
      public void dispose() {
          aMapLocationClient.onDestroy();
          isDisposed = true;
      }
      @Override
      public boolean isDisposed() {
          return isDisposed;
      }
  }

这样我们就完成了对高德定位LocationObservable的封装，那么我们该如何调用呢，首先我们需要一个外观类，命名为AMapRxHelper，然后对需求进行分析，因为高德sdk很多处地方都会用到applicationContext，如果我们每次调用都进行传参，会比较麻烦，所以我们通过全局初始化applicationContext，在application中调用。

private static Application app;
    public static void init(Application application) {
        app = application;
    }

而定位所需要的AMapLocationClient需要很多的初始化方法，我们应交由调用者自己实现，那么该怎么办呢，我们不妨参照RxJava中map操作符的实现，通过一个transfer的接口实现：

   public static Observable<AMapLocation> createAMapLocation(final LocationSettingsListener listener) {
       AMapLocationClient client = new AMapLocationClient(app);
       return Observable.just(client)
               .flatMap(new Function<AMapLocationClient, ObservableSource<AMapLocation>>() {
                   @Override
                   public ObservableSource<AMapLocation> apply(@NonNull AMapLocationClient client) throws Exception {
                       if (listener != null) {
                           listener.locationOptions(client);
                       }
                       return new LocationObservable(client);
                   }
               });
   }
public interface LocationSettingsListener {
       void locationOptions(AMapLocationClient client);
   }

这样的话我们的定位封装就已经完成了，我们在代码中实验一波，activity代码如下：

AMapRxHelper.createAMapLocation(new AMapRxHelper.LocationSettingsListener() {
           @Override
           public void locationOptions(AMapLocationClient client) {
               AMapLocationClientOption mLocationOption = new AMapLocationClientOption();
               mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
               mLocationOption.setOnceLocation(true);
               mLocationOption.setOnceLocationLatest(true);
               client.setLocationOption(mLocationOption);
           }
       }).subscribe(new Consumer<AMapLocation>() {
                   @Override
                   public void accept(AMapLocation aMapLocation) throws Exception {
                       Toast.makeText(MainActivity.this,aMapLocation.toStr(),Toast.LENGTH_SHORT).show();
                   }
               }, new Consumer<Throwable>() {
                   @Override
                   public void accept(Throwable throwable) throws Exception {
                       Toast.makeText(MainActivity.this,throwable.getMessage(),Toast.LENGTH_SHORT).show();
                   }
               });

这样写下来是不是要比高德原生的api更加舒服而且函数式呢？当然这只是其中一个例子，在源码的demo中还分别实现了poi搜索，输入关键字搜索，绑定EditText的关键字搜索，有兴趣的小伙伴可以去看下，顺便能给个star就更好了~