Android:dynamically pass model class to retrofit callback

Question

In retrofit to map json response to pojo usually we do this

@POST
Call<User> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

ApiCalls api = retrofit.create(ApiCalls.class);
    Call<User> call = api.getDataFromServer(StringConstants.URL,hashMap);
    call.enqueue(new Callback<User>() {
         //Response and failure callbacks
    }

where User is my Pojo class. But for every other request i need to make different pojo and write same code for retrofit call.I want to make a single method for calling api and pass the respective pojo class to retrofit call. like this

ApiCalls api = retrofit.create(ApiCalls.class);
Call<*ClassPassed*> call = api.getDataFromServer(StringConstants.URL,hashMap);
call.enqueue(new Callback<*ClassPassed*>() {
     //Response and failure callbacks
}

so now i can any pojo class to single method and get the response.This is just to avoid rewriting the same code again and again.is this possible

Update To elaborate more:

Suppose I need to make two requests. First one is to get userDetails and the other is patientDetails.So i have to create two model classes User and Patient. So in retrofit api i'll be having something like this

@POST
Call<User> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

@POST
Call<Patient> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

and in my FragmentUser and FragmentPatient class i'll be doing this

  ApiCalls api = retrofit.create(ApiCalls.class);
Call<User> call = api.getDataFromServer(StringConstants.URL,hashMap);
call.enqueue(new Callback<User>() {
     //Response and failure callbacks
}

ApiCalls api = retrofit.create(ApiCalls.class);
Call<Patient> call = api.getDataFromServer(StringConstants.URL,hashMap);
call.enqueue(new Callback<Patient>() {
     //Response and failure callbacks
}

but here the code is repaeting just beacuse of different pojo classes.I need to repeat the same code in every other fragments for different requests. So i need to make a generic method where it can accept any pojo class and then from fragment i'll be just passing the pojo to be mapped.

What? This is exactly what Retrofit is trying to PREVENT! if you want to do something like this, its better to use another library, or just OkHttp without Retrofit, or use Ion/Volley/Some other random http lib — Bhargav, Dec 01 '16 at 06:10

sushildlh · Answer 1 · 2019-02-15T12:42:24.817

Android:dynamically pass model class to retrofit callback

There is 2 ways you can do this .........

1. Generics

2. Combine all POJO into one ......

Generics

In the Generics you have to pass the method with the class. pleas have look on example .....

ApiCalls api = retrofit.create(ApiCalls.class);

Call<User> call = api.getDataFromServer(StringConstants.URL,hashMap);

callRetrofit(call,1);

 public static <T> void callRetrofit(Call<T> call,final int i) {

        call.enqueue(new Callback<T>() {
            @Override
            public void onResponse(Call<T> call, Response<T> response) {
            if(i==1){
                  User user = (User) response.body(); // use the user object for the other fields
             }else if (i==2){
                 Patient user = (Patient) response.body(); 
              }


            }

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

            }
        });

    }

NOTE:- Above retrofit call TypeCast your response into YOUR OBJECT, so you can access its field and methods

Combine all POJO into one

It is very easy to use . You have to combine your all POJO class into one and use them inside the Retrofit. please have look on below example ....

I have two API login and user......

In Login API i have get JSON response like this ...

{ "success": True, "message": "Authentication successful"}

above JSON , POJO look like this

public class LoginResult{

    private String message;
    private boolean success;

    //constructor , getter and setter 
}

and Retrofit call look like this .....

 call.enqueue(new Callback<LoginResult>() {
                @Override
                public void onResponse(Call<LoginResult> call, Response<LoginResult> response) {


                }

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

                }
            });

In User API i have get JSON response like this ...

{"name": "sushildlh", "place": "hyderabad"}

above JSON , POJO look like this

 public class UserResult{

        private String name;
        private String place;

        //constructor , getter and setter 
    }

and Retrofit call look like this .....

 call.enqueue(new Callback<UserResult>() {
                @Override
                public void onResponse(Call<UserResult> call, Response<UserResult> response) {


                }

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

                }
            });

Just combine both of above JSON response into one .....

public class Result{

            private String name;
            private String place;
            private String message;
            private boolean success;

            //constructor , getter and setter 
        }

and use Result inside Your API call ......

  call.enqueue(new Callback<Result>() {
            @Override
            public void onResponse(Call<Result> call, Response<Result> response) {


            }

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

            }
        });

