Observable Class Reference

A handler called upon subscription to an observable with the observer.

Ensures that Observers to the returned observable are always subscribed on the provided queue.

Ensures that Observers to the returned observable are always called on the provided queue.

Transforms the events provided to the observable into new events before calling the observers of the new observable.

Transforms the events provided to the observable into new events, stripping out the nil events, before calling the observers of the new observable.

Only report the events that are included by the provided filter.

Transforms an event by providing a new observable that is flattened in the observable that is returned by this method.

Transforms an event by providing a new observable that is flattened in the observable that is returned by this method. Every new observable returned will cancel the old observable subscriptions, therefore only emitting events for the latest returned observable.

As a very simplified example, the following code causes an endless loop:

 let subject = Subject<Int>()
 _ = subject.asObservable().flatMapLatest { value in
     Observable<Int> { observer in
         // This is the block that is called on each `subscribe` call
         subject.publish(value + 1)
         observer(value)
         return Subscription(unsubscribe: {})
     }
 }.subscribe { _ in }
 subject.publish(0)

The following, instead, has an exit condition, so it’s safe to use:

 let subject = Subject<Int>()
 _ = subject.asObservable().flatMapLatest { value in
     Observable<Int> { observer in
         // This is the block that is called on each `subscribe` call
         if value < 10 {
             subject.publish(value + 1)
         }
         observer(value)
         return Subscription(unsubscribe: {})
     }
 }.subscribe { _ in }
 subject.publish(0)

On subscription emits the provided elements before providing the other events from the original observable.

Returns a new observable that emits the events of the original observable and the otherObservable passed as parameter.

Returns an observable that emits only the first event that is included by the provided filter.

If you don’t provide a block then the first event will always be taken. After the first event is published it automatically disposes the observer.

Returns a new observable that will emit events with a tuple containing the last event of the original and the provided observable.

The first event will be fired when both observable have emitted at least one event. Then a new event with the tuple will be emitted every time one of the two emits a new event.

Returns an observable that ignores the first N published events.

Returns an observable that ignores the first published events.

Unsubscribes and subscribes again on each event while the condition is met.

This is mainly used for cold observables that, when subscribed, start a new stream from zero. Use when you want to trigger the underlying observable to restart every time.

Returns an observable that automatically unsubscribes when the provided condition is no longer met. If inclusive is true the last element will also be published.

Returns an observable that emits subsequent values only if they are different from the last one emitted by the underlying observable.

Returns a Single that only emits the first value from the underlying observable, on the given TealiumQueue.

Returns an observable that will emit values in a possibly asynchronous manner determined by the given block.

Returns an observable that will emit values in a possibly asynchronous manner determined by the given block.

Returns an observable that will emit the last element received after the provided delay if no other event is emitted in the meantime.

Returns an observable that emits each emitted value after a set time.

Subscribes the observer only once and then automatically disposes it.

This is meant to be used when you only need one observer to be registered once. Use the standalone first() operator if multiple observers all need to register for one event.

Only emits new events if the last one is different from the new one.