CallbackToFutureAdapter

class CallbackToFutureAdapter

A utility useful for adapting interfaces that take callbacks into interfaces that return .

It also provides additional safety checks, failing the future if it will never complete.

For example, you work with the following async api:

class AsyncApi  {
      interface OnResult {
          void onSuccess(Foo foo);
          void onError(Failure failure);
      }
 
      void load(OnResult onResult) {}
  }
  

Code that wraps it as ListenableFuture would look like:

ListenableFuture<Foo> asyncOperation() {
      return CallbackToFutureAdapter.getFuture(completer -> {
          asyncApi.load(new OnResult() {
              @Override
              public void onSuccess(Foo foo) {
                  completer.set(foo);
              }
 
              @Override
              public void onError(Failure failure) {
                  completer.setException(failure.exception);
              }
          });
          // This value is used only for debug purposes: it will be used in toString()
          // of returned future or error cases.
          return "AsyncApi.load operation";
      });
  }
  

Try to avoid creating references from listeners on the returned Future to the or the passed-in tag object, as this will defeat the best-effort early failure detection based on garbage collection.

Summary

Public methods

@NonNull static fun <T : Any!> getFuture(@NonNull callback: CallbackToFutureAdapter.Resolver<T>): ListenableFuture<T>