io.reactivex.rxjava3.flowables

Class ConnectableFlowable<T>

java.lang.Object

io.reactivex.rxjava3.core.Flowable<T>

io.reactivex.rxjava3.flowables.ConnectableFlowable<T>

Type Parameters:

T - the type of items emitted by the ConnectableFlowable

All Implemented Interfaces:

Publisher<T>

public abstract class ConnectableFlowable<T>
extends Flowable<T>

A ConnectableFlowable resembles an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, but only when its connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called. In this way you can wait for all intended Subscribers to Flowable.subscribe() to the Flowable before the Flowable begins emitting items.

When the upstream terminates, the ConnectableFlowable remains in this terminated state and, depending on the actual underlying implementation, relays cached events to late Subscribers. In order to reuse and restart this ConnectableFlowable, the reset() method has to be called. When called, this ConnectableFlowable will appear as fresh, unconnected source to new Subscribers. Disposing the connection will reset the ConnectableFlowable to its fresh state and there is no need to call reset() in this case.

Note that although connect() and reset() are safe to call from multiple threads, it is recommended a dedicated thread or business logic manages the connection or resetting of a ConnectableFlowable so that there is no unwanted signal loss due to early connect() or reset() calls while Subscribers are still being subscribed to to this ConnectableFlowable to receive signals from the get go.

Since:

2.0.0

See Also:

RxJava Wiki: Connectable Observable Operators

Constructor Summary

Constructors

Constructor and Description
ConnectableFlowable()

Method Summary

Modifier and Type	Method and Description
Flowable<T>	autoConnect() Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the first Subscriber subscribes.
Flowable<T>	autoConnect(int numberOfSubscribers) Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it.
Flowable<T>	autoConnect(int numberOfSubscribers, Consumer<? super Disposable> connection) Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it and calls the specified callback with the Subscription associated with the established connection.
Disposable	connect() Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.
abstract void	connect(Consumer<? super Disposable> connection) Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.
Flowable<T>	refCount() Returns a Flowable that stays connected to this ConnectableFlowable as long as there is at least one subscription to this ConnectableFlowable.
Flowable<T>	refCount(int subscriberCount) Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.
Flowable<T>	refCount(int subscriberCount, long timeout, TimeUnit unit) Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
Flowable<T>	refCount(int subscriberCount, long timeout, TimeUnit unit, Scheduler scheduler) Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
Flowable<T>	refCount(long timeout, TimeUnit unit) Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.
Flowable<T>	refCount(long timeout, TimeUnit unit, Scheduler scheduler) Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.
abstract void	reset() Resets this ConnectableFlowable into its fresh state if it has terminated.

Methods inherited from class io.reactivex.rxjava3.core.Flowable

