How to save Retrofit 2 response into SharedPreferences

Question

I have a retrofit 2 response by which i gets data from server. my code is working fine.

But i want cache this response using SharedPreferences and keep it till that activity is running and after activity is destroyed. i want to delete this response from SharedPreferences.

This is my Code:

public class SampleClass {
private DataInterface mListener;

public SampleClass() {
    super();
}

public void getDataForId(final String id) {
    ApiInterface apiInterface = APIClient.getApiInterface();
    Call<MyResponse> call = apiInterface.getResponse();
    call.enqueue(new Callback<MyResponse>() {
        @Override
        public void onResponse(Call<MyResponse> call, Response<MyResponse> response) {
            if (response!=null && response.body() != null && mListener != null) {
                mListener.responseData(response.body());
            }
        }
        @Override
        public void onFailure(Call<MyResponse> call, Throwable t) {

        }
    });
}

public void setOnDataListener(DataInterface listener) {
    mListener = listener;
}

public interface DataInterface {
    void responseData( MyResponse myResponse );
}
}

SecondData class file

    sampleClass.setOnDataListener(new SampleClass.DataInterface() {
                @Override
                public void responseData(MyResponse myResponse) {
// i wanna store this response into SharedPreferences for temp and delete after activity is destroyed.    

                    List<Detail> details = myResponse.getDetails();
                    for (Detail d : details) {
                        if (d.getId().equals(id)) {
                            reqDetail = d;
                            name.setText(reqDetail.getName());

                           Picasso.with(SecondData.this)
                                    .load(reqDetail.getName())
                                    .placeholder(R.mipmap.ic_launcher)
                                    .error(R.mipmap.ic_launcher)
                                    .into(image);
                        }
                    }
                }
            });

ApiInterface

public interface ApiInterfaceNew {

    @GET("/display.php")
    Call<MyResponse> getResponse();//imp to include MyResponse as a call
}

Api class