Note:- You directly combine your 2 POJO class and accessing it. (This is very complicate if you have response very large and provide duplication if some KEY is same with different Variable type )

score 11 · Answer 2 · answered Dec 01 '16 at 06:11

11

You can build main pojo like this

public class BaseResponse<T>
{
    @SerializedName("Ack")
    @Expose
    private String ack;

    @SerializedName("Message")
    @Expose
    private String message;

    @SerializedName("Data")
    @Expose
    private T data;

    /**
     *
     * @return
     * The ack
     */
    public String getAck() {
        return ack;
    }

    /**
     *
     * @param ack
     * The Ack
     */
    public void setAck(String ack) {
        this.ack = ack;
    }

    /**
     *
     * @return
     * The message
     */
    public String getMessage() {
        return message;
    }

    /**
     *
     * @param message
     * The Message
     */
    public void setMessage(String message) {
        this.message = message;
    }


    /**
     *
     * @return
     * The data
     */
    public T getData() {
        return data;
    }

    /**
     *
     * @param data
     * The Data
     */
    public void setData(T data) {
        this.data = data;
    }
}

And call like this

 Call<BaseResponse<SetupDetails>> getSetup(@Query("site_id") int id,@Query("ino") String ii);

answered Dec 01 '16 at 06:11

Surya Prakash Kushawah

3,185
1
22
42

what exactly you want to know – Surya Prakash Kushawah Jul 27 '17 at 05:17
I've same scenario as yours answer is pointing out, but I am unable to create service and Interface for dynamic model. – Usman Rana Jul 27 '17 at 05:54
Call> put model name in place of T – Surya Prakash Kushawah Jul 27 '17 at 06:31
This does not work - Retrofit doesn't allow for dynamic types - it needs to know the ResponseType at RUN time – HannahCarney Sep 06 '17 at 15:59
@HannahLouisaCarney hehehehe Bhai Its always work you are doing some wrong. This is well tested. Think before downvote – Surya Prakash Kushawah Sep 08 '17 at 05:09
it will not work it will always throw this error https://github.com/square/retrofit/issues/2012 - anyone that upvoted must have done so before trying. You can never put a generic type in a retrofit class - it needs to know these classes at run time as I said. – HannahCarney Sep 08 '17 at 08:42
@HannahLouisaCarney Open your eye and see problem is Call> this. But I am using like this Call> . I have make BaseResponse class as a generic. Do like this this is always work i have give you also all code . – Surya Prakash Kushawah Sep 08 '17 at 09:05
I hope so you never use my code like this. that by you say this is not working. You should try at least one time before down vote. Again i challenge you this work – Surya Prakash Kushawah Sep 08 '17 at 09:08
Thanks. Solved my issue. – kish0n Jul 26 '21 at 16:53

score 2 · Answer 3 · answered Dec 05 '16 at 04:39

2

You need to use generics. That way, you can pass the desired type into the call.

@POST
Call<T> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap, Class<T> requestClass);

