萬物RxJava(1)：封裝高德地圖API

時間 2019-11-22

標籤萬物 rxjava 封裝地圖 api 欄目 Java 简体版

原文原文鏈接

本文CSDN地址：csdn
自從去年開始接觸RxJava,深深的被rxjava的設計吸引，粗略的閱讀了RxJava1的源碼以後，感觸頗深，今年年初項目更是轉用了RxJava2，對RxJava這種函數式編程更加感興趣，不過本文的重點不在於源碼解析，若是想看源碼解析，能夠出門到這裏-->:zxt0601
若是你上文已經看完了，那麼咱們不難發現，其實RxJava自己是觀察者模式，經過Observable訂閱者subscribe方法訂閱observer觀察者，咱們首先看一下Observable中的create方法：java

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

首先咱們先看ObservableOnSubscribe參數，這是一個接口，內部實現也很簡單：android

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：git

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這個類中，就能很直觀的看到其調用關係：github

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以下：api

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的方法調用：bash

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中調用。app

private static Application app;

    public static void init(Application application) {
        app = application;
    }複製代碼

而定位所須要的AMapLocationClient須要不少的初始化方法，咱們應交由調用者本身實現，那麼該怎麼辦呢，咱們不妨參照RxJava中map操做符的實現，經過一個transfer的接口實現：ide

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就更好了~

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。