@Override final protected Observable<R> getFallbackObservable() { return Observable.defer(new Func0<Observable<R>>() { @Override public Observable<R> call() { try { return Observable.just(getFallback()); } catch (Throwable ex) { return Observable.error(ex); } } }); }
public Observable<Bitmap> compressToBitmapAsObservable(final File file) { return Observable.defer(new Func0<Observable<Bitmap>>() { @Override public Observable<Bitmap> call() { return Observable.just(compressToBitmap(file)); } }); }
public Observable<File> compressToFileAsObservable(final File file) { return Observable.defer(new Func0<Observable<File>>() { @Override public Observable<File> call() { return Observable.just(compressToFile(file)); } }); }
return Observable.defer(new Func0<Observable<ResponseType>>() { @Override public Observable<ResponseType> call() {
return Observable.defer(new Func0<Observable<ResponseType>>() { @Override public Observable<ResponseType> call() {
/** As of RxJava 1.1.7, Observable.fromCallable is still @Beta, so just in case... */ @Internal static <T> Observable<T> fromCallable(final Callable<T> callable) { return Observable.defer(new Func0<Observable<T>>() { @Override public Observable<T> call() { T result; try { result = callable.call(); } catch (Exception e) { return Observable.error(e); } return Observable.just(result); } }); } }
@Override protected Observable<Boolean> resumeWithFallback() { return Observable.defer(new Func0<Observable<Boolean>>() { @Override public Observable<Boolean> call() { startLatch.countDown(); return Observable.just(false); } }); } }
private Observable<Response> execute(Request request) { return Observable.defer(() -> { try { return Observable.just(mCallFactory.newCall(request).execute()); } catch (IOException e) { return Observable.error(e); } }).subscribeOn(mIoScheduler); }
@Override final protected Observable<R> getExecutionObservable() { return Observable.defer(new Func0<Observable<R>>() { @Override public Observable<R> call() { try { return Observable.just(run()); } catch (Throwable ex) { return Observable.error(ex); } } }).doOnSubscribe(new Action0() { @Override public void call() { // Save thread on which we get subscribed so that we can interrupt it later if needed executionThread.set(Thread.currentThread()); } }); }
protected BucketedCounterStream(final HystrixEventStream<Event> inputEventStream, final int numBuckets, final int bucketSizeInMs, final Func2<Bucket, Event, Bucket> appendRawEventToBucket) { this.numBuckets = numBuckets; this.reduceBucketToSummary = new Func1<Observable<Event>, Observable<Bucket>>() { @Override public Observable<Bucket> call(Observable<Event> eventBucket) { return eventBucket.reduce(getEmptyBucketSummary(), appendRawEventToBucket); } }; final List<Bucket> emptyEventCountsToStart = new ArrayList<Bucket>(); for (int i = 0; i < numBuckets; i++) { emptyEventCountsToStart.add(getEmptyBucketSummary()); } this.bucketedStream = Observable.defer(new Func0<Observable<Bucket>>() { @Override public Observable<Bucket> call() { return inputEventStream .observe() .window(bucketSizeInMs, TimeUnit.MILLISECONDS) //bucket it by the counter window so we can emit to the next operator in time chunks, not on every OnNext .flatMap(reduceBucketToSummary) //for a given bucket, turn it into a long array containing counts of event types .startWith(emptyEventCountsToStart); //start it with empty arrays to make consumer logic as generic as possible (windows are always full) } }); }
@Override public void getStories(@FetchMode String filter, @CacheMode int cacheMode, final ResponseListener<Item[]> listener) { if (listener == null) { return; } Observable.defer(() -> getStoriesObservable(filter, cacheMode)) .subscribeOn(mIoScheduler) .observeOn(mMainThreadScheduler) .subscribe(listener::onResponse, t -> listener.onError(t != null ? t.getMessage() : "")); }
return Observable.defer(new Func0<Observable<R>>() { @Override public Observable<R> call() {
@Override public void parse(String itemId, String url, Callback callback) { Observable.defer(() -> fromCache(itemId)) .subscribeOn(mIoScheduler) .flatMap(content -> content != null ? Observable.just(content) : fromNetwork(itemId, url)) .map(content -> AndroidUtils.TextUtils.equals(EMPTY_CONTENT, content) ? null : content) .observeOn(mMainThreadScheduler) .subscribe(callback::onResponse); }
@Override protected Observable<Boolean> construct() { return Observable.defer(new Func0<Observable<Boolean>>() { @Override public Observable<Boolean> call() { try { Thread.sleep(1000); } catch (InterruptedException e) { System.out.println("Interrupted!"); e.printStackTrace(); hasBeenInterrupted = true; } return Observable.just(hasBeenInterrupted); } }).subscribeOn(Schedulers.io()); } }
@WorkerThread @Override public void parse(String itemId, String url) { Observable.defer(() -> fromCache(itemId)) .subscribeOn(Schedulers.immediate()) .switchIfEmpty(fromNetwork(itemId, url)) .map(content -> AndroidUtils.TextUtils.equals(EMPTY_CONTENT, content) ? null : content) .observeOn(Schedulers.immediate()) .subscribe(); }
private Observable<R> executeCommandWithSpecifiedIsolation(final AbstractCommand<R> _cmd) { if (properties.executionIsolationStrategy().get() == ExecutionIsolationStrategy.THREAD) { return Observable.defer(new Func0<Observable<R>>() { @Override public Observable<R> call() { return Observable.defer(new Func0<Observable<R>>() { @Override public Observable<R> call() {
return Observable.defer(new Func0<Observable<Channel>>() { @Override public Observable<Channel> call() {
List<Observable<Integer>> commands = new ArrayList<Observable<Integer>>(); for (int i = 0; i < NUM_COMMANDS; i++) { commands.add(Observable.defer(new Func0<Observable<Integer>>() { @Override public Observable<Integer> call() {
Observable.defer(applyHystrixSemantics) .map(wrapWithAllOnNextHooks);
break; Observable.defer(() -> Observable.zip( mSessionManager.isViewed(itemId), mFavoriteManager.check(itemId),