all, amb, ambArray, ambWith, any, blockingFirst, blockingFirst, blockingForEach, blockingIterable, blockingIterable, blockingLast, blockingLast, blockingLatest, blockingMostRecent, blockingNext, blockingSingle, blockingSingle, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, bufferSize, cache, cacheWithInitialCapacity, cast, collect, collectInto, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatestArray, combineLatestArray, combineLatestDelayError, combineLatestDelayError, combineLatestDelayError, combineLatestDelayError, compose, concat, concat, concat, concat, concat, concat, concatArray, concatArrayDelayError, concatArrayEager, concatArrayEager, concatArrayEagerDelayError, concatArrayEagerDelayError, concatDelayError, concatDelayError, concatDelayError, concatEager, concatEager, concatEager, concatEager, concatMap, concatMap, concatMap, concatMapCompletable, concatMapCompletable, concatMapCompletableDelayError, concatMapCompletableDelayError, concatMapCompletableDelayError, concatMapDelayError, concatMapDelayError, concatMapDelayError, concatMapEager, concatMapEager, concatMapEagerDelayError, concatMapEagerDelayError, concatMapIterable, concatMapIterable, concatMapMaybe, concatMapMaybe, concatMapMaybeDelayError, concatMapMaybeDelayError, concatMapMaybeDelayError, concatMapSingle, concatMapSingle, concatMapSingleDelayError, concatMapSingleDelayError, concatMapSingleDelayError, concatWith, concatWith, concatWith, concatWith, contains, count, create, debounce, debounce, debounce, defaultIfEmpty, defer, delay, delay, delay, delay, delay, delay, delaySubscription, delaySubscription, delaySubscription, dematerialize, distinct, distinct, distinct, distinctUntilChanged, distinctUntilChanged, distinctUntilChanged, doAfterNext, doAfterTerminate, doFinally, doOnCancel, doOnComplete, doOnEach, doOnEach, doOnError, doOnLifecycle, doOnNext, doOnRequest, doOnSubscribe, doOnTerminate, elementAt, elementAt, elementAtOrError, empty, error, error, filter, first, firstElement, firstOrError, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMap, flatMapCompletable, flatMapCompletable, flatMapIterable, flatMapIterable, flatMapIterable, flatMapIterable, flatMapMaybe, flatMapMaybe, flatMapSingle, flatMapSingle, forEach, forEachWhile, forEachWhile, forEachWhile, fromArray, fromCallable, fromFuture, fromFuture, fromFuture, fromFuture, fromIterable, fromPublisher, fromSupplier, generate, generate, generate, generate, generate, groupBy, groupBy, groupBy, groupBy, groupBy, groupBy, groupJoin, hide, ignoreElements, interval, interval, interval, interval, intervalRange, intervalRange, isEmpty, join, just, just, just, just, just, just, just, just, just, just, last, lastElement, lastOrError, lift, map, materialize, merge, merge, merge, merge, merge, merge, merge, merge, mergeArray, mergeArray, mergeArrayDelayError, mergeArrayDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeWith, mergeWith, mergeWith, mergeWith, never, observeOn, observeOn, observeOn, ofType, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureDrop, onBackpressureDrop, onBackpressureLatest, onErrorResumeNext, onErrorResumeWith, onErrorReturn, onErrorReturnItem, onTerminateDetach, parallel, parallel, parallel, publish, publish, publish, publish, range, rangeLong, rebatchRequests, reduce, reduce, reduceWith, repeat, repeat, repeatUntil, repeatWhen, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, replay, retry, retry, retry, retry, retry, retryUntil, retryWhen, safeSubscribe, sample, sample, sample, sample, sample, sample, scan, scan, scanWith, sequenceEqual, sequenceEqual, sequenceEqual, sequenceEqual, serialize, share, single, singleElement, singleOrError, skip, skip, skip, skipLast, skipLast, skipLast, skipLast, skipLast, skipLast, skipUntil, skipWhile, sorted, sorted, startWith, startWithArray, startWithItem, startWithIterable, subscribe, subscribe, subscribe, subscribe, subscribe, subscribe, subscribeActual, subscribeOn, subscribeOn, subscribeWith, switchIfEmpty, switchMap, switchMap, switchMapCompletable, switchMapCompletableDelayError, switchMapDelayError, switchMapDelayError, switchMapMaybe, switchMapMaybeDelayError, switchMapSingle, switchMapSingleDelayError, switchOnNext, switchOnNext, switchOnNextDelayError, switchOnNextDelayError, take, take, take, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeLast, takeUntil, takeUntil, takeWhile, test, test, test, throttleFirst, throttleFirst, throttleLast, throttleLast, throttleLatest, throttleLatest, throttleLatest, throttleLatest, throttleWithTimeout, throttleWithTimeout, timeInterval, timeInterval, timeInterval, timeInterval, timeout, timeout, timeout, timeout, timeout, timeout, timeout, timeout, timer, timer, timestamp, timestamp, timestamp, timestamp, to, toFuture, toList, toList, toList, toMap, toMap, toMap, toMultimap, toMultimap, toMultimap, toMultimap, toObservable, toSortedList, toSortedList, toSortedList, toSortedList, unsafeCreate, unsubscribeOn, using, using, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, window, withLatestFrom, withLatestFrom, withLatestFrom, withLatestFrom, withLatestFrom, withLatestFrom, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipArray, zipWith, zipWith, zipWith, zipWith

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ConnectableFlowable

public ConnectableFlowable()

Method Detail

connect

public abstract void connect(@NonNull Consumer<? super Disposable> connection)

Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.

Parameters:

connection - the action that receives the connection subscription before the subscription to source happens allowing the caller to synchronously disconnect a synchronous source

See Also:

ReactiveX documentation: Connect

reset

public abstract void reset()

Resets this ConnectableFlowable into its fresh state if it has terminated.

Calling this method on a fresh or active ConnectableFlowable has no effect.

Since:

3.0.0

connect

public final Disposable connect()

Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.

To disconnect from a synchronous source, use the connect(io.reactivex.rxjava3.functions.Consumer) method.

Returns:

the subscription representing the connection

See Also:

ReactiveX documentation: Connect

refCount

@NonNull
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public Flowable<T> refCount()

Returns a Flowable that stays connected to this ConnectableFlowable as long as there is at least one subscription to this ConnectableFlowable.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the upstream ConnectableFlowable's backpressure behavior.

Scheduler:

This refCount overload does not operate on any particular Scheduler.

Returns:

a Flowable

See Also:

ReactiveX documentation: RefCount, refCount(int), refCount(long, TimeUnit), refCount(int, long, TimeUnit)

refCount

@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final Flowable<T> refCount(int subscriberCount)

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the upstream ConnectableFlowable's backpressure behavior.

Scheduler:

This refCount overload does not operate on any particular Scheduler.

History: 2.1.14 - experimental

Parameters:

subscriberCount - the number of subscribers required to connect to the upstream

Returns:

the new Flowable instance

Since:

2.2

