@Override public void setDisposable(Disposable d) { emitter.setDisposable(d); }
@Override public void setDisposable(Disposable s) { emitter.setDisposable(s); }
@Override public void onSubscribe(Disposable disposable) { /* * We end up overwriting a disposable that was set to the observer in order to remove operation from queue. * This is ok since at this moment the operation is taken out of the queue anyway. */ operationResultObserver.setDisposable(disposable); }
@Override public void subscribe(final ObservableEmitter<Connectivity> emitter) throws Exception { final BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { emitter.onNext(Connectivity.create(context)); } }; context.registerReceiver(receiver, filter); Disposable disposable = disposeInUiThread(new Action() { @Override public void run() { tryToUnregisterReceiver(context, receiver); } }); emitter.setDisposable(disposable); } }).defaultIfEmpty(Connectivity.create());
private static <T> void cancelOnObservableDisposed(ObservableEmitter<T> emitter, final Cancelable cancelable) { emitter.setDisposable(getRx2Disposable(cancelable)); }
@Override public void subscribe(ObservableEmitter<Object> emitter) throws Exception { verifyMainThread(); EmitterListener listener = new EmitterListener(emitter); emitter.setDisposable(listener); view.addOnAttachStateChangeListener(listener); }
@Override public void subscribe(ObservableEmitter<T> tEmitter) throws Exception { final FIFORunnableEntry entry = new FIFORunnableEntry<>(operation, tEmitter); tEmitter.setDisposable(Disposables.fromAction(new Action() { @Override public void run() throws Exception { if (queue.remove(entry)) { logOperationRemoved(operation); } } })); logOperationQueued(operation); queue.add(entry); } });
@Override public void subscribe(ObservableEmitter<ByteAssociation<UUID>> emitter) { final DisposableObserver writeCallbackObserver = onCharacteristicWrite .subscribeWith(disposableObserverFromEmitter(emitter)); emitter.setDisposable(writeCallbackObserver); /* * Since Android OS calls {@link android.bluetooth.BluetoothGattCallback} callbacks on arbitrary background * threads - in case the {@link BluetoothGattCharacteristic} has * a {@link BluetoothGattCharacteristic#WRITE_TYPE_NO_RESPONSE} set it is possible that * a {@link android.bluetooth.BluetoothGattCallback#onCharacteristicWrite} may be called before the * {@link BluetoothGatt#writeCharacteristic(BluetoothGattCharacteristic)} will return. * Because of such a situation - it is important to first establish a full RxJava flow and only then * call writeCharacteristic. */ try { final byte[] bytesBatch = getNextBatch(byteBuffer, batchSize); writeData(bytesBatch); } catch (Throwable throwable) { emitter.onError(throwable); } } });
@Override protected void protectedRun(final ObservableEmitter<BluetoothGatt> emitter, final QueueReleaseInterface queueReleaseInterface) { final Action queueReleaseAction = new Action() { @Override public void run() { queueReleaseInterface.release(); } }; final DisposableSingleObserver<BluetoothGatt> disposableGattObserver = getConnectedBluetoothGatt() .compose(wrapWithTimeoutWhenNotAutoconnecting()) // when there are no subscribers there is no point of continuing work -> next will be disconnect operation .doFinally(queueReleaseAction) .subscribeWith(disposableSingleObserverFromEmitter(emitter)); emitter.setDisposable(disposableGattObserver); if (autoConnect) { // with autoConnect the connection may be established after a really long time queueReleaseInterface.release(); } }
@Override public void subscribe(ObservableEmitter<Integer> e) throws Exception { e.setDisposable(d); e.onNext(1); e.onNext(2); e.onNext(3); e.onError(new TestException()); e.onComplete(); e.onNext(4); e.onError(new TestException()); } })
@Override public void subscribe(ObservableEmitter<Integer> e) throws Exception { e.setDisposable(d); 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(ObservableEmitter<Integer> e) throws Exception { e = e.serialize(); e.setDisposable(d); e.onNext(1); e.onNext(2); e.onNext(3); e.onError(new TestException()); e.onComplete(); e.onNext(4); e.onError(new TestException()); } })
@Override public void subscribe(ObservableEmitter<Integer> e) throws Exception { e = e.serialize(); e.setDisposable(d); 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(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(@NonNull final ObservableEmitter<T> emitter) throws Exception { group.add(observerTag, observableTag, sourceObservable, emitter); emitter.setDisposable(managedObservableDisposable); } });
@Override public void subscribe(@NonNull final ObservableEmitter<T> emitter) throws Exception { emitter.setDisposable(new Disposable() { @Override public void dispose() { managedObservable.dispose(); } @Override public boolean isDisposed() { return managedObservable.isDisposed(); } }); managedObservable.resubscribe(emitter); } });
@Override public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception { emitter.setDisposable(new Disposable() { @Override public void dispose() { onUnsubscribe.run(); } @Override public boolean isDisposed() { return onUnsubscribe.called; } }); } });
@Override public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception { emitter.setDisposable(new Disposable() { @Override public void dispose() { dispose.run(); } @Override public boolean isDisposed() { return dispose.called; } }); } });
@Override public void subscribe(final ObservableEmitter<Boolean> emitter) throws Exception { if (!emitter.isDisposed()) { emitter.onNext(presenter.getState() == TiPresenter.State.VIEW_ATTACHED); } final Removable removable = presenter .addLifecycleObserver(new TiLifecycleObserver() { @Override public void onChange(final TiPresenter.State state, final boolean hasLifecycleMethodBeenCalled) { if (!emitter.isDisposed()) { emitter.onNext(state == TiPresenter.State.VIEW_ATTACHED && hasLifecycleMethodBeenCalled); } } }); emitter.setDisposable(new Disposable() { @Override public void dispose() { removable.remove(); } @Override public boolean isDisposed() { return removable.isRemoved(); } }); } }).distinctUntilChanged();
e.setDisposable(new Disposable() { @Override public void dispose() {