io.reactivex.CompletableSource Java Examples

/**
 * Creates an {@link ObservableTransformer} that will flatten the provided {@link Consumer} into
 * the stream as a {@link Completable} every time it receives an effect from the upstream effects
 * observable. This will result in calling the consumer on the specified scheduler, and passing it
 * the requested effect object.
 *
 * @param doEffect the {@link Consumer} to be run every time the effect is requested
 * @param scheduler the {@link Scheduler} to be used when invoking the consumer
 * @param <F> the type of Effect this transformer handles
 * @param <E> these transformers are for effects that do not result in any events; however, they
 *     still need to share the same Event type
 * @return an {@link ObservableTransformer} that can be used with a {@link
 *     SubtypeEffectHandlerBuilder}.
 */
static <F, E> ObservableTransformer<F, E> fromConsumer(
    final Consumer<F> doEffect, @Nullable final Scheduler scheduler) {
  return new ObservableTransformer<F, E>() {
    @Override
    public ObservableSource<E> apply(Observable<F> effectStream) {
      return effectStream
          .flatMapCompletable(
              new Function<F, CompletableSource>() {
                @Override
                public CompletableSource apply(final F effect) throws Exception {
                  Completable completable =
                      Completable.fromAction(
                          new Action() {
                            @Override
                            public void run() throws Exception {
                              doEffect.accept(effect);
                            }
                          });
                  return scheduler == null ? completable : completable.subscribeOn(scheduler);
                }
              })
          .toObservable();
    }
  };
}
 

/**
 * Creates an {@link ObservableTransformer} that will flatten the provided {@link Action} into the
 * stream as a {@link Completable} every time it receives an effect from the upstream effects
 * observable. This Completable will be subscribed on the specified {@link Scheduler}. This will
 * result in calling the provided Action on the specified scheduler every time an effect is
 * dispatched to the created effect transformer.
 *
 * @param doEffect the {@link Action} to be run every time the effect is requested
 * @param scheduler the {@link Scheduler} that the action should be run on
 * @param <F> the type of Effect this transformer handles
 * @param <E> these transformers are for effects that do not result in any events; however, they
 *     still need to share the same Event type
 * @return an {@link ObservableTransformer} that can be used with a {@link
 *     SubtypeEffectHandlerBuilder}.
 */
static <F, E> ObservableTransformer<F, E> fromAction(
    final Action doEffect, @Nullable final Scheduler scheduler) {
  return new ObservableTransformer<F, E>() {
    @Override
    public ObservableSource<E> apply(Observable<F> effectStream) {
      return effectStream
          .flatMapCompletable(
              new Function<F, CompletableSource>() {
                @Override
                public CompletableSource apply(F f) throws Exception {
                  return scheduler == null
                      ? Completable.fromAction(doEffect)
                      : Completable.fromAction(doEffect).subscribeOn(scheduler);
                }
              })
          .toObservable();
    }
  };
}
 

@Override
public CompletableSource apply(Completable upstream) {
    switch (mSchedulerType) {
        case _main:
            return upstream.observeOn(AndroidSchedulers.mainThread());
        case _io:
            return upstream.observeOn(RxSchedulerUtils.io(mIOExecutor));
        case _io_main:
            return upstream
                    .subscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .unsubscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .observeOn(AndroidSchedulers.mainThread());
        case _io_io:
            return upstream
                    .subscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .unsubscribeOn(RxSchedulerUtils.io(mIOExecutor))
                    .observeOn(RxSchedulerUtils.io(mIOExecutor));
        default:
            break;
    }
    return upstream;
}
 

@Override
public Completable writeDescriptor(
        @NonNull final UUID serviceUuid, @NonNull final UUID characteristicUuid, @NonNull final UUID descriptorUuid,
        @NonNull final byte[] data
) {
    return discoverServices()
            .flatMap(new Function<RxBleDeviceServices, SingleSource<BluetoothGattDescriptor>>() {
                @Override
                public SingleSource<BluetoothGattDescriptor> apply(RxBleDeviceServices rxBleDeviceServices) {
                    return rxBleDeviceServices.getDescriptor(serviceUuid, characteristicUuid, descriptorUuid);
                }
            })
            .flatMapCompletable(new Function<BluetoothGattDescriptor, CompletableSource>() {
                @Override
                public CompletableSource apply(BluetoothGattDescriptor bluetoothGattDescriptor) {
                    return writeDescriptor(bluetoothGattDescriptor, data);
                }
            });
}
 

