本文介绍如何使用RxJava对高德地图API进行封装，通过创建自定义的Observable来简化位置定位功能，并提供了一个易于使用的API。文章还展示了如何通过观察者模式实现错误处理和生命周期管理。
本文优快云地址：csdn
自从去年开始接触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就更好了~
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
