retryWhen<T> method

Stream<T> retryWhen <T>(
  1. Stream<T> streamFactory(
      ),
    1. Stream<void> retryWhenFactory(
      1. dynamic error,
      2. StackTrace stack
      )
    )

    Creates a Stream that will recreate and re-listen to the source Stream when the notifier emits a new value. If the source Stream emits an error or it completes, the Stream terminates.

    If the retryWhenFactory emits an error a RetryError will be thrown. The RetryError will contain all of the Errors and StackTraces that caused the failure.

    Basic Example

    RetryWhenStream<int>(
      () => Stream<int>.fromIterable(<int>[1]),
      (dynamic error, StackTrace s) => throw error,
    ).listen(print); // Prints 1
    

    Periodic Example

    RetryWhenStream<int>(
      () => Stream<int>
          .periodic(const Duration(seconds: 1), (int i) => i)
          .map((int i) => i == 2 ? throw 'exception' : i),
      (dynamic e, StackTrace s) {
        return Rx.timer('random value', const Duration(milliseconds: 200);
      },
    ).take(4).listen(print); // Prints 0, 1, 0, 1
    

    Complex Example

    bool errorHappened = false;
    RetryWhenStream(
      () => Stream
          .periodic(const Duration(seconds: 1), (i) => i)
          .map((i) {
            if (i == 3 && !errorHappened) {
              throw 'We can take this. Please restart.';
            } else if (i == 4) {
              throw 'It\'s enough.';
            } else {
              return i;
            }
          }),
      (e, s) {
        errorHappened = true;
        if (e == 'We can take this. Please restart.') {
          return Stream.value('Ok. Here you go!');
        } else {
          return Stream.error(e);
        }
      },
    ).listen(
      print,
      onError: (e, s) => print(e),
    ); // Prints 0, 1, 2, 0, 1, 2, 3, RetryError
    

    Implementation

    static Stream<T> retryWhen<T>(
      Stream<T> Function() streamFactory,
      Stream<void> Function(dynamic error, StackTrace stack) retryWhenFactory,
    ) =>
        RetryWhenStream<T>(streamFactory, retryWhenFactory);