io.reactivex.disposables.Disposable Java Examples

void disposeLoad(final ViewHolder holder) {
  //
  final ViewGroup parent =
      holder.itemView instanceof ViewGroup ? (ViewGroup) holder.itemView : null;
  if (parent != null) {
    for (int i = 0; i < parent.getChildCount(); i++) {
      final View childView = parent.getChildAt(i);
      if (childView instanceof SimpleDraweeView) {
        final Object tag = childView.getTag();
        if (tag instanceof Disposable) {
          final Disposable disposable = (Disposable) tag;
          if (!disposable.isDisposed()) {
            disposable.dispose();
          }
          childView.setTag(null);
        }
      }
    }
  }
}
 

@Override
public void refreshBookList(BookListType type, String tag, int start, int limited) {

    if (tag.equals("全本")){
        tag = "";
    }

    Disposable refreshDispo = getBookListSingle(type, tag, start, limited)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                    (beans)-> {
                        mView.finishRefresh(beans);
                        mView.complete();
                    }
                    ,
                    (e) ->{
                        mView.complete();
                        mView.showError();
                        LogUtils.e(e);
                    }
            );
    addDisposable(refreshDispo);
}
 

public MutableLiveData<GankIoDataBean> loadWelfareData() {
    final MutableLiveData<GankIoDataBean> data = new MutableLiveData<>();
    mModel.setData("Girl", "Girl",mPage, 20);
    mModel.getGankIoData(new RequestImpl() {
        @Override
        public void loadSuccess(Object object) {
            GankIoDataBean gankIoDataBean = (GankIoDataBean) object;
            handleImageList(gankIoDataBean);
            data.setValue(gankIoDataBean);
        }

        @Override
        public void loadFailed() {
            if (mPage > 1) {
                mPage--;
            }
            data.setValue(null);
        }

        @Override
        public void addSubscription(Disposable disposable) {
            addDisposable(disposable);
        }
    });
    return data;
}
 

public static <T> Observable<T> retryWhen(Observable<T> source, Function<Observable<Throwable>, Observable<?>> handler) {
    return Observable.<T>defer(() -> {
        PublishSubject<Throwable> errorSignal = PublishSubject.create();

        Observable<?> retrySignal = handler.apply(errorSignal);

        BehaviorSubject<Observable<T>> sources = BehaviorSubject.createDefault(source);

        Disposable d = retrySignal.map(v -> source)
                .subscribe(sources::onNext, sources::onError, sources::onComplete);

        return sources.concatMap(src -> {
            return src
                    .doOnComplete(() -> errorSignal.onComplete())
                    .onErrorResumeNext(e -> {
                errorSignal.onNext(e);
                return Observable.<T>empty();
            });
        }).doFinally(() -> d.dispose());
    });
}
 

public void onInputRecipientAddress(String address, CharSequence amountString) {
        BigDecimal amount = getAmountFromString(amountString);

        if (AdamantAddressValidateHelper.validate(address)) {
            getViewState().dropRecipientAddressError();
            getViewState().setRecipientName(address);
            this.companionId = address;

        } else {
//            getViewState().showRecipientAddressError(R.string.wrong_address);
            this.companionId = null;
        }

        Disposable subscribe = currentFacade
                .getFee()
                .subscribe(
                        fee -> calculate(amount, currentFacade.getBalance(), fee),
                        error -> LoggerHelper.e("amount", error.getMessage(), error)
                );
        subscriptions.add(subscribe);
    }
 

public void query() {
    getModel().queryForAllSync().subscribe(new Observer<List<City>>() {
        @Override
        public void onSubscribe(Disposable d) {
            getRxManager().add(d);
        }

        @Override
        public void onNext(List<City> data) {
            queryFinish(data);
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }

    });

}
 

