How to catch response on get method android retrofit?

Question

I'm new to android development and trying to learn it. I recently ran into an issue, when I use get method I get a response as below:

As there is a status given as '0' from the backend I'm unable to catch the "response_data" array. Could anyone please guide me how can I catch the response. Thanks.

API CLIENT:

 public class ApiClient {
    private final static String BASE_URL = "http://api.xxxxxx.com/app/";
    public static ApiClient apiClient;
    private Retrofit retrofit = null;

    public static ApiClient getInstance() {
        if (apiClient == null) {
            apiClient = new ApiClient();
        }
        return apiClient;
    }
 public Retrofit getClient() {
        return getClient(null);
    }



    private Retrofit getClient(final Context context) {

        HttpLoggingInterceptor interceptor = new 
HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        OkHttpClient.Builder client = new OkHttpClient.Builder();
        client.readTimeout(60, TimeUnit.SECONDS);
        client.writeTimeout(60, TimeUnit.SECONDS);
        client.connectTimeout(60, TimeUnit.SECONDS);
        client.addInterceptor(interceptor);
        client.addInterceptor(new Interceptor() {
            @Override
            public okhttp3.Response intercept(Chain chain) throws 
IOException {
                Request request = chain.request();

                return chain.proceed(request);
            }
        });

        retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .client(client.build())
                .addConverterFactory(GsonConverterFactory.create())
                .build();


        return retrofit;
    }

    }

MAIN ACTIVITY:

public class MainActivity extends AppCompatActivity {

TextView tvResponse;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    tvResponse=findViewById(R.id.tvResponse);

    ApiInterface apiInterface = ApiClient.getInstance().getClient().create(ApiInterface.class);
    Call<ResponseData> responseDataCall=apiInterface.getData();
    responseDataCall.enqueue(new Callback<ResponseData>() {
        @Override
        public void onResponse(Call<ResponseData> call, Response<ResponseData> response) {
            if (response.isSuccessful() && response.body()!=null && response!=null){
                List<ResponseDataItem> data=response.body().getResponseData();

            }
        }

        @Override
        public void onFailure(Call<ResponseData> call, Throwable t) {
            t.printStackTrace();
        }
    });
}

}

RESPONSE DATA:

public class ResponseData {
@SerializedName("response_data")
private List<ResponseDataItem> responseData;

@SerializedName("status")
private int status;

public void setResponseData(List<ResponseDataItem> responseData){
    this.responseData = responseData;
}

public List<ResponseDataItem> getResponseData(){
    return responseData;
}

public void setStatus(int status){
    this.status = status;
}

public int getStatus(){
    return status;
}

}

Answer 1

In this case you need to let Gson know how you want to parse your json. You can add many specific TypeAdapter's for each specific class case or you can create one TypeAdapterFactory that will be used to parse all your jsons. Remember to add it to your Retrofit builder.

This code example is a TypeAdapterFactory that will ignore status and parse only response_data to your object.

class ResponseDataTypeAdapterFactory implements TypeAdapterFactory {

    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
        TypeAdapter<JsonElement> elementTypeAdapter = gson.getAdapter(JsonElement.class);

        return new TypeAdapter<T>() {
            public void write(JsonWriter out, T value) throws IOException {
                delegate.write(out, value);
            }

            public T read(JsonReader reader) throws IOException {

                JsonElement jsonElement = elementTypeAdapter.read(reader);

                if (jsonElement.isJsonObject()) {
                    JsonObject jsonObject = jsonElement.getAsJsonObject();
                    if (jsonObject.has("response_data")) {
                       jsonElement = jsonObject.get("response_data");
                    }
                }

                return delegate.fromJsonTree(jsonElement);
            }
        };
    }
}

And on your Retrofit builder

Gson gson = new GsonBuilder()
    .registerTypeAdapterFactory(ResponseDataTypeAdapterFactory())
    .create();

new Retrofit.Builder()
    .baseUrl(BASE_URL)
    .client(client.build())
    .addConverterFactory(new GsonConverterFactory.create(gson))
    .build();

And at the Retrofit interface, you only need to call the class that corresponds with response_datamapping.

public interface ApiInterface {

    @GET("/product-data")
    Call<List<ResponseDataItem>> fetchData();
}

With this implementation, you can remove your ResponseData class and care only about the important model.

Answer 2

For Catching response you use interceptor like HttpLoggingInterceptor ,stetho,chuck

Creating the Retrofit instance

// Add the interceptor to OkHttpClient

  OkHttpClient client=new OkHttpClient().newBuilder()
        .addNetworkInterceptor(new StethoInterceptor()) \\ StethoInterceptor
        .addInterceptor(new ChuckInterceptor(context))  \\  ChuckInterceptor
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(5, TimeUnit.MINUTES)
        .writeTimeout(5, TimeUnit.MINUTES)
        .build();

public static final String BASE_URL = "http://api.myservice.com/";
Retrofit retrofit = new Retrofit.Builder()
  .baseUrl(BASE_URL)
  .addConverterFactory(GsonConverterFactory.create())
  .client(client)
  .build();

for stetho interceptor

 implementation 'com.facebook.stetho:stetho:1.5.0'
 implementation 'com.facebook.stetho:stetho-okhttp3:1.5.0'

for chuck

 debugImplementation 'com.readystatesoftware.chuck:library:1.1.0'
 releaseImplementation 'com.readystatesoftware.chuck:library-no-op:1.1.0'

Answer 3

Make an interface

public interface ApiInterface {

    @GET
    Call<JsonElement> getTimeDifference(@Url String url);
}

Crate an Retrofit client calss

public class RetrofitClient {

    private static final String TAG = "RetrofitClient";

    public static Retrofit geBaseUrl() {
        Retrofit retrofit = null;
        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        if (BuildConfig.DEBUG) {
            interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        }else{
            interceptor.setLevel(HttpLoggingInterceptor.Level.NONE);
        }         OkHttpClient client = new OkHttpClient.Builder().addInterceptor(interceptor).build();

        if (retrofit==null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl("...your base url...")
                    .client(client)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }


}

            String endpoint = "...your end point...";

            ApiInterface ret = RetrofitClient.geBaseUrl(url).create(ApiInterface.class);
            Call<JsonElement> call = ret.getTimeDifference(endpoint);
            call.enqueue(new Callback<JsonElement>() {
                @Override
                public void onResponse(Call<JsonElement> call, Response<JsonElement> response) {
                    try {
                        Log.d("String", "onResponse:  response" + response.body().toString());

                    } catch (Exception e) {
                       
                    }
                }

                @Override
                public void onFailure(Call<JsonElement> call, Throwable t) {
                    Log.d("response", "onFailure: " + t + "      " + call);
                    
                }
            });