@Override public void setCancellable(Cancellable c) { emitter.setCancellable(c); }
@Override public void setCancellable(Cancellable c) { emitter.setCancellable(c); }
public QueueReleasingEmitterWrapper(ObservableEmitter<T> emitter, QueueReleaseInterface queueReleaseInterface) { this.emitter = emitter; this.queueReleaseInterface = queueReleaseInterface; emitter.setCancellable(this); }
private void storeEmitterToBeNotifiedInTheFuture(final ObservableEmitter<BleException> emitter) { exceptionEmitters.add(emitter); emitter.setCancellable(new Cancellable() { @Override public void cancel() { exceptionEmitters.remove(emitter); } }); }
@Override public void subscribe(final ObservableEmitter<Boolean> emitter) throws Exception { final boolean initialValue = locationServicesStatus.isLocationProviderOk(); final BroadcastReceiver broadcastReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { final boolean newValue = locationServicesStatus.isLocationProviderOk(); emitter.onNext(newValue); } }; emitter.onNext(initialValue); context.registerReceiver(broadcastReceiver, new IntentFilter(LocationManager.MODE_CHANGED_ACTION)); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { context.unregisterReceiver(broadcastReceiver); } }); } }).distinctUntilChanged();
@Override public void subscribe(final ObservableEmitter<Class> emitter) throws Exception { final DataSubscription dataSubscription = boxStore.subscribe().observer(new DataObserver<Class>() { @Override public void onData(Class data) { if (!emitter.isDisposed()) { emitter.onNext(data); } } }); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { dataSubscription.cancel(); } }); } });
@Override public void subscribe(final ObservableEmitter<List<T>> emitter) throws Exception { final DataSubscription dataSubscription = query.subscribe().observer(new DataObserver<List<T>>() { @Override public void onData(List<T> data) { if (!emitter.isDisposed()) { emitter.onNext(data); } } }); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { dataSubscription.cancel(); } }); } });
@Override public void subscribe(final ObservableEmitter<Query> e) throws Exception { final ContentObserver observer = new ContentObserver(contentObserverHandler) { @Override public void onChange(boolean selfChange) { if (!e.isDisposed()) { e.onNext(query); } } }; contentResolver.registerContentObserver(uri, notifyForDescendents, observer); e.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { contentResolver.unregisterContentObserver(observer); } }); if (!e.isDisposed()) { e.onNext(query); // Trigger initial query. } } });
@Override public void subscribe(ObservableEmitter<T> emitter) throws Exception { final FIFORunnableEntry entry = new FIFORunnableEntry<>(operation, emitter); emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { if (queue.remove(entry)) { logOperationRemoved(operation); } } }); logOperationQueued(operation); queue.add(entry); } });
@Override public void subscribe(ObservableEmitter<Object> e) throws Exception { ObservableEmitter<Object> f = e.serialize(); assertSame(f, f.serialize()); assertFalse(f.isDisposed()); final int[] calls = { 0 }; f.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { calls[0]++; } }); e.onComplete(); assertTrue(f.isDisposed()); assertEquals(1, calls[0]); } })
@Test public void verifyCancellation() { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java final ObservableEmitter<Integer>[] emitter = new ObservableEmitter[1]; Observable<Integer> source = Observable.create(e -> { e.setCancellable(i::incrementAndGet); emitter[0] = e; }); 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 final protected void protectedRun(final ObservableEmitter<SCAN_RESULT_TYPE> emitter, QueueReleaseInterface queueReleaseInterface) { final SCAN_CALLBACK_TYPE scanCallback = createScanCallback(emitter); try { emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { RxBleLog.i("Scan operation is requested to stop."); stopScan(rxBleAdapterWrapper, scanCallback); } }); RxBleLog.i("Scan operation is requested to start."); boolean startLeScanStatus = startScan(rxBleAdapterWrapper, scanCallback); if (!startLeScanStatus) { emitter.tryOnError(new BleScanException(BleScanException.BLUETOOTH_CANNOT_START)); } } catch (Throwable throwable) { RxBleLog.e(throwable, "Error while calling the start scan function"); emitter.tryOnError(new BleScanException(BleScanException.BLUETOOTH_CANNOT_START)); } finally { queueReleaseInterface.release(); } }
@Override public void subscribe(ObservableEmitter<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()); e.onNext(4); e.onError(new TestException()); e.onComplete(); } })
@Override public void subscribe(final ObservableEmitter<String> emitter) throws Exception { final OnSharedPreferenceChangeListener listener = new OnSharedPreferenceChangeListener() { @Override public void onSharedPreferenceChanged(SharedPreferences preferences, String key) { emitter.onNext(key); } }; emitter.setCancellable(new Cancellable() { @Override public void cancel() throws Exception { preferences.unregisterOnSharedPreferenceChangeListener(listener); } }); preferences.registerOnSharedPreferenceChangeListener(listener); } }).share();
@Override public void subscribe(ObservableEmitter<STATE> emitter) throws Exception { //the internal listener to the store. Store.StateChangeListener<STATE> listener = emitter::onNext; emitter.setCancellable(() -> store.unsubscribe(listener)); store.subscribe(listener); } }
static Observable<Event> fromEvent(EventTarget source, String type, boolean useCapture) { return Observable.create(s -> { EventListener listener = s::onNext; source.addEventListener(type, listener, useCapture); s.setCancellable(() -> source.removeEventListener(type, listener, useCapture)); }); }
public static Observable<Event> observe(EventTarget element, String type, boolean useCapture) { return Observable.create(s -> { elemental.events.EventListener listener = s::onNext; element.addEventListener(type, listener, useCapture); s.setCancellable(() -> element.removeEventListener(type, listener, useCapture)); }); } }
public static Observable<Event> observe(ElementalMixinBase source, String type, boolean useCapture) { return Observable.create(s -> { elemental.events.EventListener listener = s::onNext; source.addEventListener(type, listener, useCapture); s.setCancellable(() -> source.removeEventListener(type, listener, useCapture)); }); }
@NonNull public static Observable<ImageReader> createOnImageAvailableObservable(@NonNull ImageReader imageReader) { return Observable.create(subscriber -> { ImageReader.OnImageAvailableListener listener = reader -> { if (!subscriber.isDisposed()) { subscriber.onNext(reader); } }; imageReader.setOnImageAvailableListener(listener, null); subscriber.setCancellable(() -> imageReader.setOnImageAvailableListener(null, null)); //remove listener on unsubscribe }); } }
public RxProcess(ProcessFactory processFactory, ProcessKiller processKiller, String... commands) { this.processCreator = Observable.create(e -> { final Process process = processFactory.start(commands); e.setCancellable(() -> { if (RXSDebug.isDebug()) Timber.tag(TAG).v("cancel()"); processKiller.kill(process); }); e.onNext(process); process.waitFor(); e.onComplete(); }); }