hu.akarnokd.rxjava.interop.RxJavaInterop Java Examples

public Observable<Boolean> monitorPurchases(Context context) {
    return RxJavaInterop.toV2Observable(
            rx.Observable.concat(
                    rx.Observable.just(false),
                    ReactiveBilling.getInstance(context)
                            .getPurchases(PurchaseType.PRODUCT, null)
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .map(GetPurchasesResponse::getList)
                            .flatMap(rx.Observable::from)
                            .map(GetPurchasesResponse.PurchaseResponse::getProductId)
                            .filter(item -> PREMIUM_SKU_ID.equals(item))
                            .map(item -> true)
                            .firstOrDefault(false),
                    ReactiveBilling.getInstance(context).purchaseFlow()
                            .doOnNext(this::recordPurchase)
                            .map(PurchaseResponse::isSuccess)
            )
    );
}
 

public Observable<Boolean> monitorPurchases(Context context) {
    return RxJavaInterop.toV2Observable(
            rx.Observable.concat(
                    rx.Observable.just(false),
                    ReactiveBilling.getInstance(context)
                            .getPurchases(PurchaseType.PRODUCT, null)
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .map(GetPurchasesResponse::getList)
                            .map(list -> list == null ? EMPTY_LIST : list)
                            .flatMap(rx.Observable::from)
                            .map(GetPurchasesResponse.PurchaseResponse::getProductId)
                            .filter(item -> PREMIUM_SKU_ID.equals(item))
                            .map(item -> true)
                            .firstOrDefault(false),
                    ReactiveBilling.getInstance(context).purchaseFlow()
                            .doOnNext(this::recordPurchase)
                            .map(PurchaseResponse::isSuccess)
            )
    );
}
 

public Observable<Boolean> monitorPurchases(Context context) {
    return RxJavaInterop.toV2Observable(
            rx.Observable.concat(
                    rx.Observable.just(false),
                    ReactiveBilling.getInstance(context)
                            .getPurchases(PurchaseType.PRODUCT, null)
                            .subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .map(GetPurchasesResponse::getList)
                            .flatMap(rx.Observable::from)
                            .map(GetPurchasesResponse.PurchaseResponse::getProductId)
                            .filter(item -> PREMIUM_SKU_ID.equals(item))
                            .map(item -> true)
                            .firstOrDefault(false),
                    ReactiveBilling.getInstance(context).purchaseFlow()
                            .doOnNext(this::recordPurchase)
                            .map(PurchaseResponse::isSuccess)
            )
    );
}
 

@Override
public Single<Pair<Account, Boolean>> getAccount(String email, String code, String state,
    String agent) {
  return RxJavaInterop.toV1Single(aptoideAuthentication.authenticate(code, state, agent))
      .flatMap(oAuth2 -> authenticationPersistence.createAuthentication(email, code,
          oAuth2.getData()
              .getRefreshToken(), oAuth2.getData()
              .getAccessToken(), AptoideAccountManager.APTOIDE_SIGN_UP_TYPE)
          .andThen(authenticationPersistence.getAuthentication()
              .flatMap(auth -> getAccount(auth.getEmail()).map(
                  account -> Pair.create(account, oAuth2.getSignup())))))
      .onErrorResumeNext(throwable -> {
        if (throwable instanceof AptoideWsV3Exception) {
          AptoideWsV3Exception exception = (AptoideWsV3Exception) throwable;
          return Single.error(new AccountException(exception));
        }
        return Single.error(throwable);
      });
}
 

@BindingConversion
@Nullable
public static <U extends ViewModel> io.reactivex.Observable<List<ViewModel>> toV1GenericList(@Nullable Observable<List<U>> specificList) {
    return specificList == null ? null : RxJavaInterop.toV2Observable(specificList).map(new Function<List<U>, List<ViewModel>>() {
        @Override
        public List<ViewModel> apply(List<U> ts) throws Exception {
            return new ArrayList<ViewModel>(ts);
        }
    });
}
 