private void loadTemplate() {
    Disposable disposable = Observable
            .fromCallable(() -> {
                SmsCodeRule template = EntityStoreManager.loadEntityFromFile(
                        EntityType.CODE_RULE_TEMPLATE, SmsCodeRule.class
                );
                if (template == null) {
                    template = new SmsCodeRule();
                }
                return template;
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(codeRule -> {
                mCodeRule = codeRule;
                mView.displayCodeRule(mCodeRule);
            });

    mCompositeDisposable.add(disposable);
}
 

public Disposable getWhatsNewIcons() {
    return Observable.fromArray(mView.getResources().getStringArray(R.array.whatsnew))
            .map(new Function<String, IconBean>() {
                @Override
                public IconBean apply(@NonNull String s) throws Exception {
                    IconBean bean = new IconBean();
                    bean.id = mView.getResources().getIdentifier(s, "drawable", BuildConfig.APPLICATION_ID);
                    bean.name = s;

                    return bean;
                }
            }).toList().subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<List<IconBean>>() {
                @Override
                public void accept(List<IconBean> list) throws Exception {
                    mView.onLoadData(list);
                }
            });
}
 

public void searchAndInsert() {
    Observable.create((ObservableOnSubscribe<String>) emitter -> emitter.onNext("Start"))
            .subscribe(new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(String s) {
                    if ("Start".equals(s)) {
                        UserDao.getInstance().createUser("Mike");
                    }
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onComplete() {

                }
            });
}
 

public void init() {
    if (threadArray != null) {
        threadArray.clear();
    } else {
        threadArray = new LongSparseArray<>();
    }

    Disposable sub = HistoryTableConnection.fetchHistory(true, 0, false)
            .compose(DatabaseUtils.applySingleSchedulers())
            .subscribe(historyList -> {
                for (History historyDbModel : historyList) {
                    final ThreadRegistryModel t = new ThreadRegistryModel(historyDbModel, Collections.emptyList());
                    final long i = historyDbModel.threadId;

                    Log.d(LOG_TAG, "[refresh] Adding bookmark to registry: size=" + historyDbModel.threadSize);

                    threadArray.append(i, t);
                }
            });
}
 

@Override
public void subscribe(ObservableEmitter<DocumentSnapshot> e) throws Exception {
    DocEventListener listener = new DocEventListener(e);
    ListenerRegistration registration = mDocumentReference.addSnapshotListener(listener);
    e.setDisposable(new Disposable() {
        boolean disposed = false;
        @Override
        public void dispose() {
            if (!isDisposed()) {
                registration.remove();
                listener.emitter = null;
                disposed = true;
            }
        }

        @Override
        public boolean isDisposed() {
            return disposed;
        }
    });
}
 

@Test
public void testAllObservable() {

    Observable.just(0, 1, 2, 3, 4, 0, 6, 0)
            .all(item -> item > 0)
            .subscribe(new SingleObserver<Boolean>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onSuccess(Boolean aBoolean) {
                    System.out.println("onNext: " + aBoolean);
                }

                @Override
                public void onError(Throwable e) {

                }
            });
}
 

private void single() {
    Single.just(1).subscribe(new SingleObserver<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.d(TAG, "onSubscribe: " + d.isDisposed());
        }

        @Override
        public void onSuccess(Integer integer) {
            Log.d(TAG, "onSuccess: " + integer);
        }

        @Override
        public void onError(Throwable e) {

        }
    });
}
 

private void refreshBookShelf(BookShelfBean bookShelfBean) {
    WebBookModel.getInstance().getChapterList(bookShelfBean)
            .subscribeOn(scheduler)
            .timeout(1, TimeUnit.MINUTES)
            .flatMap(this::saveBookToShelfO)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new SimpleObserver<BookShelfBean>() {

                @Override
                public void onSubscribe(Disposable d) {
                    loadingCount.incrementAndGet();
                    refreshingDisps.add(d);
                }

                @Override
                public void onNext(BookShelfBean value) {
                    whenRefreshNext(bookShelfBean, false);
                }

                @Override
                public void onError(Throwable e) {
                    whenRefreshNext(bookShelfBean, true);
                }
            });
}
 

/**
 * 倒计时
 *
 * @param view     倒计时所用到的view
 * @param second   倒计时时长  单位 秒
 * @param listener 倒计时回调
 * @param <T>
 * @return Disposable  返回 Disposable  在Activity的onDestroy方法中
 * disposable.dispose() 取消掉  防止内存泄漏
 * @see CountDownListener  回调接口
 */
public static <T extends View> Disposable countDown(final T view, @IntRange(from = 1) final int second, final CountDownListener<T> listener) {
	if (listener == null || second <= 0) return null;
	return Flowable.intervalRange(0, second + 1, 0, 1, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread())
			.doOnNext(new Consumer<Long>() {
				@Override
				public void accept(Long aLong) throws Exception {
					listener.onCountDownProgress(view, (int) (second - aLong));
				}
			}).doOnComplete(new Action() {
				@Override
				public void run() throws Exception {
					listener.onCountDownComplete(view);
				}
			}).doOnSubscribe(new Consumer<Subscription>() {
				@Override
				public void accept(Subscription subscription) throws Exception {
					listener.onBindCountDown(view);
				}
			}).subscribe();

}
 

@Override
public void bind(ViewActivity<PortfolioListData> activity) {
    super.bind(activity);
    disposable = new CompositeDisposable();

    Disposable subscribe = Observable.combineLatest(
            portfolioRepository.getPortfolioItems()
                    .toList()
                    .toObservable(),
            purchasesService.monitorPurchases(getActivity()),
            (items, hasPurchases) -> data.withItems(items).withSummaryActive(hasPurchases)
    )
            .subscribe(this::update, RxError::handler);

    disposable.addAll(
            subscribe
    );
}
 

