@Override public void subscribe(SingleEmitter<Integer> s) throws Exception { calls[0]++; s.onSuccess(1); } });
@Override public void subscribe(SingleEmitter<Integer> e) throws Exception { e.setDisposable(d1); e.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { d2.dispose(); } }); e.onSuccess(1); e.onError(new TestException()); e.onSuccess(2); e.onError(new TestException()); } })
@Override public void subscribe(SingleEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onSuccess(1); e.onError(new TestException()); e.onSuccess(2); e.onError(new TestException()); } })
@Override public void subscribe(SingleEmitter<Object> e) throws Exception { e.onSuccess(1); response[0] = e.tryOnError(new TestException()); } })
e.onSuccess(Uri.parse(thread.getImageUrl())); return; e.onError(new Throwable(context.getString(R.string.thread_users_have_no_valid_avatar_urls))); e.onSuccess(Uri.parse(urls.get(0))); File file = ImageUtils.compressImageToFile(context, bitmap, "avatar", ".png"); if(file != null) { e.onSuccess(Uri.fromFile(file)); e.onError(new Throwable(context.getString(R.string.could_not_save_composite_thread_image_to_file))); }, throwable -> e.onError(throwable));
@Override public Single<Listing<Submission>> getSubmissionListing(final Paginator<Submission> paginator) { return Single.create(e -> { try { Listing<Submission> listing = paginator.next(false); e.onSuccess(listing); } catch (Exception ex) { if (!e.isDisposed()) { e.onError(ex); } } }); }
@Override public void subscribe(SingleEmitter<Object> e) throws Exception { e.setCancellable(SoloTest.this); e.onSuccess(1); e.onSuccess(2); e.onError(new IOException()); } })
@Override public void onCancelled(DatabaseError e) { if (!emit.isDisposed()) { emit.onError(e.toException()); } } };
@Override public void subscribe(SingleEmitter<Response> e) { try { requestBuilder.setCallback(new RequestCallback() { @Override public void onResponseReceived(Request req, Response res) { e.onSuccess(res); } @Override public void onError(Request req, Throwable ex) { e.onError(ex); } }); Request request = requestBuilder.send(); e.setCancellable(request::cancel); } catch (RequestException ex) { e.onError(ex); } } });
@Override public void onDataChange(DataSnapshot dataSnapshot) { if (!emit.isDisposed()) { emit.onSuccess(dataSnapshot); } }
@Test public void verifyCancellation() { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java Single<Integer> source = Single.create(e -> e.setCancellable(i::incrementAndGet)); CompletableSubject scope = CompletableSubject.create(); source.as(autoDisposable(scope)) .subscribe(); assertThat(i.get()).isEqualTo(0); assertThat(scope.hasObservers()).isTrue(); scope.onComplete(); // Verify cancellation was called assertThat(i.get()).isEqualTo(1); assertThat(scope.hasObservers()).isFalse(); }
@Test void toFuture_single_cancel() throws InterruptedException { final CountDownLatch subscribeLatch = new CountDownLatch(1); final CountDownLatch emitLatch = new CountDownLatch(1); final CountDownLatch completedLatch = new CountDownLatch(1); final Single<String> completable = Single.<String>create(emitter -> { subscribeLatch.countDown(); try { emitLatch.await(100, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { // ignore } if (emitter.isDisposed()) { completedLatch.countDown(); } }).subscribeOn(Schedulers.single()); final CompletableFuture<String> future = RxFutureConverter.toFuture(completable); assertFalse(future.isDone()); assertTrue(subscribeLatch.await(100, TimeUnit.MILLISECONDS)); future.cancel(false); emitLatch.countDown(); assertTrue(completedLatch.await(100, TimeUnit.MILLISECONDS)); assertTrue(future.isDone()); assertThrows(CancellationException.class, future::get); }
public static Single<Bitmap> combineBitmaps (final Context context, final List<String> urls) { return Single.create(e -> { final ArrayList<Bitmap> bitmaps = new ArrayList<>(); ArrayList<Single<Bitmap>> singles = new ArrayList<>(); for(String url : urls) { if(singles.size() >= 4) { break; } singles.add(bitmapForURL(context, url).onErrorResumeNext(throwable -> null)); } Single.merge(singles).observeOn(AndroidSchedulers.mainThread()) .doOnComplete(() -> { int size = context.getResources().getDimensionPixelSize(R.dimen.chat_sdk_chat_action_barcircle_image_view_size); Bitmap bitmap = ImageUtils.getMixImagesBitmap(size, size, bitmaps); if(bitmap == null) { e.onError(new Throwable(context.getString(R.string.thread_image_could_not_be_created))); } else { e.onSuccess(bitmap); } }) .subscribe(bitmaps::add, throwable -> { e.onError(throwable); ChatSDK.logError(throwable); }); }); }
@Override public Single<List<Contribution>> getUserContributions( final UserContributionPaginator paginator) { return Single.create(e -> { try { e.onSuccess(new ArrayList<>(paginator.next())); } catch (Exception ex) { if (!e.isDisposed()) { e.onError(ex); } } }); }
@Override public void subscribe(SingleEmitter<Object> e) throws Exception { e.setCancellable(SoloTest.this); e.onError(new IOException()); e.onSuccess(2); e.onError(new IOException()); } })
@Override public void subscribe(SingleEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onError(new TestException()); e.onSuccess(2); e.onError(new TestException()); } })
protected final void handleResolutionResult(int resultCode, ConnectionResult connectionResult) { for (Map.Entry<GoogleApiClient, SingleEmitter<T>> entry : subscriptionInfoMap.entrySet()) { if (!entry.getValue().isDisposed()) { if (resultCode == Activity.RESULT_OK) { try { entry.getKey().connect(); } catch (Throwable ex) { entry.getValue().onError(ex); } } else { entry.getValue().onError(new GoogleAPIConnectionException("Error connecting to GoogleApiClient, resolution was not successful.", connectionResult)); } } } }
@Override public final void subscribe(SingleEmitter<T> subscriber) throws Exception { final GoogleApiClient apiClient = createApiClient(new ApiClientConnectionCallbacks(subscriber)); subscriptionInfoMap.put(apiClient, subscriber); try { apiClient.connect(); } catch (Throwable ex) { subscriber.onError(ex); } subscriber.setCancellable(() -> { if (apiClient.isConnected() || apiClient.isConnecting()) { onUnsubscribed(apiClient); apiClient.disconnect(); } subscriptionInfoMap.remove(apiClient); }); }
@Test public void deferredResultSubscriberWithError() throws Exception { IllegalStateException ex = new IllegalStateException(); // Mono MonoProcessor<String> mono = MonoProcessor.create(); testDeferredResultSubscriber(mono, Mono.class, forClass(String.class), () -> mono.onError(ex), ex); // RxJava 1 Single AtomicReference<SingleEmitter<String>> ref = new AtomicReference<>(); Single<String> single = Single.fromEmitter(ref::set); testDeferredResultSubscriber(single, Single.class, forClass(String.class), () -> ref.get().onError(ex), ex); // RxJava 2 Single AtomicReference<io.reactivex.SingleEmitter<String>> ref2 = new AtomicReference<>(); io.reactivex.Single<String> single2 = io.reactivex.Single.create(ref2::set); testDeferredResultSubscriber(single2, io.reactivex.Single.class, forClass(String.class), () -> ref2.get().onError(ex), ex); }