@Override public void onDataChange(DataSnapshot dataSnapshot) { if (!emit.isDisposed()) { emit.onSuccess(dataSnapshot); } }
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 void onCancelled(DatabaseError e) { if (!emit.isDisposed()) { emit.onError(e.toException()); } } };
@Override public <X> Single<X> fromCompletionStage(CompletionStage<X> cs) { CompletionStage<X> future = Objects.requireNonNull(cs); return Single .create(emitter -> future.<X>whenComplete((X res, Throwable err) -> { if (!emitter.isDisposed()) { if (err != null) { emitter.onError(err instanceof CompletionException ? err.getCause() : err); } else { emitter.onSuccess(res); } } })); }
@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 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 onComplete(@Nullable DatabaseError databaseError, boolean committed, @NonNull DataSnapshot dataSnapshot) { if (!emitter.isDisposed()) { if (null == databaseError) { emitter.onSuccess(dataSnapshot); } else { emitter.onError(databaseError.toException()); } } } };
if (em.isDisposed()) return null; if (xhr.readyState == XMLHttpRequest.DONE) { if (isExpected(uri(), xhr.status)) em.onSuccess(xhr);
@Override public Single<String> replyToThread( final RedditClient redditClient, final Submission submission, final String text) { return Single.create((e) -> { AccountManager accountManager = new AccountManager(redditClient); try { e.onSuccess(accountManager.reply(submission, text)); } catch (Exception ex) { if (!e.isDisposed()) { e.onError(ex); } } }); }
for (CommentNode node : iterable) { if (node.getComment().getId().equals(commentId)) { if (!e.isDisposed()) { e.onSuccess(node); return; if (!e.isDisposed()) { e.onError(new ReplyNotAvailableException()); if (!e.isDisposed()) { e.onError(ex);
@Test public void handleResolutionResult_ResultOK_ConnectionException() { final Object object = new Object(); BaseSingle<Object> single = spy(new BaseSingle<Object>(rxFit, null, null) { @Override protected void onGoogleApiClientReady(GoogleApiClient apiClient, SingleEmitter<? super Object> subscriber) { subscriber.onSuccess(object); } }); SingleEmitter sub = PowerMockito.spy(new SingleEmitter() { @Override public void onSuccess(Object value) { } @Override public void onError(Throwable error) { } @Override public void setDisposable(Disposable s) {} @Override public void setCancellable(Cancellable c) { } @Override public boolean isDisposed() { return false;} }); RuntimeException exception = new RuntimeException(); doThrow(exception).when(apiClient).connect(); PowerMockito.doReturn(false).when(sub).isDisposed(); single.subscriptionInfoMap.put(apiClient, sub); single.handleResolutionResult(Activity.RESULT_OK, connectionResult); verify(apiClient).connect(); verifyNoMoreInteractions(apiClient); verify(sub).onError(exception); }
@Override public Single<String> replyToComment( final RedditClient redditClient, final Comment parent, final String text) { return Single.create(e -> { AccountManager accountManger = new AccountManager(redditClient); try { String id = accountManger.reply(parent, text); e.onSuccess(id); } catch (Exception ex) { if (!e.isDisposed()) { e.onError(new ReplyToCommentException()); } } }); }
public static <T> Single<T> fiber(SuspendableCallable<T> body){ final Map<Class<?>, Object> contextDataMap = ResteasyProviderFactory.getContextDataMap(); AppGlobals globals = AppGlobals.get(); return Single.<T>create(sub -> { QuasiFibers.start(() -> { try{ // start by restoring the RE context in this Fiber's ThreadLocal ResteasyProviderFactory.pushContextDataMap(contextDataMap); AppGlobals.set(globals); T ret = body.run(); if(!sub.isDisposed()) sub.onSuccess(ret); }catch(Throwable x){ if(!sub.isDisposed()) sub.onError(x); }finally { ResteasyProviderFactory.removeContextDataLevel(); AppGlobals.set(null); } return null; }); }); }
@Test public void handleResolutionResult_ResultCanceled() { final Object object = new Object(); BaseSingle<Object> single = spy(new BaseSingle<Object>(rxFit, null, null) { @Override protected void onGoogleApiClientReady(GoogleApiClient apiClient, SingleEmitter<? super Object> subscriber) { subscriber.onSuccess(object); } }); SingleEmitter sub = PowerMockito.spy(new SingleEmitter() { @Override public void onSuccess(Object value) { } @Override public void onError(Throwable error) { } @Override public void setDisposable(Disposable s) {} @Override public void setCancellable(Cancellable c) { } @Override public boolean isDisposed() { return false;} }); PowerMockito.doReturn(false).when(sub).isDisposed(); single.subscriptionInfoMap.put(apiClient, sub); single.handleResolutionResult(Activity.RESULT_CANCELED, connectionResult); verifyZeroInteractions(apiClient); verify(sub).onError(Matchers.any(GoogleAPIConnectionException.class)); }
@Test public void handleResolutionResult_ResultOK() { final Object object = new Object(); BaseSingle<Object> single = spy(new BaseSingle<Object>(rxFit, null, null) { @Override protected void onGoogleApiClientReady(GoogleApiClient apiClient, SingleEmitter<? super Object> subscriber) { subscriber.onSuccess(object); } }); SingleEmitter sub = PowerMockito.spy(new SingleEmitter() { @Override public void onSuccess(Object value) { } @Override public void onError(Throwable error) { } @Override public void setDisposable(Disposable s) {} @Override public void setCancellable(Cancellable c) { } @Override public boolean isDisposed() { return false;} }); PowerMockito.doReturn(false).when(sub).isDisposed(); single.subscriptionInfoMap.put(apiClient, sub); single.handleResolutionResult(Activity.RESULT_OK, connectionResult); verify(apiClient).connect(); verifyNoMoreInteractions(apiClient); verify(sub, never()).onError(Matchers.any(Throwable.class)); }
@Override public Single<SubscriberCount> getSubscriberCount( final RedditClient redditClient, final String subreddit) { return Single.create(e -> { try { Subreddit rnba = redditClient.getSubreddit(subreddit); Long subscribers = rnba.getSubscriberCount(); int activeUsers = rnba.getAccountsActive(); e.onSuccess(new SubscriberCount(subscribers, activeUsers)); } catch (Exception ex) { if (!e.isDisposed()) { e.onError(ex); } } }); }
@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); }
@Override public Single<Submission> getSubmission( final RedditClient redditClient, final String threadId, final CommentSort sort) { return Single.create(e -> { SubmissionRequest.Builder builder = new SubmissionRequest.Builder(threadId); if (sort != null) { builder.sort(sort); } SubmissionRequest submissionRequest = builder.build(); try { e.onSuccess(redditClient.getSubmission(submissionRequest)); } catch (Exception ex) { if (!e.isDisposed()) { e.onError(ex); } } }); }