public Observable<Response> purchasePremium(Context context) {
    analytics.logCheckoutStart(PREMIUM_SKU_ID);
    return RxJavaInterop.toV2Observable(
            ReactiveBilling.getInstance(context)
                    .startPurchase(PREMIUM_SKU_ID, PurchaseType.PRODUCT, null, null)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
    );
}
 

public Observable<Response> purchasePremium(Context context) {
    return RxJavaInterop.toV2Observable(
            ReactiveBilling.getInstance(context)
                    .startPurchase(PREMIUM_SKU_ID, PurchaseType.PRODUCT, null, null)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
    );
}
 

public Observable<Response> purchasePremium(Context context) {
    analytics.logCheckoutStart(PREMIUM_SKU_ID);
    return RxJavaInterop.toV2Observable(
            ReactiveBilling.getInstance(context)
                    .startPurchase(PREMIUM_SKU_ID, PurchaseType.PRODUCT, null, null)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
    );
}
 

@NonNull
public static <T> rx.Observable<T> toObservable(@NonNull final ObservableField<T> field) {

    return RxJavaInterop.toV1Observable(
            com.manaschaudhari.android_mvvm.FieldUtils.toObservable(field),
            BackpressureStrategy.LATEST);
}
 

public Single<Boolean> contains(String packageName, boolean isExcluded, boolean isAppcUpgrade) {
  return RxJavaInterop.toV1Single(
      updateDao.getByPackageAndExcludedAndUpgrade(packageName, isExcluded, isAppcUpgrade))
      .onErrorReturn(throwable -> null)
      .map(update -> update != null)
      .subscribeOn(Schedulers.io());
}
 

@Override public rx.Completable save(Event event) {
  return RxJavaInterop.toV1Completable(Completable.create(completableEmitter -> {
    try {
      eventDAO.insert(mapper.map(event));
      completableEmitter.onComplete();
    } catch (JsonProcessingException e) {
      completableEmitter.onError(e);
    }
  })
      .subscribeOn(Schedulers.io()));
}
 

@Override public rx.Completable remove(List<Event> events) {
  return RxJavaInterop.toV1Completable(Observable.fromIterable(events)
      .flatMap(event -> {
        try {
          return Observable.just(mapper.map(event));
        } catch (JsonProcessingException e) {
          return Observable.error(e);
        }
      })
      .subscribeOn(Schedulers.io())
      .doOnNext(roomEvent -> eventDAO.delete(roomEvent))
      .toList()
      .ignoreElement());
}
 

private Observable<List<RoomInstalled>> getInstalledAsList(String packageName) {
  return RxJavaInterop.toV1Observable(installedDao.getAsListByPackageName(packageName),
      BackpressureStrategy.BUFFER)
      .onErrorReturn(throwable -> new ArrayList<>())
      .flatMap(installs -> filterCompleted(installs))
      .subscribeOn(Schedulers.io());
}
 

@Override public Completable save(String experimentName, Experiment experiment) {
  return RxJavaInterop.toV1Completable(io.reactivex.Completable.create(completableEmitter -> {
    experimentDAO.save(mapper.map(experimentName, experiment));
    completableEmitter.onComplete();
  })
      .subscribeOn(Schedulers.io()));
}
 

@Override public rx.Single<ExperimentModel> get(String identifier) {
  return RxJavaInterop.toV1Single(experimentDAO.get(identifier)
      .subscribeOn(Schedulers.io())
      .flatMap(
          roomExperiment -> Single.just(new ExperimentModel(mapper.map(roomExperiment), false))))
      .onErrorReturn(throwable -> new ExperimentModel(new Experiment(), true))
      .doOnError(Throwable::printStackTrace);
}
 

@Override public rx.Observable<List<Event>> getAll() {
  return RxJavaInterop.toV1Observable(eventDAO.getAll()
      .subscribeOn(Schedulers.io())
      .flatMap(roomEvents -> {
        try {
          return Observable.just(mapper.map(roomEvents));
        } catch (IOException e) {
          return Observable.error(e);
        }
      }), BackpressureStrategy.BUFFER);
}
 

