com.spotify.mobius.rx2.RxEventSources Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mobius-rx2 Show documentation
RxJava2 utilities for use with Mobius
The newest version!
/*
 * -\-\-
 * Mobius
 * --
 * Copyright (c) 2017-2020 Spotify AB
 * --
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * -/-/-
 */
package com.spotify.mobius.rx2;

import com.spotify.mobius.EventSource;
import com.spotify.mobius.disposables.Disposable;
import com.spotify.mobius.functions.Consumer;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.functions.Cancellable;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.annotation.Nonnull;

/**
 * Contains utility methods for converting back and forth between {@link Observable}s and {@link
 * EventSource}s.
 */
public final class RxEventSources {

  private RxEventSources() {}

  /**
   * Create an event source from the given RxJava streams.
   *
   * All streams must be mapped to your event type.
   *
   * @param sources the observables you want to include in this event source
   * @param  the event type
   * @return an EventSource based on the provided observables
   */
  @SafeVarargs
  public static  EventSource fromObservables(ObservableSource... sources) {
    final Observable eventSource = Observable.mergeArray(sources);

    return new EventSource() {
      @Nonnull
      @Override
      public Disposable subscribe(final Consumer eventConsumer) {
        final AtomicBoolean disposed = new AtomicBoolean();
        final io.reactivex.disposables.Disposable disposable =
            eventSource.subscribe(
                value -> {
                  synchronized (disposed) {
                    if (!disposed.get()) {
                      eventConsumer.accept(value);
                    }
                  }
                });
        return () -> {
          synchronized (disposed) {
            disposable.dispose();
            disposed.set(true);
          }
        };
      }
    };
  }

  /**
   * Create an observable from the given event source.
   *
   * @param eventSource the eventSource you want to convert to an observable
   * @param  the event type
   * @return an Observable based on the provided event source
   */
  public static  Observable toObservable(final EventSource eventSource) {
    return Observable.create(
        new ObservableOnSubscribe() {
          @Override
          public void subscribe(final ObservableEmitter emitter) throws Exception {
            final Disposable disposable =
                eventSource.subscribe(
                    new Consumer() {
                      @Override
                      public void accept(E value) {
                        emitter.onNext(value);
                      }
                    });

            emitter.setCancellable(
                new Cancellable() {
                  @Override
                  public void cancel() throws Exception {
                    disposable.dispose();
                  }
                });
          }
        });
  }
}