Rxjava2在Android中的模版栗子

最新推荐文章于 2022-06-28 17:24:13 发布

Flutter鸿蒙梁典典学院

最新推荐文章于 2022-06-28 17:24:13 发布

阅读量141

点赞数

文章标签： Rxjava

本文链接：https://blog.csdn.net/wds1181977/article/details/88840139

版权

Android切换UI线程

        Observable.create(new ObservableOnSubscribe<Boolean>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Boolean> emitter) throws Exception {
                try {
               //TODO   dosomething
             
                    emitter.onNext(true);
                } catch (Exception e) {
                    e.printStackTrace();
                    emitter.onComplete();
                }
            }

        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Boolean>() {

                    @Override
                    public void onSubscribe(@NonNull Disposable d) {

                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
                        e.printStackTrace();


                    }

                    @Override
                    public void onComplete() {


                    }


                    @Override
                    public void onNext(@NonNull Boolean aBoolean) {
                        if (aBoolean) {
                        //TODO   dosomething
                        } else {
                        }
                    }
                });

//或者可以这样
     Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                      //TODO   dosomething
            }
        }).compose(RxUtil.<String>io_main()).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {

            }
        });



/**
 * <p>描述：线程调度工具</p>
 * 作者： zhouyou<br>
 * 日期： 2017/5/15 17:12 <br>
 * 版本： v1.0<br>
 */
public class RxUtil {

