com.spotify.mobius.rx3.RxMobiusLoop Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mobius-rx3 Show documentation
RxJava3 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.rx3;

import com.spotify.mobius.MobiusLoop;
import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.ObservableEmitter;
import io.reactivex.rxjava3.core.ObservableOnSubscribe;
import io.reactivex.rxjava3.core.ObservableSource;
import io.reactivex.rxjava3.core.ObservableTransformer;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.functions.Cancellable;
import io.reactivex.rxjava3.functions.Consumer;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * Wraps a MobiusLoop into an observable transformer.
 *
 * Compose it on top of an event of streams to convert it into a stream of models.
 */
class RxMobiusLoop implements ObservableTransformer {

  @Nonnull private final MobiusLoop.Factory loopFactory;
  @Nonnull private final M startModel;
  @Nullable private final Set startEffects;

  RxMobiusLoop(
      MobiusLoop.Factory loopFactory, M startModel, @Nullable Set startEffects) {
    this.loopFactory = loopFactory;
    this.startModel = startModel;
    this.startEffects = startEffects;
  }

  @Override
  public ObservableSource apply(@NonNull Observable upstream) {
    return Observable.create(
        new ObservableOnSubscribe() {
          @Override
          public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
            final MobiusLoop loop;

            if (startEffects == null) {
              loop = loopFactory.startFrom(startModel);
            } else {
              loop = loopFactory.startFrom(startModel, startEffects);
            }

            loop.observe(
                new com.spotify.mobius.functions.Consumer() {
                  @Override
                  public void accept(M value) {
                    emitter.onNext(value);
                  }
                });
            final Disposable eventsDisposable =
                upstream.subscribe(
                    new Consumer() {
                      @Override
                      public void accept(E event) throws Throwable {
                        loop.dispatchEvent(event);
                      }
                    },
                    new Consumer() {
                      @Override
                      public void accept(Throwable throwable) throws Throwable {
                        emitter.onError(new UnrecoverableIncomingException(throwable));
                      }
                    });
            emitter.setCancellable(
                new Cancellable() {
                  @Override
                  public void cancel() throws Throwable {
                    loop.dispose();
                    eventsDisposable.dispose();
                  }
                });
          }
        });
  }
}