Thank you very much four your help and lead @Daniel-b.

I've solved my issue now.

First I created an Interface for handling results; as you suggested.

public interface ResultHandler<T> {
    void onSuccess(T data);
    void onFailure(Exception e);
}

Then in the service class, I added ResultHandler to the function's input parameters :

public void getUserInfo(String id, ResultHandler<UserInfo> handler) {
    firestore().collection("userInfo").document(id).get().addOnCompleteListener(snap -> {
        if (snap.isSuccessful()) {
           try {
               // failable constructor. use try-catch
               UserInfo info = new UserInfo(snap.getResult().getId(), snap.getResult().getData());
               handler.onSuccess(info);
           } catch (Exception e) {
                handler.onFailure(e);
           }
        } else {
            handler.onFailure(snap.getException())
        }
    });
}

And called service in Activity

FirestoreService.getInstance().getUserInfo("ZsrAdsG5HVYLTZDBeZtkGDlIBW42", new ResultHandler<UserInfo>() {
    @Override
    public void onSuccess(UserInfo data) {
        Log.i("UserInfo", data.id);                    
    }

    @Override
    public void onFailure(Exception e) {
        // getting data failed for some reason
    }
});

Using AsyncTask

You can use an AsyncTask. It has 3 steps to it.

1. onPreExecute() - things you want to do before running doInBackground(). This happens in the UI main thread.

2. doInBackground()- the AsyncTask, will do operations in a background thread (the background thread is created by Android so you don't need to worry about it).

3.onPostExecute() - here you can receive any data from the doInBackground method. The postExecute method is executed again, in the UI main thread.

So you can do any I/O operations in doInBackground(), and return the value you received from the server or any other data source, and onPostExecute(), is the equivalent of a completion block in swift.

How to Declare

To use AsyncTask, you need to extend the Android AsyncTask.

So your own AsyncTask declaration will look like this:

private class MyAsyncTask extends AsyncTask<Void, Void, Void> { ... }

What are the 3 generic arguments you ask?

1. Params - the type of the parameters sent to the task upon execution.

2. Progress - the type of the progress units published during the background computation. (Almost always will be Void, unless you care about the actual progress of the operation. Notice this is Void with a capital letter, and not void as the return type).

3. Result - the type of the result of the background computation.

Full Example

private class LongOperation extends AsyncTask<String, Void, String> {

        @Override
        protected String doInBackground(String... params) {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.interrupted();
                }
            }
            return "Executed";
        }

        @Override
        protected void onPostExecute(String result) {
            TextView txt = findViewById(R.id.output);
            txt.setText(result); 
        }
    }

In the example, I create a fake, long operation, that you can not run on the UI main thread (because it is a blocking operation).

When the operation is finished, it returns a String, and that same String is received in the onPostExecute() method (and remember, onPostExecute() runs on the UI main thread again). So you can change your UI with the String value you received from the long,blocking operation.

If you want the documentation, here it is:

https://developer.android.com/reference/android/os/AsyncTask

Using Observer Pattern

You can also use the observer pattern in your situation.

Create an interface, that has a method onSuccess(). Have an object implement that interface, and whenever you need it, you can call the onSuccess() method.

Example:

public Interface SuccessInterface{
   void onSuccess()
}

public class SuccessHandler implements SuccessInterface{
   public void onSuccess(){
         //success code goes here
   }

}

then in your code, have a SucessHandler instantiated, and call onSuccess() when you need to.

For API 26, CompletionHandler is available. Check https://developer.android.com/reference/java/nio/channels/CompletionHandler