Rxjava多场景操作集合

最新推荐文章于 2023-02-21 14:33:04 发布

Android小码家

最新推荐文章于 2023-02-21 14:33:04 发布

阅读量323

点赞数

分类专栏： Android 文章标签： Rxjava Retrofit

本文链接：https://blog.csdn.net/qq_20330595/article/details/117283041

版权

Android 专栏收录该内容

62 篇文章 2 订阅

订阅专栏

文章目录

串行

  /*获取 版本信息*/
    private fun toGetVersion() {
        val appvserison_ob = Observable.create(ObservableOnSubscribe<Int> {
            mGuideInterface?.getAppversion()
            it.onNext(1);
            it.onComplete();
        })/*.flatMap<String>(object : Function<Int, ObservableSource<String>> {
            override fun apply(result: Int): ObservableSource<String> {
                return Observable.create {
                    it.onNext("1 " + result);
                    it.onComplete();
                };
            }
        })*/

        val tempvserison_ob = Observable.create(ObservableOnSubscribe<Int> {
            mGuideInterface?.getTempversion()
            it.onNext(2);
            it.onComplete();
        })/*.flatMap<String>(object : Function<Int, ObservableSource<String>> {
            override fun apply(result: Int): ObservableSource<String> {
                return Observable.create {
                    it.onNext("2 " + result);
                    it.onComplete();
                };
            }
        })*/
        val imagevserison_ob = Observable.create(ObservableOnSubscribe<Int> {
            mGuideInterface?.getImageversion()
            it.onNext(3);
            it.onComplete();
        })/*.flatMap<String>(object : Function<Int, ObservableSource<String>> {
            override fun apply(result: Int): ObservableSource<String> {
                return Observable.create {
                    it.onNext("3 " + result);
                    it.onComplete();
                };
            }
        })*/
        /*设置 版本号*/
        Observable.concat<Int>(appvserison_ob, tempvserison_ob, imagevserison_ob)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Observer<Int> {
                override fun onComplete() {
                }

                override fun onSubscribe(d: Disposable) {
                }

                override fun onNext(result: Int) {
                    Logger.d(TAG, "result   " + result)
                }

                override fun onError(e: Throwable) {
                }

            })
    }

Observable.just("appversion")
.observeOn(AndroidSchedulers.mainThread())
 .map {
     var appversion = ""
     while (appversion.isBlank()) {
         Thread.sleep(250)
         appversion = mGuideInterface?.appversion ?: "未知"
     }
     binding.appVersion.text = String.format(getString(R.string.app_version_str), appversion)
 }
 .delay(250, TimeUnit.MILLISECONDS).observeOn(AndroidSchedulers.mainThread())
 .flatMap {
     Observable.just("tempversion")
         .map {
             var tempversion = ""
             while (tempversion.isBlank()) {
                 Thread.sleep(250)
                 tempversion = mGuideInterface?.tempversion ?: "未知"

             }
             binding.tempVersion.text =
                 String.format(getString(R.string.temp_version_str), tempversion)
         }
 }
 .delay(250, TimeUnit.MILLISECONDS).observeOn(AndroidSchedulers.mainThread())
 .flatMap {
     Observable.just("imageversion")
         .map {
             var imageversion = ""
             while (imageversion.isBlank()) {
                 Thread.sleep(250)
                 imageversion = mGuideInterface?.imageversion ?: "未知"
             }

             binding.imageVersion.text =
                 String.format(getString(R.string.image_version_str), imageversion)
         }
 }.observeOn(AndroidSchedulers.mainThread()).subscribe { initViews() }

串行线程切换

Observable.just(true).doOnSubscribe(disposable -> {
            ···    
			})
			   .subscribeOn(AndroidSchedulers.mainThread())
			   .observeOn(Schedulers.io())
			   .map(Boolean-> {
			      ···
			      return true;
			   })
			   .observeOn(AndroidSchedulers.mainThread())
			   .subscribe(success -> {
			      ···
			   });

串行多入参

Observable.fromIterable(msgs).subscribeOn(Schedulers.io()).flatMap(new Function<TIMMessage, Observable<Pair<Boolean, TIMMessage>>>() {
                    @Override
                    public Observable<Pair<Boolean, TIMMessage>> apply(TIMMessage timMessage) throws Exception {
                        SettingsSleepBody settingsSleepBody = new SettingsSleepBody(timMessage.getConversation().getPeer());
                        BaseResulty<IsTopResult> resultyStatus = 		Api.getService().chatDndOnOff(settingsSleepBody.getMap()).execute().body();
                        if (resultyStatus.getStatus() == Api.STATUS_SUCCESS) {
                            return Observable.just(new Pair<>(resultyStatus.getData().isTrue(), timMessage));
                        }
                        return Observable.just(new Pair<>(false, timMessage));
                    }
                }).observeOn(AndroidSchedulers.mainThread()).filter(new Predicate<Pair<Boolean, TIMMessage>>() {
                    @Override
                    public boolean test(Pair<Boolean, TIMMessage> pair) throws Exception {
                        ;//设置为1 免打扰
                        return !pair.first;
                    }
                }).subscribe(new Consumer<Pair<Boolean, TIMMessage>>() {
                    @Override
                    public void accept(Pair<Boolean, TIMMessage> pair) throws Exception {
                         
                    }
                });

