code: @NotNull public static <T> Observable<Response<T>> from(@NotNull final ApolloCall<T> call,
        Emitter.BackpressureMode backpressureMode) {
      checkNotNull(call, "call == null");
      return Observable.create(new Action1<Emitter<Response<T>>>() {
        @Override public void call(final Emitter<Response<T>> emitter) {
          final AtomicBoolean canceled = new AtomicBoolean();
          emitter.setCancellation(new Cancellable() {
            @Override public void cancel() throws Exception {
              canceled.set(true);
              call.cancel();
            }
          });
          call.enqueue(new ApolloCall.Callback<T>() {
            @Override public void onResponse(@NotNull Response<T> response) {
              if (!canceled.get()) {
                emitter.onNext(response);
              }
            }
  
            @Override public void onFailure(@NotNull ApolloException e) {
              Exceptions.throwIfFatal(e);
              if (!canceled.get()) {
                emitter.onError(e);
              }
            }
  
            @Override public void onStatusEvent(@NotNull ApolloCall.StatusEvent event) {
              if (!canceled.get()) {
                if (event == ApolloCall.StatusEvent.COMPLETED) {
                  emitter.onCompleted();
                }
              }
            }
          });
        }
      }, backpressureMode);
    }
docs: Converts an {@link ApolloCall} to a Observable. The number of emissions this Observable will have is based on the
  {@link ResponseFetcher} used with the call.
  
  @param call             the ApolloCall to convert
  @param <T>              the value type
  @param backpressureMode The {@link rx.Emitter.BackpressureMode} to use.
  @return the converted Observable