com.contentful.java.cda.Callbacks Maven / Gradle / Ivy

package com.contentful.java.cda;

import io.reactivex.rxjava3.core.Flowable;
import io.reactivex.rxjava3.flowables.ConnectableFlowable;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.schedulers.Schedulers;

final class Callbacks {
  private Callbacks() {
    throw new AssertionError();
  }

  static  CDACallback subscribeAsync(
          Flowable flowable, CDACallback callback, CDAClient client) {
    ConnectableFlowable connectable = flowable.observeOn(Schedulers.io()).publish();

    callback.setSubscription(connectable.subscribe(
        new SuccessAction<>(callback, client),
        new FailureAction(callback, client)));

    connectable.connect();

    return callback;
  }

  abstract static class BaseAction implements Consumer {
    protected final CDACallback callback;

    protected final CDAClient client;

    BaseAction(CDACallback callback, CDAClient client) {
      this.callback = callback;
      this.client = client;
    }

    @Override public void accept(E e) {
      if (!callback.isCancelled()) {
        doCall(e);
      }
      callback.unsubscribe();
    }

    protected abstract void doCall(E e);

    protected void execute(Runnable r) {
      client.callbackExecutor.execute(r);
    }
  }

  static class SuccessAction extends BaseAction {
    SuccessAction(CDACallback callback, CDAClient client) {
      super(callback, client);
    }

    @SuppressWarnings("unchecked")
    @Override
    protected void doCall(E e) {
      execute(new SuccessRunnable<>(e, (CDACallback) callback));
    }
  }

  static class FailureAction extends BaseAction {
    FailureAction(CDACallback callback, CDAClient client) {
      super(callback, client);
    }

    @Override protected void doCall(Throwable t) {
      execute(new FailureRunnable(t, callback));
    }
  }

  static class SuccessRunnable implements Runnable {
    private final E result;

    private final CDACallback callback;

    SuccessRunnable(E result, CDACallback callback) {
      this.result = result;
      this.callback = callback;
    }

    @Override public void run() {
      if (!callback.isCancelled()) {
        callback.onSuccess(result);
      }
    }
  }

  static class FailureRunnable implements Runnable {
    private final Throwable throwable;

    private final CDACallback callback;

    FailureRunnable(Throwable throwable, CDACallback callback) {
      this.throwable = throwable;
      this.callback = callback;
    }

    @Override public void run() {
      if (!callback.isCancelled()) {
        callback.onFailure(throwable);
      }
    }
  }
}