@Override public Observable<Sync> get(String id) {
  return RxJavaInterop.toV1Observable(localNotificationSyncDao.get(id),
      BackpressureStrategy.BUFFER)
      .subscribeOn(Schedulers.io())
      .onErrorReturn(throwable -> null)
      .map(sync -> {
        if (sync != null) {
          return mapper.map(sync, provider);
        } else {
          return null;
        }
      });
}
 

public Observable<E> singleAsObservable() {
    rx.Observable<E> o = briteResolver.createQuery(baseUri,
            projection,
            selection.toString(),
            getSelectionArgs(),
            sortOrderWithLimit(" LIMIT 1 "), true)
            .mapToOne(cursor -> EntityMapper.forEntity(clazz).fromCursor(cursor))
            .throttleFirst(THROTTLE_BATCH, TimeUnit.MILLISECONDS);

    return RxJavaInterop.toV2Observable(o);
}
 

public Observable<List<RoomDownload>> getInQueueSortedDownloads() {
  return RxJavaInterop.toV1Observable(downloadDAO.getInQueueSortedDownloads(),
      BackpressureStrategy.BUFFER)
      .onErrorReturn(throwable -> new ArrayList<>())
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomDownload>> getRunningDownloads() {
  return RxJavaInterop.toV1Observable(downloadDAO.getRunningDownloads(),
      BackpressureStrategy.BUFFER)
      .onErrorReturn(throwable -> new ArrayList<>())
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomInstalled>> getAsList(String packageName, int versionCode) {
  return RxJavaInterop.toV1Observable(installedDao.getAsList(packageName, versionCode),
      BackpressureStrategy.BUFFER)
      .onErrorReturn(throwable -> new ArrayList<>())
      .subscribeOn(Schedulers.io());
}
 

public Single<RoomDownload> getAsSingle(String md5) {
  return RxJavaInterop.toV1Single(downloadDAO.getAsSingle(md5))
      .onErrorReturn(throwable -> null)
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomDownload>> getAll() {
  return RxJavaInterop.toV1Observable(downloadDAO.getAll(), BackpressureStrategy.BUFFER)
      .defaultIfEmpty(new ArrayList<>())
      .subscribeOn(Schedulers.io());
}
 

public Observable<RoomDownload> getAsObservable(String md5) {
  return RxJavaInterop.toV1Observable(downloadDAO.getAsObservable(md5),
      BackpressureStrategy.BUFFER)
      .onErrorReturn(throwable -> null)
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomDownload>> getUnmovedFilesDownloads() {
  return RxJavaInterop.toV1Observable(downloadDAO.getUnmovedFilesDownloads(),
      BackpressureStrategy.BUFFER)
      .onErrorReturn(throwable -> new ArrayList<>())
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomInstalled>> getAllInstalled() {
  return RxJavaInterop.toV1Observable(installedDao.getAll(), BackpressureStrategy.BUFFER)
      .flatMap(installs -> filterCompleted(installs))
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomInstalled>> getAll() {
  return RxJavaInterop.toV1Observable(installedDao.getAll(), BackpressureStrategy.BUFFER)
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomInstalled>> getAllInstalledSorted() {
  return RxJavaInterop.toV1Observable(installedDao.getAllSortedAsc(), BackpressureStrategy.BUFFER)
      .flatMap(installs -> filterCompleted(installs))
      .subscribeOn(Schedulers.io());
}
 

public Completable remove(String packageName, int versionCode) {
  return RxJavaInterop.toV1Completable(installedDao.remove(packageName, versionCode))
      .subscribeOn(Schedulers.io());
}
 

public Observable<List<RoomDownload>> getAsList(String md5) {
  return RxJavaInterop.toV1Observable(downloadDAO.getAsList(md5), BackpressureStrategy.BUFFER)
      .defaultIfEmpty(new ArrayList<>())
      .onErrorReturn(throwable -> new ArrayList<>())
      .subscribeOn(Schedulers.io());
}