public static Completable wrap(
  CompletableSource source, CurrentTraceContext contextScoper, TraceContext assembled) {
  if (source instanceof Callable) {
    return new TraceContextCallableCompletable<>(source, contextScoper, assembled);
  }
  return new TraceContextCompletable(source, contextScoper, assembled);
}
 

@Override
public CompletableSource apply(Completable upstream) {
  return sqlConnection.rxSetAutoCommit(false)
    .andThen(upstream)
    .andThen(sqlConnection.rxCommit())
    .onErrorResumeNext(throwable -> {
      return sqlConnection.rxRollback().onErrorComplete()
        .andThen(sqlConnection.rxSetAutoCommit(true).onErrorComplete())
        .andThen(Completable.error(throwable));
    }).andThen(sqlConnection.rxSetAutoCommit(true));
}
 

private Disposable loadImage(final Uri uri) {
  mSourceUri = uri;
  return new RxPermissions(getActivity()).request(Manifest.permission.WRITE_EXTERNAL_STORAGE)
      .filter(new Predicate<Boolean>() {
        @Override public boolean test(@io.reactivex.annotations.NonNull Boolean granted)
            throws Exception {
          return granted;
        }
      })
      .flatMapCompletable(new Function<Boolean, CompletableSource>() {
        @Override
        public CompletableSource apply(@io.reactivex.annotations.NonNull Boolean aBoolean)
            throws Exception {
          return mCropView.load(uri)
              .useThumbnail(true)
              .initialFrameRect(mFrameRect)
              .executeAsCompletable();
        }
      })
      .subscribeOn(Schedulers.newThread())
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe(new Action() {
        @Override public void run() throws Exception {
        }
      }, new Consumer<Throwable>() {
        @Override public void accept(@NonNull Throwable throwable) throws Exception {
        }
      });
}
 

@Override
public CompletableSource apply(Completable upstream) {
    return Completable.ambArray(upstream, observable.flatMapCompletable(new Function<Object, Completable>() {
        @Override
        public Completable apply(Object ignore) throws Exception {
            return Completable.error(new CancellationException());
        }
    }));
}
 

@SuppressLint("CheckResult")
private void sendHeartBeat(@NonNull String pingMessage) {
    Completable completable = connectionProvider.send(pingMessage);
    CompletableSource connectionComplete = getConnectionStream()
            .filter(isConnected -> isConnected)
            .firstElement().ignoreElement();
    completable.startWith(connectionComplete)
            .onErrorComplete()
            .subscribe();
}
 

public Completable send(@NonNull StompMessage stompMessage) {
    Completable completable = connectionProvider.send(stompMessage.compile(legacyWhitespace));
    CompletableSource connectionComplete = getConnectionStream()
            .filter(isConnected -> isConnected)
            .firstElement().ignoreElement();
    return completable
            .startWith(connectionComplete);
}
 

@Override
public CompletableSource apply(Completable upstream) {
    if (mLifecycleTransformer != null) {
        upstream = upstream.compose(mLifecycleTransformer);
    }
    return upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
}
 

@Override
public CompletableSource apply(Completable upstream) {
    if (mLifecycleTransformer != null) {
        upstream = upstream.compose(mLifecycleTransformer);
    }
    return upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
}
 

/**
 * TakeUntil n'existe pas sur un completable. Amb permet de la premère émission
 *
 * @param upstream
 * @return
 */
@Override
public CompletableSource apply(Completable upstream) {
    return Completable.ambArray(upstream, mObservable.flatMapCompletable(new Function<Object, CompletableSource>() {
        @Override
        public CompletableSource apply(@NonNull Object o) throws Exception {
            return Completable.error(new CancellationException());
        }
    }));
}
 

@Override
public CompletableSource apply(Completable upstream) {
    Completable tObservable = upstream
            .observeOn(AndroidSchedulers.mainThread());
    if (provider == null) {
        return tObservable;
    }
    return tObservable.compose(RxLifecycleDelegate.<T>bindLifecycle(provider));
}
 

@Override
public CompletableSource apply(Completable upstream) {
    return Completable.ambArray(upstream, mObservable.flatMapCompletable(
        new Function<Object, CompletableSource>() {
            @Override
            public CompletableSource apply(Object t) throws Exception {
                return Completable.complete();
            }
        }));
}
 

private CompletableSource publishThroughput(List<KafkaConsumerRecord<String, JsonObject>> records) {
  KafkaProducerRecord<String, JsonObject> record = KafkaProducerRecord.create("event-stats.throughput", new JsonObject()
    .put("seconds", 5)
    .put("count", records.size())
    .put("throughput", (((double) records.size()) / 5.0d)));
  return producer.rxWrite(record);
}
 