private static final String ROOT_URL = "";

    private static Retrofit retrofit1 = null;
    private static final String CACHE_CONTROL = "Cache-Control";

    public static Retrofit getClient() {
        if (retrofit1 == null) {
            retrofit1 = new Retrofit.Builder()
                    .baseUrl(ROOT_URL)
                    .client(provideOkHttpClient())
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit1;
    }

    public static ApiInterfaceNew getApiInterface() {
        return getClient().create(ApiInterfaceNew.class);
    }

    private static OkHttpClient provideOkHttpClient() {
        return new OkHttpClient.Builder()
                .addInterceptor(provideHttpLoggingInterceptor())
                .addInterceptor(provideOfflineCacheInterceptor())
                .addNetworkInterceptor(provideCacheInterceptor())
                .cache(provideCache())
                .build();
    }

    private static Cache provideCache() {
        Cache cache = null;
        try {
            cache = new Cache(new File(AppControler.getInstance().getCacheDir(), "http-cache"),
                    10 * 1024 * 1024); // 10 MB
        } catch (Exception e) {
            Timber.e("Could not create Cache!");
        }
        return cache;
    }

    private static HttpLoggingInterceptor provideHttpLoggingInterceptor() {
        HttpLoggingInterceptor httpLoggingInterceptor =
                new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
                    @Override
                    public void log(String message) {
                        Timber.e(message);
                    }
                });
        httpLoggingInterceptor.setLevel(BuildConfig.DEBUG ? HEADERS : NONE);
        return httpLoggingInterceptor;
    }

    public static Interceptor provideCacheInterceptor() {
        return new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Response response = chain.proceed(chain.request());

                // re-write response header to force use of cache
                CacheControl cacheControl = new CacheControl.Builder()
                        .maxAge(2, TimeUnit.MINUTES)
                        .build();

                return response.newBuilder()
                        .header(CACHE_CONTROL, cacheControl.toString())
                        .build();
            }
        };
    }

    public static Interceptor provideOfflineCacheInterceptor() {
        return new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request request = chain.request();

                if (!AppControler.hasNetwork()) {
                    CacheControl cacheControl = new CacheControl.Builder()
                            .maxStale(7, TimeUnit.DAYS)
                            .build();

                    request = request.newBuilder()
                            .cacheControl(cacheControl)
                            .build();
                }

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

AppControler class

 public class AppControler extends Application {

        private static AppControler instance;

        @Override
        public void onCreate()
        {
            super.onCreate();

            instance = this;

            if (BuildConfig.DEBUG)
            {
                Timber.plant(new Timber.DebugTree());
            }

            Timber.i("Creating our Application");
        }

        public static AppControler getInstance ()
        {
            return instance;
        }

        public static boolean hasNetwork ()
        {
            return instance.checkIfHasNetwork();
        }

        public boolean checkIfHasNetwork()
        {
            ConnectivityManager cm = (ConnectivityManager) getSystemService( Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = cm.getActiveNetworkInfo();
            return networkInfo != null && networkInfo.isConnected();
        }

https://stackoverflow.com/questions/45904054/retrofit-2-okhttpclient-caching-not-working/45904151#45904151 This answer can probably help you in caching your response.By the way caching the response in SharedPref is not a good Idea — Farmaan Elahi, Oct 23 '17 at 21:05
hey tired that code but i'm getting this error https://i.stack.imgur.com/3ZMap.jpg — feltonjk, Oct 24 '17 at 14:11
Here instance may not be initialized that why it is giving NullPointerException — Farmaan Elahi, Oct 24 '17 at 18:32
Please upload the entire retrofit or okhttp code in that file atleast — Farmaan Elahi, Oct 24 '17 at 19:11

Nirmal Shethwala · Answer 1 · 2017-10-24T09:53:46.913

Add below code in your Retrofit response when a response is success.

First convert JSON to string and store.

  Gson gson = new Gson();
  String favData = gson.toJson(response.body());

save strings to prefrance.

preferenceManager is my SharedPref class

  preferenceManager.setStringPreference(Global.OFFLINE_WORD, favData);

now when you want to get pref data call below method.

 public ArrayList<MyResponse> getData(String key) {
    String data = getStringPreference(key);
    Gson gson = new Gson();

    Type type = new TypeToken<ArrayList<MyResponse>>() {
    }.getType();
    return gson.fromJson(data, type);
}

Ashokkumar Adichill · Answer 2 · 2017-10-24T09:36:47.313

You can use either ObjectMapper or Gson.

For ObjectMapper you can refer the below code

 public static void updateUserInfo(UserInfo userInfo, Context context) {
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
    Crashlytics.log("updating User Info "+(userInfo!=null?userInfo.toString():"UserInfo is null"));
    final SharedPreferences.Editor edit = preferences.edit();
    ObjectMapper objectMapper = new ObjectMapper();
    try {
        String value = objectMapper.writeValueAsString(userInfo);
        edit.putString("USER_INFO_MODEL", value);
        edit.commit();
    } catch (JsonProcessingException e) {
        Exceptions.propagate(e);
    }

}

you can also get the stored response from shared preferences

public static UserInfo getUserInfo(Context context) {
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
    String userDetatails = preferences.getString(AppConstants.USER_INFO_MODEL, "");
    Crashlytics.log("get UserInfo   "+userDetatails);
    ObjectMapper mapper = new ObjectMapper();
    if (StringUtils.isEmpty(userDetatails)) {
        return null;
    }
    UserInfo userInfo = null;
    try {
        userInfo = mapper.readValue(userDetatails, UserInfo.class);
    } catch (IOException e) {
        Exceptions.propagate(e);
    }
    return userInfo;
}

just call the method with the response and context ClassName where the method is available CommonUtil.updateUserInfo(response,context); — Ashokkumar Adichill, Oct 24 '17 at 09:32

How to save Retrofit 2 response into SharedPreferences

2 Answers2