@Override
public void onNext(final T t) {
    if (finished) {
        return;
    }
    queue.offer(t);
    final long waitTime;
    try {
        waitTime = timeout.apply(t);
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // we cancel upstream ourselves because the
        // error did not originate from source
        upstream.cancel();
        onError(e);
        return;
    }
    TimeoutAction<T> action = new TimeoutAction<T>(this, t);
    Disposable d = worker.schedule(action, waitTime, unit);
    DisposableHelper.set(scheduled, d);
    drain();
}
 

@Override public void onDeleteCheckPoint(int adapterPosition) {
  getCheckPointDataSource().deleteCheckPoint(allCheckPoints.get(adapterPosition))
      .subscribeOn(Schedulers.io())
      .observeOn(AndroidSchedulers.mainThread())
      .subscribeWith(new CompletableObserver() {
        @Override public void onSubscribe(Disposable d) {

        }

        @Override public void onComplete() {
          allCheckPoints.remove(adapterPosition);
          getView().removeMarker(adapterPosition);
          getView().notifyListAdapter();
        }

        @Override public void onError(Throwable e) {
          getView().showError("Delete Failed");
        }
      });
}
 

private void postUread(String boardName, long threadId, @NonNull UnreadCountUpdate callback) {
    HistoryTableConnection.fetchPost(boardName, threadId)
            .subscribeOn(Schedulers.computation())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new SingleObserver<History>() {
                @Override
                public void onSubscribe(Disposable d) {
                    // no op
                }

                @Override
                public void onSuccess(History history) {
                    callback.OnUnreadCountUpdate(history.unreadCount);
                }

                @Override
                public void onError(Throwable e) {
                    Log.e(LOG_TAG, "Error setting unread count badge", e);
                }
            });
}
 

@Override
public void getHotKey() {
    Observable<BaseResponse<List<HotKey>>> observable = dataManager.getHotKey();
    observable.observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io())
            .map(new Function<BaseResponse<List<HotKey>>, List<HotKey>>() {
                @Override
                public List<HotKey> apply(@NonNull BaseResponse<List<HotKey>> response)
                        throws Exception {
                    return response.getData();
                }
            }).subscribeWith(new Observer<List<HotKey>>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            disposable = d;
        }

        @Override
        public void onNext(@NonNull List<HotKey> hotKeys) {
            getView().showHotKey(hotKeys);
        }

        @Override
        public void onError(@NonNull Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    });
}
 

@Test
public void concurrentOneProducerOneConsumer() {
    ChatsStorage chatsStorage = new ChatsStorage();

    Flowable<AdamantBasicMessage> producer = provideProducer(chatsStorage);
    Flowable<Integer> consumer = provideConsumer(chatsStorage, CHAT_COUNT);

    Disposable producerSubscription = producer.subscribe();
    subscriptions.add(producerSubscription);

    Integer size = consumer.blockingFirst();

    Assert.assertEquals(CHAT_COUNT, (int) size);
}
 

private Observer<String> getObserver() {
    return new Observer<String>() {

        @Override
        public void onSubscribe(Disposable d) {
            Log.d(TAG, " onSubscribe : " + d.isDisposed());
        }

        @Override
        public void onNext(String value) {
            textView.append(" onNext : value : " + value);
            textView.append(AppConstant.LINE_SEPARATOR);
            Log.d(TAG, " onNext : value : " + value);
        }

        @Override
        public void onError(Throwable e) {
            textView.append(" onError : " + e.getMessage());
            textView.append(AppConstant.LINE_SEPARATOR);
            Log.d(TAG, " onError : " + e.getMessage());
        }

        @Override
        public void onComplete() {
            textView.append(" onComplete");
            textView.append(AppConstant.LINE_SEPARATOR);
            Log.d(TAG, " onComplete");
        }
    };
}
 

public void testGetInBackgroundWithIncludePointer() throws Exception {
  AVObject current = AVObject.createWithoutData("Student", currentObjectId);
  final AVObject target = new AVObject("Student");
  target.put("friend", current);
  target.save();
  AVQuery query = new AVQuery("Student");
  query.include("friend");
  query.getInBackground(target.getObjectId()).subscribe(new Observer<AVObject>() {
    @Override
    public void onSubscribe(Disposable disposable) {

    }

    @Override
    public void onNext(AVObject o) {
      AVObject friend = o.getAVObject("friend");
      testSucceed = "Automatic Tester".equals(friend.get("name"));
      latch.countDown();
    }

    @Override
    public void onError(Throwable throwable) {
      throwable.printStackTrace();
      latch.countDown();
    }

    @Override
    public void onComplete() {

    }
  });
  latch.await();
  target.delete();
  assertTrue(testSucceed);
}
 

