private <T> void run( org.web3j.protocol.core.filters.Filter<T> filter, FlowableEmitter<? super T> emitter, long pollingInterval) { filter.run(scheduledExecutorService, pollingInterval); emitter.setCancellable(filter::cancel); }
@Override public void subscribe(final FlowableEmitter<Integer> t) { this.current = t; final ResourceSubscriber<Integer> as = new ResourceSubscriber<Integer>() { @Override public void onComplete() { t.onComplete(); } @Override public void onError(Throwable e) { t.onError(e); } @Override public void onNext(Integer v) { t.onNext(v); } }; processor.subscribe(as); t.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { as.dispose(); } });; }
static <T> void createListItemEmitter(final Query<T> query, final FlowableEmitter<T> emitter) { final DataSubscription dataSubscription = query.subscribe().observer(new DataObserver<List<T>>() { @Override public void onData(List<T> data) { for (T datum : data) { if (emitter.isCancelled()) { return; } else { emitter.onNext(datum); } } if (!emitter.isCancelled()) { emitter.onComplete(); } } }); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { dataSubscription.cancel(); } }); }
emitter.setCancellable(disposable::dispose);
@Test public void verifyCancellation() { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java final FlowableEmitter<Integer>[] emitter = new FlowableEmitter[1]; Flowable<Integer> source = Flowable.create(e -> { e.setCancellable(i::incrementAndGet); emitter[0] = e; }, BackpressureStrategy.LATEST); CompletableSubject scope = CompletableSubject.create(); source.as(autoDisposable(scope)) .subscribe(); assertThat(i.get()).isEqualTo(0); assertThat(scope.hasObservers()).isTrue(); emitter[0].onNext(1); scope.onComplete(); emitter[0].onNext(2); // Verify cancellation was called assertThat(i.get()).isEqualTo(1); assertThat(scope.hasObservers()).isFalse(); }
@Override public void subscribe(FlowableEmitter<Object> e) throws Exception { FlowableEmitter<Object> f = e.serialize(); assertSame(f, f.serialize()); assertFalse(f.isCancelled()); final int[] calls = { 0 }; f.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { calls[0]++; } }); e.onComplete(); assertTrue(f.isCancelled()); assertEquals(1, calls[0]); } }, m)
@Override public void subscribe(FlowableEmitter<Integer> e) throws Exception { e.setDisposable(d1); e.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { d2.dispose(); } }); e.onNext(1); e.onNext(2); e.onNext(3); e.onComplete(); e.onError(new TestException("first")); e.onNext(4); e.onError(new TestException("second")); e.onComplete(); } }, BackpressureStrategy.BUFFER)
EmitterListener(FlowableEmitter<S> emitter, SimpleStore<S> store) { this.emitter = emitter.serialize(); this.store = store; emitter.setCancellable(this); }
private <T> void run( Filter<T> filter, FlowableEmitter<? super T> emitter, long pollingInterval) { filter.run(scheduledExecutorService, pollingInterval); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { filter.cancel(); } }); }
@Override public void subscribe(final FlowableEmitter<String> emitter) { final Timber.Tree tree = new Timber.Tree() { @Override protected void log(int priority, @Nullable String tag, @NotNull String message, @Nullable Throwable t) { if ("BlackMirror".equals(tag)) { emitter.onNext(message); } } }; Timber.plant(tree); emitter.setCancellable(new Cancellable() { @Override public void cancel() { Timber.uproot(tree); } }); } }, BackpressureStrategy.DROP);
@Override public void subscribe(final FlowableEmitter<QuerySnapshot> emitter) throws Exception { final ListenerRegistration registration = ref.addSnapshotListener(metadataChanges, new EventListener<QuerySnapshot>() { @Override public void onEvent(QuerySnapshot querySnapshot, FirebaseFirestoreException e) { if (e != null && !emitter.isCancelled()) { emitter.onError(e); return; } emitter.onNext(querySnapshot); } }); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { registration.remove(); } }); } }, strategy);
@Override public void subscribe(final FlowableEmitter<QuerySnapshot> emitter) { final ListenerRegistration registration = ref.addSnapshotListener(executor, metadataChanges, new EventListener<QuerySnapshot>() { @Override public void onEvent(QuerySnapshot documentSnapshot, FirebaseFirestoreException e) { if (e != null && !emitter.isCancelled()) { emitter.onError(e); return; } emitter.onNext(documentSnapshot); } }); emitter.setCancellable(new Cancellable() { @Override public void cancel() { registration.remove(); } }); } }, strategy);
@Override public void subscribe(final FlowableEmitter<DocumentSnapshot> emitter) throws Exception { final ListenerRegistration registration = ref.addSnapshotListener(activity, metadataChanges, new EventListener<DocumentSnapshot>() { @Override public void onEvent(DocumentSnapshot documentSnapshot, FirebaseFirestoreException e) { if (e != null && !emitter.isCancelled()) { emitter.onError(e); return; } emitter.onNext(documentSnapshot); } }); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { registration.remove(); } }); } }, strategy);
@Override public void subscribe(FlowableEmitter<Integer> emitter) throws Exception { final OnPropertyChangedCallback callback = new OnPropertyChangedCallback() { @Override public void onPropertyChanged(android.databinding.Observable dataBindingObservable, int propertyId) { if (dataBindingObservable == observableInt) { emitter.onNext(observableInt.get()); } } }; observableInt.addOnPropertyChangedCallback(callback); emitter.setCancellable(() -> observableInt.removeOnPropertyChangedCallback(callback)); } }, BackpressureStrategy.DROP);
public static <T> Flowable<T> toObservableField(@NonNull final ObservableField<T> observableField) { return Flowable.create(emitter -> { final OnPropertyChangedCallback callback = new OnPropertyChangedCallback() { @Override public void onPropertyChanged(android.databinding.Observable dataBindingObservable, int propertyId) { if (dataBindingObservable == observableField) { emitter.onNext(observableField.get()); } } }; observableField.addOnPropertyChangedCallback(callback); emitter.setCancellable(() -> observableField.removeOnPropertyChangedCallback(callback)); }, BackpressureStrategy.DROP); }
public static void processExecConstructTriples(FlowableEmitter<Triple> emitter, QueryExecution qe) { try { emitter.setCancellable(qe::abort); Iterator<Triple> it = qe.execConstructTriples(); while(!emitter.isCancelled() && it.hasNext()) { Triple item = it.next(); emitter.onNext(item); } emitter.onComplete(); } catch (Exception e) { emitter.onError(e); } }
public static <T> void processExecSelect(FlowableEmitter<T> emitter, QueryExecution qe, Function<? super ResultSet, ? extends T> next) { try { emitter.setCancellable(qe::abort); ResultSet rs = qe.execSelect(); while(!emitter.isCancelled() && rs.hasNext()) { T binding = next.apply(rs); emitter.onNext(binding); } emitter.onComplete(); } catch (Exception e) { emitter.onError(e); } }
@Override public final void subscribe(FlowableEmitter<T> emitter) throws Exception { final GoogleApiClient apiClient = createApiClient(new ApiClientConnectionCallbacks(emitter)); try { apiClient.connect(); } catch (Throwable ex) { emitter.onError(ex); } emitter.setCancellable(() -> { if (apiClient.isConnected()) { onUnsubscribed(apiClient); } apiClient.disconnect(); }); }
@Test public void testCannotSubscribeTwice() throws Exception { waitFor(3); RxJavaPlugins.setErrorHandler(throwable -> { assertThat(throwable, is(instanceOf(ProtocolViolationException.class))); complete(); }); Subscriber<Integer> subscriber = RxHelper.toSubscriber(new FakeWriteStream(vertx)).onComplete(this::complete); Flowable.range(0, 100) .observeOn(RxHelper.scheduler(vertx)) .subscribeOn(RxHelper.scheduler(vertx)) .subscribe(subscriber); Flowable.<Integer>create(emitter -> emitter.setCancellable(this::complete), BackpressureStrategy.MISSING) .observeOn(RxHelper.scheduler(vertx)) .subscribeOn(RxHelper.scheduler(vertx)) .subscribe(subscriber); await(); }
@Test public void testCannotSubscribeTwice() throws Exception { waitFor(3); RxJavaPlugins.setErrorHandler(throwable -> { assertThat(throwable, is(instanceOf(ProtocolViolationException.class))); complete(); }); Subscriber<Integer> subscriber = RxHelper.toSubscriber(new FakeWriteStream(vertx)).onComplete(this::complete); Flowable.range(0, 100) .observeOn(RxHelper.scheduler(vertx)) .subscribeOn(RxHelper.scheduler(vertx)) .subscribe(subscriber); Flowable.<Integer>create(emitter -> emitter.setCancellable(this::complete), BackpressureStrategy.MISSING) .observeOn(RxHelper.scheduler(vertx)) .subscribeOn(RxHelper.scheduler(vertx)) .subscribe(subscriber); await(); }