private static void racePauseResuming(final TestCallStreamObserver<?> downstream, int times) {
    Observable.range(0, times)
              .concatMapCompletable(new Function<Integer, CompletableSource>() {
                  @Override
                  public CompletableSource apply(Integer i) {
                      return Completable
                          .fromAction(new Action() {
                              @Override
                              public void run() {
                                  downstream.resume();
                              }
                          })
                          .subscribeOn(Schedulers.computation())
                          .andThen(Completable
                              .fromAction(
                                  new Action() {
                                      @Override
                                      public void run() {
                                          downstream.pause();
                                      }
                                  }
                              )
                              .subscribeOn(Schedulers.computation())
                          );
                  }
              })
              .blockingAwait();

    downstream.pause();
    executorService.execute(new Runnable() {
        @Override
        public void run() {
            downstream.resume();
        }
    });
}
 

@NonNull
static Completable writeClientCharacteristicConfig(
        final BluetoothGattCharacteristic bluetoothGattCharacteristic,
        final DescriptorWriter descriptorWriter,
        final byte[] value
) {
    final BluetoothGattDescriptor descriptor = bluetoothGattCharacteristic.getDescriptor(CLIENT_CHARACTERISTIC_CONFIG_UUID);
    if (descriptor == null) {
        return Completable.error(new BleCannotSetCharacteristicNotificationException(
                bluetoothGattCharacteristic,
                BleCannotSetCharacteristicNotificationException.CANNOT_FIND_CLIENT_CHARACTERISTIC_CONFIG_DESCRIPTOR,
                null
        ));
    }

    return descriptorWriter.writeDescriptor(descriptor, value)
            .onErrorResumeNext(new Function<Throwable, CompletableSource>() {
                @Override
                public CompletableSource apply(Throwable throwable) {
                    return Completable.error(new BleCannotSetCharacteristicNotificationException(
                            bluetoothGattCharacteristic,
                            BleCannotSetCharacteristicNotificationException.CANNOT_WRITE_CLIENT_CHARACTERISTIC_CONFIG_DESCRIPTOR,
                            throwable
                    ));
                }
            });
}
 

@Override
public CompletableSource apply(Completable upstream) {
    return Completable.ambArray(upstream, mObservable.flatMapCompletable(
        new Function<Object, CompletableSource>() {
            @Override
            public CompletableSource apply(Object t) throws Exception {
                return Completable.complete();
            }
        }));
}
 

@Override
public CompletableSource apply(Completable upstream) {
    return Completable.ambArray(upstream, mObservable.flatMapCompletable(
        new Function<Object, CompletableSource>() {
            @Override
            public CompletableSource apply(Object t) throws Exception {
                return Completable.complete();
            }
        }));
}
 

@Override
public final CompletableSource requestScope() {
  return LifecycleScopes.resolveScopeFromLifecycle(this);
}
 

@Override
public CompletableSource requestScope() {
  return workerLifecycleObservable.skip(1).firstElement().ignoreElement();
}
 

@Override
public CompletableSource requestScope() {
  return lifecycleRelay.skip(1).firstElement().ignoreElement();
}
 

@Override
public CompletableSource requestScope() {
  return LifecycleScopes.resolveScopeFromLifecycle(this);
}
 

RequestContextScalarCallableCompletable(CompletableSource source, RequestContext assemblyContext) {
    this.source = source;
    this.assemblyContext = assemblyContext;
}
 

RequestContextCompletable(CompletableSource source, RequestContext assemblyContext) {
    this.source = source;
    this.assemblyContext = assemblyContext;
}
 

RequestContextCallableCompletable(CompletableSource source, RequestContext assemblyContext) {
    this.source = source;
    this.assemblyContext = assemblyContext;
}
 

private CompletableSource publishUserActivityUpdate(JsonObject data) {
  return producer.rxWrite(
    KafkaProducerRecord.create("event-stats.user-activity.updates", data.getString("username"), data));
}
 

TraceContextCompletable(
  CompletableSource source, CurrentTraceContext contextScoper, TraceContext assembled) {
  this.source = source;
  this.contextScoper = contextScoper;
  this.assembled = assembled;
}
 

TraceContextCallableCompletable(
  CompletableSource source, CurrentTraceContext contextScoper, TraceContext assembled) {
  this.source = source;
  this.contextScoper = contextScoper;
  this.assembled = assembled;
}