RxJava實現倒計時並提供回調和銷燬方法

RxJava庫中有很多好用的方法，今天我們來使用interval實現倒計時的功能。
首先，爲了讓倒計時能夠跟隨頁面的生命週期，我們的類首先得集成LifecycleObserver，並新增一個方法，如下：

public class CountDownManager implements LifecycleObserver {

	@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    	public void destory() {
        	cancelCallback(); // 該方法是取消倒計時
    	}
}

其次，爲了能夠讓外部輕鬆控制後續邏輯，我還提供了一個callback，如下：

public class CountDownManager implements LifecycleObserver {
	// 負責將倒計時執行完或者成功後回調到使用者的地方
	private Callback callback;
	
    public void setCallback(Callback callback) {
        this.callback = callback;
    }

    public interface Callback {
        void onNext(Long time);
        void onComplete();
    }
}

第三，就是我們的核心代碼

public class CountDownManager implements LifecycleObserver {

	@SuppressLint("CheckResult")
    public CountDownManager startCountDown(@Nullable final int time) {
        disposableObserver = Observable.interval(1, TimeUnit.SECONDS)
                .take(time + 1)
                .map(new Function<Long, Long>() {
                    @Override
                    public Long apply(Long aLong) throws Exception {
                        return time - aLong;
                    }
                })
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(new DisposableObserver<Long>() {
                    @Override
                    public void onNext(Long aLong) {
                        if (callback != null) {
                            callback.onNext(aLong);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        if (callback != null) {
                            callback.onComplete();
                        }
                    }
                });
        return this;
    }
}

完整代碼：

public class CountDownManager implements LifecycleObserver {
    DisposableObserver disposableObserver;


    public CountDownManager() {
    }

    private static class Holder {
        private static final CountDownManager manager = new CountDownManager();
    }

    public static CountDownManager getInstance() {
        return Holder.manager;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void destory() {
        cancelCallback();
    }

    @SuppressLint("CheckResult")
    public CountDownManager startCountDown(@Nullable final int time) {
        disposableObserver = Observable.interval(1, TimeUnit.SECONDS)
                .take(time + 1)
                .map(new Function<Long, Long>() {
                    @Override
                    public Long apply(Long aLong) throws Exception {
                        return time - aLong;
                    }
                })
                .subscribeOn(Schedulers.computation())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(new DisposableObserver<Long>() {
                    @Override
                    public void onNext(Long aLong) {
                        if (callback != null) {
                            callback.onNext(aLong);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        if (callback != null) {
                            callback.onComplete();
                        }
                    }
                });
        return this;
    }

    private Callback callback;

    public void setCallback(Callback callback) {
        this.callback = callback;
    }

    public interface Callback {
        void onNext(Long time);
        void onComplete();
    }


    private void cancelCallback() {
        if (null != disposableObserver && !disposableObserver.isDisposed()) {
            disposableObserver.dispose();
        }
    }

    public boolean isCountdowning() {
        if (null == disposableObserver) {
            return false;
        }
        return !disposableObserver.isDisposed();
    }
}