    public static <T> ObservableTransformer<T, T> io_main() {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(@NonNull Observable<T> upstream) {
                return upstream
                        .subscribeOn(Schedulers.io())
                        .unsubscribeOn(Schedulers.io())
                        .doOnSubscribe(new Consumer<Disposable>() {
                            @Override
                            public void accept(@NonNull Disposable disposable) throws Exception {
                                HttpLog.i("+++doOnSubscribe+++" + disposable.isDisposed());
                            }
                        })
                        .doFinally(new Action() {
                            @Override
                            public void run() throws Exception {
                                HttpLog.i("+++doFinally+++");
                            }
                        })
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

    public static <T> ObservableTransformer<ApiResult<T>, T> _io_main() {
        return new ObservableTransformer<ApiResult<T>, T>() {
            @Override
            public ObservableSource<T> apply(@NonNull Observable<ApiResult<T>> upstream) {
                return upstream
                        .subscribeOn(Schedulers.io())
                        .unsubscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .map(new HandleFuc<T>())
                        .doOnSubscribe(new Consumer<Disposable>() {
                            @Override
                            public void accept(@NonNull Disposable disposable) throws Exception {
                                HttpLog.i("+++doOnSubscribe+++" + disposable.isDisposed());
                            }
                        })
                        .doFinally(new Action() {
                            @Override
                            public void run() throws Exception {
                                HttpLog.i("+++doFinally+++");
                            }
                        })
                        .onErrorResumeNext(new HttpResponseFunc<T>());
            }
        };
    }


    public static <T> ObservableTransformer<ApiResult<T>, T> _main() {
        return new ObservableTransformer<ApiResult<T>, T>() {
            @Override
            public ObservableSource<T> apply(@NonNull Observable<ApiResult<T>> upstream) {
                return upstream
                        //.observeOn(AndroidSchedulers.mainThread())
                        .map(new HandleFuc<T>())
                        .doOnSubscribe(new Consumer<Disposable>() {
                            @Override
                            public void accept(@NonNull Disposable disposable) throws Exception {
                                HttpLog.i("+++doOnSubscribe+++" + disposable.isDisposed());
                            }
                        })
                        .doFinally(new Action() {
                            @Override
                            public void run() throws Exception {
                                HttpLog.i("+++doFinally+++");
                            }
                        })
                        .onErrorResumeNext(new HttpResponseFunc<T>());
            }
        };
    }

延时执行

    private CompositeDisposable compositeDisposable; 

  public void addDisposable(Disposable disposable) {
        if (compositeDisposable == null) {
            compositeDisposable = new CompositeDisposable();
        }
        compositeDisposable.add(disposable);
    }

    public void dispose() {
        if (compositeDisposable != null && !compositeDisposable.isDisposed()) {
            compositeDisposable.dispose();
        }

    }
    ```
//防止过快点击

  addDisposable(RxView.clicks(right_text_ll)
            .throttleFirst(500, TimeUnit.MILLISECONDS)
            .subscribe(o -> {
                if (isSloting) {
                    slotingMsg();
                    return;
                }
                startActivity(new Intent(SlotMachineActivity.this, SlotRecordActivity.class));
            }));


 //延迟2秒钟

    addDisposable(Observable
            .just(1)
            .delay(2, TimeUnit.SECONDS)  //延迟2秒钟，然后在发射数据
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    startActivity(new Intent(cnt, MonopolyActivity.class));
                    finish();
                }
            }));


定时任务

//定时2秒调用一次

disposable = Flowable.interval(5, TimeUnit.SECONDS)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                                Log.e("------>",(aLong++)+"");
                }
            });

    addDisposable(disposable);

输出日志：

09-22 03:13:36.785 4434-4434/jy.com.rxjava2 E/------>: 0
09-22 03:13:38.785 4434-4434/jy.com.rxjava2 E/------>: 1
09-22 03:13:40.785 4434-4434/jy.com.rxjava2 E/------>: 2
09-22 03:13:42.785 4434-4434/jy.com.rxjava2 E/------>: 3
09-22 03:13:44.785 4434-4434/jy.com.rxjava2 E/------>: 4
09-22 03:13:46.785 4434-4434/jy.com.rxjava2 E/------>: 5

带有延迟的定时任务；如下，先延迟 10秒，在执行2s定时任务

public static void interval2(final TextView textView) {
Log.e(">", “start”);
Flowable.interval(10, 2, TimeUnit.SECONDS)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
Log.e(">",(aLong++)+"");
}
});
}

输出日志：

09-22 05:00:32.965 11640-11640/jy.com.rxjava2 E/>: start
09-22 05:00:43.015 11640-11640/jy.com.rxjava2 E/>: 0
09-22 05:00:45.015 11640-11640/jy.com.rxjava2 E/>: 1
09-22 05:00:47.015 11640-11640/jy.com.rxjava2 E/>: 2
09-22 05:00:49.015 11640-11640/jy.com.rxjava2 E/>: 3
09-22 05:00:51.015 11640-11640/jy.com.rxjava2 E/>: 4
09-22 05:00:53.015 11640-11640/jy.com.rxjava2 E/======>: 5



倒计时

    //从0开始发射60个数字为：0-60依次输出，延时0s执行，每1s发射一次。
    mDisposable = Flowable.intervalRange(1, 60, 0, 1, TimeUnit.SECONDS)
            .observeOn(AndroidSchedulers.mainThread())
            .doOnNext(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    String text = MAX_COUNT - aLong + "s";
                    sendCodeText.setText(text);
                    sendCodeText.setTextColor(getResources().getColor(R.color.gray_low));
                }
            })
            .doOnComplete(new Action() {
                @Override
                public void run() throws Exception {
                    //倒计时完毕置为可点击状态
                    sendCode.setEnabled(true);
                    sendCode.setBackground(getResources().getDrawable(R.drawable.shape_phone_text_select));
                    sendCodeText.setText(getString(R.string.string_phone_verification_resend));
                    sendCodeText.setTextColor(getResources().getColor(R.color.yellow_end));

                }
            })
            .subscribe();


}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (mDisposable != null) {
        mDisposable.dispose();
    }
}


flatMap
应用场景：一个接口调用时依赖另一个接口的返回值，如一个接口调用成功后才调用第二个接口或者第二个接口需要第一个接口的返回值作为参数调用

 ServerApi.getEosChainInfo(params.activity)
     .flatMap(new Function<Response<EosChainInfoModel>, Observable<String>>() {
                @Override
                public Observable<String> apply(Response<EosChainInfoModel> response) throws Exception {
                    if (response.isCode() && response.getData() != null) {
                        return signMessage(response.getData(), params);
                    } else {
                        if (!TextUtils.isEmpty(response.getMsg())) {
                            ToastUtils.show(response.getMsg());
                        }
                        return Observable.empty();
                    }

                }
     }).flatMap(new Function<String, Observable<Response<EosTxInfo>>>() {
        @Override
        public Observable<Response<EosTxInfo>> apply(String packJson) throws Exception {
            if (packJson == null) {
                return Observable.empty();
            } else {
                return ServerApi.pushTransaction(params.activity, packJson);
            }
        }
    }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<Response<EosTxInfo>>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                   params.ui.showProgress("","");
                }

                @Override
                public void onNext(@NonNull Response<EosTxInfo> response) {
                    if (response.isCode() && response.getData() != null) {

                      //TODO  Do something

                    } else {
                        String msg = response.getMsg();
                        if (TextUtils.isEmpty(msg)) {
                            msg = params.activity.getString(R.string.setting_get_eos_node_erro);
                        }
                        if (params.ui.isActive())

                            DialogController.getInstance().showErrorDialog(params.activity,     params.activity.getString(R.string.string_eos_transfer_push_fail), msg);
                    }

                    params.wipe();


                }


                @Override
                public void onError(@NonNull Throwable e) {
                    e.printStackTrace();
                    params.ui.dismissProgress();


                }

                @Override
                public void onComplete() {
                    params.ui.dismissProgress();

                }
            });


}

//签名后返回签名String
private Observable signMessage(EosChainInfoModel infoModel, EosTransferParams params) {
return Observable.just(1)
.map(i -> {
String pockJson = null;
try {
if (params.tx_form == 1) {
pockJson = signTransferMessage(infoModel, params);
} else if (params.tx_form == 2) {
pockJson = createAccountAndSign(infoModel, params);
} else if (params.tx_form == 3) {
pockJson = doSign(infoModel, params);
}
} catch (Exception e) {
e.printStackTrace();
}
return pockJson;
});
}

flatMap栗子2

ServerApi.getInstance().getSlotCount(getContext())
.flatMap(new Function<MonResponse<List>, Observable<MonResponse>>() {
@Override
public Observable<MonResponse> apply(MonResponse<List> response) throws Exception {
if (CommonParametersUtils.checkMonResponse(getContext(), response)) {
slotCountList = response.getData();
if (response == null || slotCountList == null || slotCountList.size() == 0) {
slotMaxCount = 0;
isCanSlot = false;
return Observable.empty();
}
isCanSlot = true;
slotMaxCount = slotCountList.size();
landcode = slotCountList.get(0).getLandCode();
zoneId = slotCountList.get(0).getZoneId();
try {
if (!mediaPlayer.isPlaying() && isCanPlay) {
mediaPlayer.start();
}
} catch (Exception e) {

                        }
                        spin.setEnabled(false);
                        spin.setImageResource(R.mipmap.icon_slot_pin_select_cn);
                        interval();

                        return ServerApi.getInstance().startSlot(getContext(), landcode, zoneId);
                    } else {
                        slotMaxCount = 0;
                        isCanSlot = false;
                        if (!TextUtils.isEmpty(response.getMsg())) {
                            ToastUtils.show(response.getMsg());
                        }
                        return Observable.empty();
                    }

                }
            }).flatMap(new Function<MonResponse<String>, Observable<MonResponse<SlotResultModel>>>() {
        @Override
        public Observable<MonResponse<SlotResultModel>> apply(MonResponse<String> response) throws Exception {
            if (!CommonParametersUtils.checkMonResponse(cnt, response)) {
                isSlotFail = true;
                return Observable.empty();
            } else {
                return ServerApi.getInstance().getSlotCode(getContext(), landcode, zoneId);
            }
        }
    }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new BaseSubscriber<MonResponse<SlotResultModel>>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                    LogUtil.d("wds", "onSubscribe");
                    addDisposable(d);
                }

                @Override
                public void onNext(@NonNull MonResponse<SlotResultModel> response) {
                    try {
                        if (CommonParametersUtils.checkMonResponse(cnt, response) || response.getData() == null) {
                            int a, b, c;
                            slotResultModel = response.getData();
                            SlotResultModel.MapBean slotList = response.getData().getMap();
                            a = findCode(slotList.getSlotA());
                            b = findCode(slotList.getSlotB());
                            c = findCode(slotList.getSlotC());

                            doneScrool(a, b, c, false);
                        } else {
                            scroolError();
                            slotFail();
                        }


                    } catch (Exception e) {
                        scroolError();
                        slotFail();

                    }

                }


                @Override
                public void onError(ApiException e) {
                    e.printStackTrace();
                    scroolError();
                    XToastUtils.showRoundRectToast(e.getMessage());
                    LogUtil.d("wds", "onError");
                }

                @Override
                public void onComplete() {
                    LogUtil.d("wds", "onComplete");
                    if (!isCanSlot) {
                        if (SP.get(Constant.MON_HASE_BEEN_BUY, false)) {
                            XToastUtils.showRoundRectToast(getString(R.string.string_monopoly_slot_msg2));
                        } else {
                            XToastUtils.showRoundRectToast(getString(R.string.string_monopoly_slot_msg1));

                        }

                        doneScrool(0, 1, 2, true);
                    }
                    if (isSlotFail) {
                        slotFail();
                        scroolError();
                        isSloting = false;
                    }
                    isSlotFail = false;
                }
            });

}

Flutter鸿蒙梁典典学院

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Rxjava2在Android中的模版栗子

Observable.create(new ObservableOnSubscribe<Boolean>() { @Override public void subscribe(@NonNull ObservableEmitter<Boolean> emitter) throws Exception { ...
复制链接

扫一扫