ApiCalls api = retrofit.create(ApiCalls.class);
    Call<T> call = api.getDataFromServer(StringConstants.URL,hashMap);
    call.enqueue(new Callback<T>() {
         //Response and failure callbacks
    }

By the way, I'm no retrofit expert (I use my own stuff mostly), but I think you are using it wrong.

answered Dec 05 '16 at 04:39

Fco P.

2,486
17
20

This doesn't work: you'll get an `java.lang.IllegalArgumentException: Method return type must not include a type variable or wildcard: retrofit2.Call` fix this by using JsonElement as return type first and convert later to specific type: `val userInfo = Gson().fromJson(jsonElement?.asJsonObject.toString(), UserInfo::class.java)` – SqAR.org Apr 08 '20 at 22:00

score 1 · Answer 4 · answered Dec 01 '16 at 06:00

First Create Interface:

public interface
ItemAPI {

    @GET("setup.php")
    Call<SetupDetails> getSetup(@Query("site_id") int id,@Query("ino") String ii);

    @GET("setup.php")
    void setMy(@Query("site_id") int id, Callback<List<SetupDetails>> sd);
    }

Now create class:

public class Apiclient {

    private static final String BASE_URL ="http://www.YOURURL.COM/";
    private static Retrofit retrofit = null;

    public static Retrofit getClient() {

        OkHttpClient.Builder httpClient2 = new OkHttpClient.Builder();
        httpClient2.addNetworkInterceptor(new Interceptor() {

            @Override
            public Response intercept(Chain chain) throws IOException {
                Request.Builder builder = chain.request().newBuilder();
                builder.addHeader("site_id","1");
                return chain.proceed(builder.build());
            }
        });
        OkHttpClient client = httpClient2.build();

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

Now in any activity just use:

ItemAPI itemAPI = Apiclient.getClient().create(ItemAPI.class);
     Call<AllProducts> call=itemAPI.getSetup(1,count);
     call.enqueue(new Callback<AllProducts>() {
            @Override
            public void onResponse(Call<AllProducts> call, Response<AllProducts> response) {
                try {
                    if (response.body().getItem().size()>0){

                    }

                }catch (Exception e){
                    e.printStackTrace();
                }
            }

            @Override
            public void onFailedAfterRetry(Throwable t) {

            }
        });

I am using this in my app. And i don't have optimized method of doing that — Divyesh Patel, Dec 01 '16 at 06:03
@Bhargav how can i use singleton pattern for using apiclient class? — Divyesh Patel, Dec 01 '16 at 06:05
If you understand the singleton pattern, then `if (null != retrofit) return retrofit;` else, do that other stuff to create the client — OneCricketeer, Dec 01 '16 at 06:10
Ah you are already doing the null check on `retrofit` just move the instantiation of okhttp builder class inside the if block — Bhargav, Dec 01 '16 at 06:12

score 1 · Answer 5 · answered Dec 01 '16 at 06:05

My approach is make a POJO called ResponseData in which you will have an attribute Object, so you have:

@POST
Call<ResponseData> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

When you get the response you have to parse your response.body() to the desired class. So the pros: you just have one request, instead you have to parse the response.

score 1 · Answer 6 · answered Dec 01 '16 at 06:10

Do it like this :

    @POST
    Call<Object> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

    ApiCalls api = retrofit.create(ApiCalls.class);
        Call<Object> call = api.getDataFromServer(StringConstants.URL,hashMap);
        call.enqueue(new Callback<User>() {
            @Override
            public void onResponse(Call<Object> call, Response<Object> response) {
            YourModel modelObject = (YourModel) response.body();
            }

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

            }
        }

How the object will be deserialized. The complete information is required at run time. — Irfan Ul Haq, Mar 13 '18 at 11:04

score 1 · Answer 7 · answered Dec 01 '16 at 11:16

In Order to generalize what you want, you can simply serialize your POJO, and then you can just pass your POJO to the method as is. when you serialize with Objects it basically converts it to string, which are later converted to one big Json String, which are easier to transfer and manipulate.

A quick example would be:

example POJO implementing the serialization, here you should make sure the strings in the Map<String,Object> correspond to what the server is expecting to get, and this method should be different in each POJO:

public class YourPojo implements ObjectSerializer
{
  private static final long serialVersionUID = -1481977114734318563L;

  private String itemName;
  private int itemId;

  @Override
  public Map<String, Object> objectSerialize()
  {
   Map<String, Object> map = new HashMap<>();
   map.put("itemid", itemId); // server will be looking for "itemid"
   map.put("itemname", itemName); // server will be looking for "itemname"
   }

   //other stuff you need....
 }

The serialization interface (so you can implement it across other POJOs)

public interface ObjectSerializer extends Serializable
{
  public Map<String, Object> objectSerialize();
}

And a Json parser you shoul probably have anyways:

public class JsonParser
{
  public static JSONObject serializeToJsonString(Map<String, Object> jsonParams)
  {
    Gson gson = new Gson();
    String json = gson.toJson(jsonParams);
    JSONObject object;
    try
    {
        object = new JSONObject(json);
    }
    catch (Exception e)
    {
        object = new JSONObject(jsonParams);
    }
    return (object);
 }
}

And last, your API defintion:

@POST("users/createitem")
Call<ResponseBody> someCall(@Body RequestBody params);

And method, which should sit in a general class that manages your requests:

public void someMethodName(YourPojo item, final CustomEventListener<String> listener)
{
    JSONObject object = JsonParser.serializeToJsonString(item.objectSerialize());
    RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8";), object.toString());
    Call<ResponseBody> requestCall = serviceCaller.someCall(body);

    requestCall.enqueue(new Callback<ResponseBody>()
    {
        @Override
        public void onResponse(Call<ResponseBody> call, retrofit2.Response<ResponseBody> rawResponse)
        {
            try
            {
                String response = rawResponse.body().string();
                //do what you want with this string
                listener.getResult(response);
            }
            catch (Exception e)
            {
             e.printStackTrace();                    
            }
        }

        @Override
        public void onFailure(Call<ResponseBody> call, Throwable throwable)
        {

        }
    });
    }

I return the response through a listener, that's one example of what you can do depending on your response.

Hope this helps!

score 1 · Answer 8 · answered Mar 13 '18 at 12:17

using JsonElement in Response would help:

     public interface serviceApi {
     //  @GET("userinfo")
    //  Observable<userInfo> getUserIfo();
    @GET("gmail/v1/users/me/profile")
    Observable<Response<JsonElement>> getUserProfile(@HeaderMap 
    Map<String,String> Headers);
    }


private void executeAPICall(String token) {
    HashMap<String, String> headers = new HashMap<>();
    Observable<Response<JsonElement>> observable = RetroFitInstance.getInstance().getAPI(token)
            .getUserProfile(ImmutableMap.<String, String>of("Authorization", String.format("Bearer %s", token))).observeOn(AndroidSchedulers.mainThread())
            .subscribeOn(Schedulers.io());

    Observer<Response<JsonElement>> observer = new Observer<Response<JsonElement>>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {
            Log.d("error:", e.getMessage());
        }

        @Override
        public void onNext(Response<JsonElement> jsonElementResponse) {
            UserProfile userProfile = 
       getObject(jsonElementResponse,UserProfile.class);

            EmailTextView.setText("Email Address: " + 
            userProfile.getEmailAddress());
            EmailTextView.setText("Email Address: " + 
            userProfile.getEmailAddress());
            totalEmailsTextView.setText("Total Emails: " + userProfile.getMessagesTotal());
            totalThreadsTextView.setText("Total Threads: " + userProfil
    };
    subscription = observable.subscribe(observer);
}


private <T> T getObject(Response<JsonElement> jsonElementResponse, Class<T> 
                        t){
    return  new Gson().fromJson(jsonElementResponse.body().getAsJsonObject().toString(),t);
}

score 0 · Answer 9 · answered Dec 10 '16 at 10:12

Use standard generics, with a little bit of hacking around

Define your interface like this

public interface ApiCalls<T> {
    @POST
    Call<T> getResult getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);
}

and call for creating api client use a helper method

class HelperMethods {
    @SuppressWarnings("unchecked")
    private static <T> ApiCalls<T> getClient() {
        return retrofit.create((Class<ApiCalls<T>>)(Class<?>)ApiCalls.class);
    }
}

ApiCalls<User> api = HelperMethods.getClient();

But despite of the fact how many times it has been said here, I am gonna say it again... Don't do this .. You are giving up the whole type safety and contract validation that Retrofit is offering .. That is actually the most exciting thing about it..

Hey @koperko ,how we can seperate Callback methods like OnResponse and OnError Seperately i.e i dont want to include those in my Activity/Fragment — Trinadh Koya, May 09 '17 at 10:22

score 0 · Answer 10 · answered Nov 14 '17 at 15:52

I use following approach: First I have implemented custom Call

public class ProxyConvertCall<Tin,Tout> implements Call<Tout> {
    Converter<Tin,Tout> converter;
    Call<Tin> innerCall;

    public ProxyConvertCall2(Call<Tin> jcall, Converter<Tin,Tout> converter){
        this.innerCall = jcall;
        this.converter = converter;
        }

    @Override
    public Response<Tout> execute() throws IOException {
        Response<Tin> response = innerCall.execute();
        if (response.isSuccessful()){
            return Response.success(converter.Convert(response.body()),response.raw());
        }
        else return Response.error(response.code(), response.errorBody());
    }

    @Override
    public void enqueue(final Callback<Tout> callback) {
        final Call<Tout> self = this;
        this.innerCall.enqueue(new Callback<Tin>() {  
            @Override
            public void onResponse(Call<Tin> call, Response<Tin> response) {
                if (response.isSuccessful()){
                    callback.onResponse(self, Response.success(converter.Convert(response.body()), response.raw()));
                }
                else callback.onResponse(self, Response.error(response.code(), response.errorBody()));
            }
            @Override
            public void onFailure(Call<Tin> call, Throwable t) {
                callback.onFailure(self,t);
            }
        });

    }

    @Override
    public boolean isExecuted() {
        return innerCall.isExecuted();
    }

    @Override
    public void cancel() {
        innerCall.cancel();

    }

    @Override
    public boolean isCanceled() {
        return innerCall.isCanceled();
    }

    @Override
    public Call<Tout> clone() {
        return new ProxyConvertCall2<>(innerCall,converter);
    }

    @Override
    public Request request() {
        return innerCall.request();
    }
}

It wrappes Call<Tin> and converts it's result to <Tout> by converter.

@FunctionalInterface 
public interface Converter<Tin, Tout> {
    public Tout Convert(Tin in);
}

For your service you must create service interface, that return JsonObject for single object and JsonArray for arrays

public interface ApiCalls {
    @POST
    Call<JsonObject> getDataFromServer(@Url String url, @Body HashMap<String,Object> hashMap);

    @POST
    Call<JsonArray> getArrayFromServer(@Url String url, @Body HashMap<String,Object> hashMap);
}

Then wrap it with generic class, with converters from JsonElement to any Type <T>:

public class ApiCallsGeneric<T> {
    Converter<JsonObject,T> fromJsonObject;
    Converter<JsonArray,List<T>> fromJsonArray;
    ApiCalls service;

    public ApiCallsGeneric(Class<T> classOfT, ApiCalls service){    
        this.service = service;
        Gson gson  = new GsonBuilder().create();
        GenericListType<T> genericListTypeOfT = new GenericListType<T>(classOfT);
        fromJsonObject = (t)->gson.fromJson(t,classOfT);
        fromJsonArray =(t)->gson.fromJson(t,genericListTypeOfT);
    }

    public Call<T> getDataFromServer(String url, HashMap<String,Object> hashMap){
        return new ProxyConvertCall<>(service.getDataFromServer(url, hashMap), fromJsonObject);
     }

    public Call<List<T>> getArrayFromServer(String url, HashMap<String,Object> hashMap){ 
        return new ProxyConvertCall<>(service.getArrayFromServer(url, hashMap), fromJsonArray);
     }
}

GenericListType is ParaterizedType. It is used for passing type parameter to gson for List<T>

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

public class GenericListType<T> implements ParameterizedType {

    private Type wrapped;

    public GenericListType(Type wrapped) {
        this.wrapped = wrapped;
    }

    public Type[] getActualTypeArguments() {
        return new Type[] {wrapped};
    }

    public Type getRawType() {
        return  List.class;
    }

    public Type getOwnerType() {
        return null;
    }

}

Then you can instantiate ApiCallsGeneric with type you want.

ApiCallsGeneric<User> userService= new ApiCallsGeneric<User>(User.class, retrofit.create(ApiCalls.class));
Call<User> call = userService.getDataFromServer(StringConstants.URL,hashMap);
call.enqueue(new Callback<User>() {
         //Response and failure callbacks
    }

Android:dynamically pass model class to retrofit callback

10 Answers10

Linked