Java SingleTransformer类代码示例

import io.reactivex.SingleTransformer; //导入依赖的package包/类
/**
 * Creates transform operator, which logs defined events in observable's lifecycle
 * @param msg     message
 * @param bitMask bitmask of events which you want to log
 * @param <T>     type
 * @return transformer
 */
public static <T> SingleTransformer<T, T> logSingle(final String msg, final int bitMask) {
    return upstream -> {
        if ((bitMask & LOG_SUBSCRIBE) > 0) {
            upstream = upstream.compose(sLogSubscribe(msg));
        }
        if ((bitMask & LOG_ERROR) > 0) {
            upstream = upstream.compose(sLogError(msg));
        }
        if ((bitMask & LOG_NEXT_DATA) > 0) {
            upstream = upstream.compose(sLogSuccess(msg));
        } else if ((bitMask & LOG_NEXT_EVENT) > 0) {
            upstream = upstream.compose(sLogSuccessEvent(msg));
        }
        if ((bitMask & LOG_DISPOSE) > 0) {
            upstream = upstream.compose(sLogDispose(msg));
        }
        return upstream;
    };
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
private SingleTransformer<TmpResult, TmpResult> storeToCacheAndReturn() {
    return single -> single
            // собственно, вставка
            .flatMap(result -> this.messagesInteractor
                    .insertMessages(result.getAccountId(), result.collectDtos())
                    .andThen(refreshChangedDialogs(result))
                    .andThen(Single.just(result)))
            .flatMap(result -> {
                // собственно, получение из локальной базы
                List<Integer> ids = collectIds(result.getData(), msg -> true);

                return this.messagesInteractor
                        .findCachedMessages(result.getAccountId(), ids)
                        .map(result::appendModel);
            });
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
private SingleTransformer<List<PostEntity>, List<Post>> dbos2models(int accountId) {
    return single -> single
            .flatMap(dbos -> {
                final VKOwnIds ids = new VKOwnIds();
                Entity2Model.fillOwnerIds(ids, dbos);

                return ownersInteractor
                        .findBaseOwnersDataAsBundle(accountId, ids.getAll(), IOwnersInteractor.MODE_ANY)
                        .map(owners -> {
                            List<Post> posts = new ArrayList<>(dbos.size());
                            for (PostEntity dbo : dbos) {
                                posts.add(Entity2Model.buildPostFromDbo(dbo, owners));
                            }
                            return posts;
                        });
            });
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
private SingleTransformer<List<MessageEntity>, List<Message>> toMessageModels(int accountId) {
    return single -> single
            .flatMap(dbos -> {
                VKOwnIds ownIds = new VKOwnIds();
                Entity2Model.fillOwnerIds(ownIds, dbos);

                return this.ownersInteractor
                        .findBaseOwnersDataAsBundle(accountId, ownIds.getAll(), IOwnersInteractor.MODE_ANY)
                        .map(owners -> {
                            final List<Message> messages = new ArrayList<>(dbos.size());

                            for (MessageEntity dbo : dbos) {
                                messages.add(Entity2Model.buildMessageFromDbo(accountId, dbo, owners));
                            }

                            return messages;
                        });
            });
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
private SingleTransformer<List<CommentEntity>, List<Comment>> dbos2models(int accountId) {
    return single -> single.flatMap(dbos -> {
        VKOwnIds ownids = new VKOwnIds();
        for (CommentEntity c : dbos) {
            Entity2Model.fillCommentOwnerIds(ownids, c);
        }

        return ownersInteractor
                .findBaseOwnersDataAsBundle(accountId, ownids.getAll(), IOwnersInteractor.MODE_ANY)
                .map(owners -> {
                    List<Comment> comments = new ArrayList<>(dbos.size());
                    for (CommentEntity dbo : dbos) {
                        comments.add(Entity2Model.buildCommentFromDbo(dbo, owners));
                    }
                    return comments;
                });
    });
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
public <R> SingleTransformer<? super R, ? extends R> composeSingle() {
    return new SingleTransformer<R, R>() {
        @Override
        public SingleSource<R> apply(@NonNull Single<R> upstream) {
            return upstream
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .retryWhen(new RetryWithDelay(maxRetry, todoBeforeRetry).forSingle)
                    .doOnSubscribe(new Consumer<Disposable>() {
                        @Override
                        public void accept(@NonNull Disposable disposable) throws Exception {
                            AbstractPresenter.this.addDisposable(disposable);
                        }
                    });
        }
    };
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
public static <R extends Result> SingleTransformer<R, R> forSingle() {
    return upstream -> upstream.onErrorResumeNext(throwable -> {
        if(throwable instanceof StatusException) {
            StatusException statusException = (StatusException) throwable;

            if(statusException.getStatus().hasResolution()) {
                return Single.just((R) statusException.getResult());
            } else {
                return Single.error(throwable);
            }

        } else {
            return Single.error(throwable);
        }
    });
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
/**
 * Filters the given list against whether their Title or Subtitle matches the filter text.
 *
 * @return Filtered list.
 */
public SingleTransformer<List<? extends RecyclerViewModel>, List<? extends RecyclerViewModel>> filterByFilterText()
{
    return untransformed ->
            (Single) untransformed.flattenAsObservable(items -> items)
                    .filter(item ->
                            item.getSubtitle().toLowerCase().contains(filterText) || item.getTitle().toLowerCase().contains(filterText))
                    .toList();
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
/**
 * Filters the list to items that are listed as For Sale.
 *
 * @return Filtered list.
 */
public SingleTransformer<List<Listing>, List<Listing>> filterForSale()
{
    return listingsSingle ->
            listingsSingle.flattenAsObservable(listings -> listings)
                    .filter(listing ->
                            listing.getStatus().equals("For Sale"))
                    .toList();
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
@Provides
SchedulerSingleTransformer provideSchedulerSingleTransformer() {
  return new SchedulerSingleTransformer() {
    @SuppressWarnings("unchecked")
    @Override public <T> SingleTransformer<T, T> transformer() {
      return upstream -> upstream.subscribeOn(Schedulers.io())
          .observeOn(AndroidSchedulers.mainThread());
    }
  };
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override public <T> SingleTransformer<T, T> transformer() {
  return (SingleTransformer<T, T>) new SingleTransformer() {
    @Override public SingleSource apply(Single upstream) {
      return upstream.subscribeOn(Schedulers.trampoline())
          .observeOn(Schedulers.trampoline());
    }
  };
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
private SingleTransformer<TmpResult, TmpResult> getAndStore() {
    return single -> single
            .flatMap(result -> {
                // если в исходных данных недостаточно инфы - получаем нужные данные с api
                List<Integer> needGetFromNet = collectIds(result.getData(), msg -> isNull(msg.getDto()));
                if (needGetFromNet.isEmpty()) {
                    return Single.just(result);
                }

                return networker.vkDefault(result.getAccountId())
                        .messages()
                        .getById(needGetFromNet)
                        .map(result::appendDtos);
            })
            .map(result -> {
                // отсеиваем сообщения, которые имеют отношение к обмену ключами
                removeIf(result.getData(), msg -> KeyExchangeService.intercept(app, result.getAccountId(), msg.getDto()));
                return result;
            })
            .flatMap(result -> {
                if (result.getData().isEmpty()) {
                    return Single.just(result);
                }

                // идентифицируем доолнительные необходимые данные, которых не хватает в локальной базе
                // например, информация о пользователях, группах или чатах
                // получаем и сохраняем, если необходимо
                return identifyMissingObjectsGetAndStore(result)
                        .andThen(Single.just(result))
                        // сохраняем сообщения в локальную базу и получаем оттуда "тяжелые" обьекты сообщений
                        .compose(storeToCacheAndReturn());
            });
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
private SingleTransformer<PostEntity, Post> dbo2model(int accountId) {
    return single -> single
            .flatMap(dbo -> {
                final VKOwnIds ids = new VKOwnIds();
                Entity2Model.fillPostOwnerIds(ids, dbo);

                return ownersInteractor
                        .findBaseOwnersDataAsBundle(accountId, ids.getAll(), IOwnersInteractor.MODE_ANY)
                        .map(owners -> {
                            return Entity2Model.buildPostFromDbo(dbo, owners);
                        });
            });
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
public  static <T> SingleTransformer<T, T> applyCommonSchedulersSingle() {
    return new SingleTransformer<T, T>() {
        @Override
        public SingleSource<T> apply(@NonNull Single<T> upstream) {
            return upstream.subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
        }
    };
}
 

import io.reactivex.SingleTransformer; //导入依赖的package包/类
private <T> SingleTransformer<T, T> retry() {
    return new SingleTransformer<T, T>() {
        @Override
        public SingleSource<T> apply(Single<T> upstream) {
            return upstream.retryWhen(new Function<Flowable<Throwable>, Publisher<Object>>() {

                private final int MAX_COUNT = 3;
                private int count = 0;

                private final int DELAY_SECOND = 10;

                @Override
                public Publisher<Object> apply(Flowable<Throwable> throwableFlowable) throws Exception {
                    return throwableFlowable.flatMap(new Function<Throwable, Publisher<?>>() {
                        @Override
                        public Publisher<?> apply(Throwable throwable) throws Exception {
                            if (count++ < MAX_COUNT && throwable instanceof HttpException) {
                                final HttpException httpException = (HttpException) throwable;
                                if (httpException.code() == 403) {
                                    return Flowable.timer(DELAY_SECOND, TimeUnit.SECONDS);
                                }
                            }
                            return Flowable.error(throwable);
                        }
                    });
                }
            });
        }
    };
}