public final Disposable subscribe(final Consumer<? super T> onSuccess, final Consumer<? super Throwable> onError) {
    ObjectHelper.requireNonNull(onSuccess, "onSuccess is null");
    ObjectHelper.requireNonNull(onError, "onError is null");

    ConsumerSingleObserver<T> observer = new ConsumerSingleObserver<T>(onSuccess, onError);
    subscribe(observer);
    return observer;
}
 

public void testCreateUploadToken() throws Exception {

      JSONObject fileObject = new JSONObject();
      StorageClient storageClient = PaasClient.getStorageClient();
      storageClient.newUploadToken(fileObject).subscribe(new Observer<FileUploadToken>() {
        public void onComplete() {

        }

        public void onError(Throwable throwable) {
          System.out.println("failed! cause: " + throwable);
          testSucceed = true;
          latch.countDown();
        }

        public void onNext(FileUploadToken fileUploadToken) {
          System.out.println(fileUploadToken);

          latch.countDown();
        }
        public void onSubscribe(Disposable disposable) {
          ;
        }
      });
      latch.await();
      assertTrue(testSucceed);
  }
 

@Override
public void onSubscribe(@io.reactivex.annotations.NonNull Disposable d) {
    disposable = d;
    if (!NetworkUtil.isNetworkAvailable(context)) {
        LogUtils.e(TAG, "网络不可用");
    } else {
        LogUtils.e(TAG, "网络可用");
    }
}
 

public static void main(String[] args) {
	// TODO Auto-generated method stub
	
	Observable<Long>observable=Observable.rangeLong(1l,3l);
	Observer< Long> observer=new Observer<Long>() {

		@Override
		public void onComplete() {
			// TODO Auto-generated method stub
			System.out.println("on complete");
			
		}

		@Override
		public void onError(Throwable throwable) {
			// TODO Auto-generated method stub
			throwable.printStackTrace();
			
		}

		@Override
		public void onNext(Long value) {
			// TODO Auto-generated method stub
			System.out.println(""+value);
			
		}

		@Override
		public void onSubscribe(Disposable disposable) {
			// TODO Auto-generated method stub
			System.out.println(disposable.isDisposed());
			disposable.dispose();
			
		}
	};
	observable.subscribe(observer);
	
}
 

public void testUploaderExternelUrlWithObserver() throws Exception {
  AVFile file = new AVFile("test", "http://cms-bucket.ws.126.net/2020/0401/8666ec9dp00q83fid008oc000m801n8c.png");
  Observable<AVFile> result = file.saveInBackground();
  result.subscribe(new Observer<AVFile>() {
    @Override
    public void onSubscribe(Disposable d) {
      ;
    }

    @Override
    public void onNext(AVFile avFile) {
      log("Thread:" + Thread.currentThread().getId());
      log("保存了一个File：" + avFile.getObjectId());
      Toast.makeText(FileDemoActivity.this, "上传成功", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onError(Throwable e) {
      Toast.makeText(FileDemoActivity.this, "上传失败", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onComplete() {

    }
  });
}
 

private synchronized void doUpdate() {
    upIndex++;
    if (upIndex < searchBookBeanList.size()) {
        toBookshelf(searchBookBeanList.get(upIndex))
                .flatMap(this::getChapterList)
                .flatMap(this::saveSearchBookBean)
                .subscribeOn(scheduler)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<SearchBookBean>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        compositeDisposable.add(d);
                        handler.postDelayed(() -> {
                            if (!d.isDisposed()) {
                                d.dispose();
                                doUpdate();
                            }
                        }, 20 * 1000);
                    }

                    @Override
                    public void onNext(SearchBookBean searchBookBean) {
                        RxBus.get().post(RxBusTag.UP_SEARCH_BOOK, searchBookBean);
                        doUpdate();
                    }

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

                    @Override
                    public void onComplete() {

                    }
                });
    }
}
 

public void testPushFlowControl() throws Exception {
  AVPush push = new AVPush();
  Map<String, Object> pushData = new HashMap<>();
  pushData.put("alert", "push message to android device directly");
  push.setPushToAndroid(true);
  push.setData(pushData);
  push.setFlowControl( 200);
  assertEquals(push.getFlowControl(), 1000);

  final CountDownLatch latch = new CountDownLatch(1);
  testSucceed = false;
  push.sendInBackground().subscribe(new Observer<JSONObject>() {
    @Override
    public void onSubscribe(Disposable d) {
    }

    @Override
    public void onNext(JSONObject jsonObject) {
      System.out.println("推送成功" + jsonObject);
      testSucceed = true;
      latch.countDown();
    }

    @Override
    public void onError(Throwable e) {
      e.printStackTrace();
      System.out.println("推送失败，错误信息：" + e.getMessage());
      latch.countDown();
    }

    @Override
    public void onComplete() {
    }
  });
  latch.await();
  assertTrue(testSucceed);
}