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

Go to download
package com.contentful.java.cda;

import rx.Observable;
import rx.functions.Action1;
import rx.observables.ConnectableObservable;
import rx.schedulers.Schedulers;

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

  static  CDACallback subscribeAsync(
      Observable observable, CDACallback callback, CDAClient client) {
    ConnectableObservable connectable = observable.observeOn(Schedulers.io()).publish();

    callback.setSubscription(connectable.subscribe(
        new SuccessAction(callback, client),
        new FailureAction(callback, client)));
    
    connectable.connect();
    return callback;
  }

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

    protected final CDAClient client;

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

    @Override public void call(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);
      }
    }
  }
}