多接口相同数据合并回调

final Map<String, String> parma = body.getMap();
        Observable.just(parma).flatMap(new Function<Map<String, String>, ObservableSource<BaseResulty<SystemMsgResultBody>>>() {

            @Override
            public ObservableSource<BaseResulty<SystemMsgResultBody>> apply(Map<String, String> map) throws Exception {
                Api.ProginnApiService service = Api.getService();
                return Observable.zip(Observable.just(service.system(map)), Observable.just(service.outsource_(map)), new BiFunction<BaseResulty<SystemMsgResultBody>, BaseResulty<SystemMsgResultBody>, BaseResulty<SystemMsgResultBody>>() {
                    @Override
                    public BaseResulty<SystemMsgResultBody> apply(
                            BaseResulty<SystemMsgResultBody> outdata,
                            BaseResulty<SystemMsgResultBody> sysdata) throws Exception {
                        List<SystemMsgResultBody.recordsMsgSystem> recordsMsgSystem = outdata.getData().getRecordsMsgSystem();
                        recordsMsgSystem.addAll(sysdata.getData().getRecordsMsgSystem());
                        Collections.sort(recordsMsgSystem);
                        return outdata;
                    }
                });
            }
        })
                .subscribeOn(Schedulers.newThread())
                .filter(new Predicate<BaseResulty<SystemMsgResultBody>>() {
                    @Override
                    public boolean test(BaseResulty<SystemMsgResultBody> systemMsgResultBodyBaseResulty) throws Exception {
                        return systemMsgResultBodyBaseResulty.getStatus() == 3;
                    }
                })
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(new DisposableObserver<BaseResulty<SystemMsgResultBody>>() {
                    @Override
                    public void onNext(BaseResulty<SystemMsgResultBody> systemMsgResultBodyBaseResulty) {
                        if (isRefresh) {
                            mAdapter.setContent(systemMsgResultBodyBaseResulty.getData().getRecordsMsgSystem());
                        } else {
                            mAdapter.addContent(systemMsgResultBodyBaseResulty.getData().getRecordsMsgSystem());
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        if (isRefresh) setRefreshing(false);
                        else setLoading(false);
                    }

                    @Override
                    public void onComplete() {
                        if (isRefresh) setRefreshing(false);
                        else setLoading(false);
                    }
                });

Completable 简单直接

  Completable.fromAction(() -> {
            new NormalDialog(mContext).setCustomTitle("提示")
                    .setMessage("开通会员即可" + tip)
                    .setRightButton("开通会员", new NormalDialog.Callback() {
                        @Override
                        public void onClick(Dialog dialog) {
                            WebViewActivity.startActivity(getContext(), VIP_DEVELOPER_INDEX, getString(R.string.vip_center), false, true);
                            dialog.dismiss();
                        }
                    })
                    .setLeftButton("取消", null).show();

        }).observeOn(AndroidSchedulers.mainThread()).subscribe();

经典

Observable.create((ObservableOnSubscribe<ArrayList<ApplyStatus>>) emitter -> {
           
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());

多接口分开处理同时回调

Observable.mergeArray(getCityData(), getProvinceData(), getSimpleData(),
                    getJobDirectionData(), getIndustryData(), getConfig(),
                    getUserInfo(), getDeveloperCertTypes(), getToken()).buffer(9);

observable.flatMap(new Function<List<Boolean>, ObservableSource<Boolean>>() {
            @Override
            public ObservableSource<Boolean> apply(@NonNull List<Boolean> booleen) throws Exception {
                boolean success = true;
                for (Boolean bool : booleen) {
                    if (!bool) {
                        success = false;
                        break;
                    }
                }
                return Observable.just(success);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribeWith(new DisposableObserver<Boolean>() {
            @Override
            public void onNext(@NonNull Boolean aBoolean) {
                if (aBoolean) {
                    onSyncSuccess();
                } else {
                    onSyncError();
                }
            }

            @Override
            public void onError(@NonNull Throwable e) {
                onSyncError();
            }

            @Override
            public void onComplete() {
                dispose();
            }
        });


private Observable<Boolean> getJobDirectionData() {
        return Observable.create(new ObservableOnSubscribe<Boolean>() {
            @Override
            public void subscribe(@NonNull final ObservableEmitter<Boolean> emitter) throws Exception {               
               emitter.onNext(true);
            }

           @Override
           public void failure(RetrofitError retrofitError) {
               emitter.onNext(false);
           }
       };
    }