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();
    }
}