How can we handle different response type with Retrofit 2?

Question

I have a webservice that returns either a list of serialized MyPOJO objects:

[
  { //JSON MyPOJO },
  { //JSON MyPOJO }
]

either an error object :

{  
  'error': 'foo', 
  'message':'bar' 
}

Using retrofit2, how can I retrieve the error ?

Call<List<MyPOJO>> request = ...
request.enqueue(new Callback<List<MyPOJO>>() {
  @Override
  public void onResponse(Response<List<MyPOJO>> response) {
      if (response.isSuccess()) {
          List<MyPOJO> myList = response.body();
          // do something with the list...
      } else {
          // server responded with an error, here is how we are supposed to retrieve it
          ErrorResponse error = ErrorResponse.fromResponseBody(apiService.getRetrofitInstance(), response.errorBody());
          processError(error);
          // but we never get there because GSON deserialization throws an error !
      }
  }

  @Override
  public void onFailure(Throwable t) {
    if(t instanceof IOException){
        // network error 
    }else if(t instanceof IllegalStateException){
        // on server sending an error object we get there
        // how can I retrieve the error object ?
    }else { 
        // default error handling 
    }       
  }
}

Here is the GSON exception:

java.lang.IllegalStateException: Expected BEGIN_ARRAY but was BEGIN_OBJECT at line 1 column 2 path $

Retrofit instance is created using GsonConverterFactory

Already asked http://stackoverflow.com/questions/24279245/how-to-handle-dynamic-json-in-retrofit — Rohit5k2, Feb 23 '16 at 17:01
@Rohit52k to be fair that previous question is asked about Retrofit 1.. this is about Retrofit 2. — The Tokenizer, Mar 14 '18 at 21:16

score 25 · Answer 1 · answered Oct 19 '16 at 12:30

I had a similar issue and I solved it by using a generic Object and then testing what type of response I had using instanceof

Call<Object> call = api.login(username, password);
call.enqueue(new Callback<Object>() 
{
    @Override
    public void onResponse(Response<Object> response, Retrofit retrofit)
    {
         if (response.body() instanceof MyPOJO )
         {
            MyPOJO myObj = (MyPOJO) response.body();
            //handle MyPOJO 
         }
         else  //must be error object
         {
            MyError myError = (MyError) response.body();
            //handle error object
         }
    }

    @Override
    public void onFailure(Throwable t) 
    {
     ///Handle failure
    }
});

In my case I had either MyPOJO or MyError returned and I could be sure it would be one of these.

In other cases then I had the backend return the same Response Object no matter if the request was successful or not.
Then inside this response object I had my actual data within an "Object" field. Then I can use instance of to determine what type of data I had. In this case I always had the same object being returned, no matter what the call was.

public class MyResponse {

    private int responseCode;
    private String command;
    private int errorno;
    private String errorMessage;
    private Object responseObject;   //This object varies depending on what command was called
    private Date responseTime;
}

java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to models.NewOrder — Ahamadullah Saikat, Sep 06 '18 at 06:18
Object object = response.body(); LinkedTreeMap t = (LinkedTreeMap) object; progress.dismiss(); Log.d("printT", "onResponse: " + t); String message = t.get("message").toString(); — Harshit Gupta, Jul 18 '21 at 18:46

score 12 · Answer 2 · answered Aug 02 '17 at 06:34

Call<LoginResponse> call = apiService.getUserLogin(usernametext, passwordtext);
    call.enqueue(new Callback<LoginResponse>() {
        @Override
        public void onResponse(Call<LoginResponse> call, Response<LoginResponse> response) {
            Log.e("responsedata","dd"+response.toString());
            if (response.code()==200) {
                showMessage(response.body().getMessage());
                Intent intent = new Intent(LoginActivity.this, MainAct.class);
                startActivity(intent);
            }
            else
                try {
                    LoginError loginError= gson.fromJson(response.errorBody().string(),LoginError.class);
                    showMessage(loginError.getMessage());
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }

        @Override
        public void onFailure(Call<LoginResponse> call, Throwable t) {

        }
    });
}

not working for me...because it is not reaching onresponse(), gettting error internally inside retrofit — NehaK, Oct 02 '18 at 18:30
LoginError loginError= gson.fromJson(response.errorBody().string(),LoginError.class); works for me. Thank you. — Mahmudur Rahman, Nov 22 '19 at 04:54

How can we handle different response type with Retrofit 2?

2 Answers2

Linked

Related