refCount

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @BackpressureSupport(value=PASS_THROUGH)
public final Flowable<T> refCount(long timeout,
        TimeUnit unit)

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the upstream ConnectableFlowable's backpressure behavior.

Scheduler:

This refCount overload operates on the computation Scheduler.

History: 2.1.14 - experimental

Parameters:

timeout - the time to wait before disconnecting after all subscribers unsubscribed

unit - the time unit of the timeout

Returns:

the new Flowable instance

Since:

2.2

See Also:

refCount(long, TimeUnit, Scheduler)

refCount

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @BackpressureSupport(value=PASS_THROUGH)
public final Flowable<T> refCount(long timeout,
        TimeUnit unit,
        Scheduler scheduler)

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the upstream ConnectableFlowable's backpressure behavior.

Scheduler:

This refCount overload operates on the specified Scheduler.

History: 2.1.14 - experimental

Parameters:

timeout - the time to wait before disconnecting after all subscribers unsubscribed

unit - the time unit of the timeout

scheduler - the target scheduler to wait on before disconnecting

Returns:

the new Flowable instance

Since:

2.2

refCount

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @BackpressureSupport(value=PASS_THROUGH)
public final Flowable<T> refCount(int subscriberCount,
        long timeout,
        TimeUnit unit)

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the upstream ConnectableFlowable's backpressure behavior.

Scheduler:

This refCount overload operates on the computation Scheduler.

History: 2.1.14 - experimental

Parameters:

subscriberCount - the number of subscribers required to connect to the upstream

timeout - the time to wait before disconnecting after all subscribers unsubscribed

unit - the time unit of the timeout

Returns:

the new Flowable instance

Since:

2.2

See Also:

refCount(int, long, TimeUnit, Scheduler)

refCount

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @BackpressureSupport(value=PASS_THROUGH)
public final Flowable<T> refCount(int subscriberCount,
        long timeout,
        TimeUnit unit,
        Scheduler scheduler)

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.

Backpressure:

The operator itself doesn't interfere with backpressure which is determined by the upstream ConnectableFlowable's backpressure behavior.

Scheduler:

This refCount overload operates on the specified Scheduler.

History: 2.1.14 - experimental

Parameters:

subscriberCount - the number of subscribers required to connect to the upstream

timeout - the time to wait before disconnecting after all subscribers unsubscribed

unit - the time unit of the timeout

scheduler - the target scheduler to wait on before disconnecting

Returns:

the new Flowable instance

Since:

2.2

autoConnect

@NonNull
public Flowable<T> autoConnect()

Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the first Subscriber subscribes.

The connection happens after the first subscription and happens at most once during the lifetime of the returned Flowable. If this ConnectableFlowable terminates, the connection is never renewed, no matter how Subscribers come and go. Use refCount() to renew a connection or dispose an active connection when all Subscribers have cancelled their Subscriptions.

This overload does not allow disconnecting the connection established via connect(Consumer). Use the autoConnect(int, Consumer) overload to gain access to the Disposable representing the only connection.

Returns:

a Flowable that automatically connects to this ConnectableFlowable when the first Subscriber subscribes

See Also:

refCount(), autoConnect(int, Consumer)

autoConnect

@NonNull
public Flowable<T> autoConnect(int numberOfSubscribers)

Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it.

The connection happens after the given number of subscriptions and happens at most once during the lifetime of the returned Flowable. If this ConnectableFlowable terminates, the connection is never renewed, no matter how Subscribers come and go. Use refCount() to renew a connection or dispose an active connection when all Subscribers have cancelled their Subscriptions.

This overload does not allow disconnecting the connection established via connect(Consumer). Use the autoConnect(int, Consumer) overload to gain access to the Disposable representing the only connection.

Parameters:

numberOfSubscribers - the number of subscribers to await before calling connect on the ConnectableFlowable. A non-positive value indicates an immediate connection.

Returns:

a Flowable that automatically connects to this ConnectableFlowable when the specified number of Subscribers subscribe to it

autoConnect

@NonNull
public Flowable<T> autoConnect(int numberOfSubscribers,
        @NonNull Consumer<? super Disposable> connection)

Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it and calls the specified callback with the Subscription associated with the established connection.

The connection happens after the given number of subscriptions and happens at most once during the lifetime of the returned Flowable. If this ConnectableFlowable terminates, the connection is never renewed, no matter how Subscribers come and go. Use refCount() to renew a connection or dispose an active connection when all Subscribers have cancelled their Subscriptions.

Parameters:

numberOfSubscribers - the number of subscribers to await before calling connect on the ConnectableFlowable. A non-positive value indicates an immediate connection.

connection - the callback Consumer that will receive the Subscription representing the established connection

Returns:

a Flowable that automatically connects to this ConnectableFlowable when the specified number of Subscribers subscribe to it and calls the specified callback with the Subscription associated with the established connection