Tutoriel Android : Apprendre à utiliser Retrofit, OkIo, OkHttp et Moshi

Buffer buffer = new Buffer();

Buffer buffer = new Buffer();
buffer.writeUtf8("Thanks Jake Wharton");

Buffer buffer = new Buffer();
buffer.writeUtf8("Thanks Jake Wharton");
buffer.writeUtf8("Thanks Jake");

Buffer buffer = new Buffer();
buffer.writeUtf8("Thanks Jake Wharton");
buffer.writeUtf8("Thanks Jake");
buffer.writeUtf8("Thanks a billion");

Buffer buffer = new Buffer();
buffer.writeUtf8("Thanks Jake Wharton");
buffer.writeUtf8("Thanks Jake");
buffer.writeUtf8("Thanks a billion");
buffer.readUtf8(6);//returns Thanks

Buffer buffer = new Buffer();
buffer.writeUtf8("Thanks Jake Wharton");
buffer.writeUtf8("Thanks Jake");
buffer.writeUtf8("Thanks a billion");
buffer.readUtf8(6);//returns Thanks
//read the rest of the first segment
buffer.readUtf8(24);//returns Jake WhartonThanks Jake

Buffer buffer = new Buffer();
buffer.writeUtf8("Thanks Jake Wharton");
buffer.writeUtf8("Thanks Jake");
buffer.writeUtf8("Thanks a billion");
buffer.readUtf8(6);//returns Thanks
//read the rest of the first segment
buffer.readUtf8(24);//returns Jake WhartonThanks Jake
//then create a new buffer
Buffer otherBuffer = new Buffer();

Buffer buffer = new Buffer();
buffer.writeUtf8("Thanks Jake Wharton");
buffer.writeUtf8("Thanks Jake");
buffer.writeUtf8("Thanks a billion");
buffer.readUtf8(6);//returns Thanks
//read the rest of the first segment
buffer.readUtf8(24);//returns Jake WhartonThanks Jake
//then create a new buffer
Buffer otherBuffer = new Buffer();
otherBuffer.writeAll(buffer);

public class RetrofitBuilder {
    public static WebServerIntf getComplexClient(Context ctx) {
        // get the OkHttp client
        OkHttpClient client = getOkHttpClient(ctx);

        // now it's using the cach
        // Using my HttpClient
        Retrofit raCustom = new Retrofit.Builder()
            .client(client)
            .baseUrl(BASE_URL)
                    //add your own converter first (declaration order matters)
                    //the responsability chain design pattern is behind
            .addConverterFactory(new MyPhotoConverterFactory())
                    //You need to add a converter if you want your Json to be automagicly convert 
                   //into the object
            .addConverterFactory(MoshiConverterFactory.create())
                    //then add your own CallAdapter
            .addCallAdapterFactory(new ErrorHandlingCallAdapterFactory())
            .build();
        WebServerIntf webServer = raCustom.create(WebServerIntf.class);
        return webServer;
    }
}

public class RetrofitBuilder {
    @NonNull
    public static OkHttpClient getOkHttpClient(Context ctx) {
        // Define the OkHttp Client with its cache!
        // Assigning a CacheDirectory
        File myCacheDir=new File(ctx.getCacheDir(),"OkHttpCache");
        // You should create it...
        int cacheSize=1024*1024;
        Cache cacheDir=new Cache(myCacheDir,cacheSize);
        Interceptor customLoggingInterceptor=new CustomLoggingInterceptor();
        HttpLoggingInterceptor httpLogInterceptor=new HttpLoggingInterceptor();
        httpLogInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
        return new OkHttpClient.Builder()
            //add a cache
            .cache(cacheDir)
            //add interceptor (here to log the request)
           .addInterceptor(customLoggingInterceptor)
           .addInterceptor(httpLogInterceptor)
           .build();
    }
}

public interface WebServerIntf {
    @GET("posts/1")
    Call<Post> getPostOne();

    @GET("posts/{id}")
    Call<Post> getPostById(@Path("id") int id);

    @GET("posts")
    Call<List<Post>> getPostsList();
}

Call<Post> getPostOneCall getPostByIdCall = webServiceComplex.getPostOne();

Response<Post> response=getPostOneCall.execute();

getPostOneCall.enqueue(new Callback<Post>() {
    @Override
    public void onResponse(Response<Post> response) {
        Log.e("BusinessService", "The call is back with success");
    }

    @Override
    public void onFailure(Throwable t) {
        Log.e("BusinessService", "The call failed");
    }
});

//This will log this information
//Analyzing a response Object
//Analyzing a response.code()=200
//Analyzing a response.message()=OK
//Analyzing a response.isSuccess()=true
//Analyzing a response.headers()=Connection: keep-alive
//                Content-Type: application/json; charset=utf-8
//                Server: Cowboy
//                X-Powered-By: Express
//                Vary: Origin
//                Access-Control-Allow-Credentials: true
//                Cache-Control: no-cache
//                Pragma: no-cache
//                Expires: -1
//                X-Content-Type-Options: nosniff
//                Etag: W/"1fd-jhjIa9s91vj8ZufojwdSzA"
//                Date: Thu, 21 Jan 2016 15:11:30 GMT
//                Via: 1.1 vegur
//                OkHttp-Sent-Millis: 1453389092618
//                OkHttp-Received-Millis: 1453389096044
//Analyzing a response.errorBody()=null
//Analyzing a response.raw()=Response{protocol=http/1.1, code=200, message=OK, url=http://jsonplaceholder.typicode.com/users/2}

public void release() {
    activity = null;
    //you have to cancel your calls in onStop
    getPostOneCall.cancel();
    getPostByIdCall.cancel();
    getPostListCall.cancel();
    getUsersListCall.cancel();
    getUserByIdCall.cancel();
    getPhotoWithQueryCall.cancel();
}

@GET("posts/1")
Call<Post> getPostOne();
@POST("posts")
Call<Post> addNewPost(@Body Post post);
@PUT("users/1")
Call<User> updateUserOne(@Body User user);
@DELETE("user/{id}")
Call<User> deleteUserById(@Path("id")int id);

@GET("posts/{id}")
Call<Post> getPostById(@Path("id") int id);

@Multipart
@PUT("photos")
Call<Photo> newPhoto(@Part("photo") Photo photoObject,
                     @Part("content") byte[] picture);

@FormUrlEncoded
@POST("user/{id}/edit")
Call<User> updateUserWithForm(@Path("id")int id, 
                              @Field("name")String name,
                              @Field("points")int point);

@GET("photos/1")
Call<Photo> getPhotoWithQuery(@Query("data") int id,
                              @QueryMap Map<String,String>option);

HashMap<String, String> options = new HashMap<String, String>();
options.put("parameter1", "value1");
options.put("parameter2", "value2");
options.put("parameter3", "value3");
getPhotoWithQueryCall = webServiceComplex.getPhotoWithQuery(3, options);

http://jsonplaceholder.typicode.com/photos/1?data=3&parameter2=value2&parameter1=value1&parameter3=value3

@GET("photos")
Call<Photo> getPhotoWithQuery(@Query("id") List<Integer> id);

http://jsonplaceholder.typicode.com/photos/1?id=3&id=2&id=1&id=4

@Headers({
        "Accept: application/vnd.yourapi.v1.full+json",
        "User-Agent: Your-App-Name"
})
@GET("posts/1")
Call<Post> getPostOne();

@GET("posts/{id}")
Call<Post> getPostById(@Header("Content-Range")String contentRange,
                       @Path("id") int id);

public class RetrofitBuilder {
    OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
    httpClient.interceptors().add(new Interceptor() {
        @Override
        public Response intercept(Interceptor.Chain chain) throws IOException {
            Request original = chain.request();

            Request request = original.newBuilder()
                .header("User-Agent", "Your-App-Name")
                .header("Accept", "application/vnd.yourapi.v1.full+json")
                .method(original.method(), original.body())
                .build();

            return chain.proceed(request);
        }
    }
}

public static WebServerIntf getSimpleClient(){
    //Using Default HttpClient
    Retrofit ra=new Retrofit.Builder()
            //you need to add your root url
            .baseUrl(BASE_URL)
            //You need to add a converter if you want your Json to be automagicly 
            //convert into the object
            .addConverterFactory(MoshiConverterFactory.create())
            .build();
    WebServerIntf webServer=ra.create(WebServerIntf.class);
    return webServer;
}

public class RetrofitBuilder {

        // Using my HttpClient
        Retrofit raCustom = new Retrofit.Builder()
        .client(client)
        .baseUrl(BASE_URL)
        
        // Add your own converter first (declaration order matters)
        // The responsability chain design pattern is behind
        .addConverterFactory(new MyPhotoConverterFactory())
        // You need to add a converter if you want your Json to be automagicly 
        // convert into the object
        .addConverterFactory(MoshiConverterFactory.create())
        // Then add your own CallAdapter
        .addCallAdapterFactory(new ErrorHandlingCallAdapterFactory())
        .build();
        WebServerIntf webServer = raCustom.create(WebServerIntf.class);
        return webServer;
}

public class MyPhotoConverterFactory extends Converter.Factory {

    public static MyPhotoConverterFactory create(){
        return new MyPhotoConverterFactory();
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] 
        annotations, Retrofit retrofit) {
        //If it's a Photo instance then convert
        if(type==Photo.class){
            return MyPhotoRequestConverter.INSTANCE;
        }
        //else use the Chain of responsability pattern and return null
        //the api will look at the next converter
        return null;
    }
    
    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] 
        annotations, Retrofit retrofit) {
        //If it's a Photo instance then convert
        if(type==Photo.class){
            return MyPhotoResponseConverter.INSTANCE;
        }
        //else use the Chain of responsability pattern and return null
        //the api will look at the next converter
        return null;
    }
}

public class MyPhotoRequestConverter<T> implements Converter<T, RequestBody> {
    // Instance of the converter
    static final MyPhotoRequestConverter<Photo> INSTANCE = new MyPhotoRequestConverter<>();
    
    // MIME type of the request
    private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=utf-8");
    
    private Photo photo;

    // Default PRIVATE empty constructor
    private MyPhotoRequestConverter() {    
    }

    // The real conversion from the Photo to it's json representation
    @Override
    public RequestBody convert(T value) throws IOException {
        // Ensure the right object is passed to you
        if (value instanceof Photo) {
            photo = (Photo) value;
            return new RequestBody() {
                @Override
                public MediaType contentType() {return MEDIA_TYPE;}
                @Override
                public void writeTo(BufferedSink sink) throws IOException {
                    writeRequest(sink); }
                };
            } else {throw new IllegalArgumentException();}    
        }

        private void writeRequest(BufferedSink sink) throws IOException {
            //do the Moshi stuff:
            JsonWriter jsonW = JsonWriter.of(sink);
            jsonW.setIndent("    ");
            writeJson(jsonW);
            // You have to close the JsonWrtiter too (otherwise nothing will happen)
            jsonW.close();
            // Don't forget to close, otherwise nothing appears
            sink.close();
        }

        private void writeJson(JsonWriter jsonW) throws IOException {
            jsonW.beginObject();
            jsonW.name("albumId").value(photo.getAlbumId());
            jsonW.name("id").value(photo.getId());
            jsonW.name("title").value(photo.getTitle());
            jsonW.name("url").value(photo.getUrl());
            jsonW.name("thumbnailUrl").value(photo.getThumbnailUrl());
            jsonW.endObject();
        }
    }
}

public class MyPhotoResponseConverter implements Converter<ResponseBody, Photo> {
    //define an instance to retrieve the converter only once
    static final MyPhotoResponseConverter INSTANCE = new  MyPhotoResponseConverter();

    //default empty constructor
    private MyPhotoResponseConverter() {
    }

    //The real conversion from the server response to the Photo object
    @Override
    public Photo convert(ResponseBody value) throws IOException {
        return readJson(value.source());
    }
    //Read the source, build the object and return it
    public Photo readJson(BufferedSource source) throws IOException {
        if(source==null){throw new IOException();}
        Photo photo =new Photo();
        //Then read the JSon File
        JsonReader reader = JsonReader.of(source);
        reader.beginObject();
        while (reader.hasNext()) {
            switch (reader.nextName()) {
                case "albumId":
                    photo.setAlbumId(reader.nextInt()); break;
                case "id":
                    photo.setId(reader.nextInt()); break;
                case "title":
                    photo.setTitle(reader.nextString()); break;
                case "url":
                    photo.setUrl(reader.nextString()); break;
               case "thumbnailUrl":
                    photo.setThumbnailUrl(reader.nextString()); break;
                default:break;
            }
        }
        reader.endObject();
        reader.close();
        source.close();
        return photo;
}}

public interface ErrorHandlingCallBack<T>{
    /** Called for [200, 300) responses. */
    void success(Response<T> response);
    /** Called for 401 responses. */
    void unauthenticated(Response<?> response);
    /** Called for [400, 500) responses, except 401. */
    void clientError(Response<?> response);
    /** Called for [500, 600) response. */
    void serverError(Response<?> response);
    /** Called for network errors while making the call. */
    void networkError(IOException e);
    /** Called for unexpected errors while making the call. */
    void unexpectedError(Throwable t);
}

public interface WebServerIntf {
    @GET("posts/trois")
    ErrorHandlingCall<Post> getPostOneWithError();

public class RetrofitBuilder {
    // Now it's using the cach
    // Using my HttpClient
    Retrofit raCustom = new Retrofit.Builder()
        .client(client)
        .baseUrl(BASE_URL)
        // add your own converter first (declaration order matters)
        // the responsability chain design pattern is behind
        .addConverterFactory(new MyPhotoConverterFactory())
        // You need to add a converter if you want your Json    
        .addConverterFactory(MoshiConverterFactory.create())
        // then add your own CallAdapter
        .addCallAdapterFactory(new ErrorHandlingCallAdapterFactory())
        .build();
    WebServerIntf webServer = raCustom.create(WebServerIntf.class);
    return webServer;
}

public class ErrorHandlingCallAdapterFactory implements Factory{
    @Override
    public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
        //tricky stuff, not proud of, but works really
        if(!returnType.toString().contains("ErrorHandlingCall")){
            //This is not handled by you, so return null 
            //and enjoy the responsability chain design pattern
            return null;
        }
        //this case is yours, do your job:
        return new CallAdapter<ErrorHandlingCall<?>>() {
            @Override public Type responseType() {
                return responseType;
            }

            @Override public <R> ErrorHandlingCall<R> adapt(Call<R> call) {
                return new ErrorHandlingCall<>(call);
            }
        };
    }

}

public interface ErrorHandlingCallBack<T>{
    /** Called for [200, 300) responses. */
    void success(Response<T> response);
    /** Called for 401 responses. */
    void unauthenticated(Response<?> response);
    /** Called for [400, 500) responses, except 401. */
    void clientError(Response<?> response);
    /** Called for [500, 600) response. */
    void serverError(Response<?> response);
    /** Called for network errors while making the call. */
    void networkError(IOException e);
    /** Called for unexpected errors while making the call. */
    void unexpectedError(Throwable t);
}

public interface ErrorHandlingCallIntf<T> {
    /**
     * Mandatory
     * To be called before execute or enqueue
     *
     * @param callBack
     */
    void initializeCallBack(ErrorHandlingCallBack callBack);

    /**
     * Synchronously send the request and return its response.
     *
     * @throws IOException      if a problem occurred talking to the server.
     * @throws RuntimeException (and subclasses) if an unexpected error occurs
     * creating the request or decoding the response.
     */
    Response<T> execute() throws IOException;

    /**
     * Asynchronously send the request and notify {@code callback} of its response 
     * or if an error occurred talking to the server, creating the request,
     * or processing the response.
     */
    void enqueue();

    /**
     * Returns true if this call has been either {@linkplain #execute() executed} or {@linkplain
     * #enqueue() enqueued}. It is an error to execute or enqueue a call more than once.
     */
    boolean isExecuted();

    /**
     * Cancel this call. An attempt will be made to cancel in-flight calls, and if the call has not
     * yet been executed it never will be.
     */
    void cancel();


    /**
     * True if {@link #cancel()} was called.
     */
    boolean isCanceled();

    /**
     * Create a new, identical call to this one which can be enqueued or executed even 
     *  if this call has already been.
     */
    ErrorHandlingCallIntf<T> clone();
}

public class ErrorHandlingCall<T> implements ErrorHandlingCallIntf<T> {
    /**
     * The real call beyond the this call
     */
    private final Call<T> call;

    /**
     * The call back to use to give more granularity to the error handling to the client
     */
    private ErrorHandlingCallBack<T> errorHandlingCallBack;

    /***********************************************************
     * Constructor
     **********************************************************/
    /**
     * Used by the ErrorHandlingCallAdapterFactory
     *
     * @param call
     */
    ErrorHandlingCall(Call<T> call) {
        this.call = call;
    }

    /**
     * Used by clone
     *
     * @param errorHandlingCallBack
     * @param call
     */
    private ErrorHandlingCall(ErrorHandlingCallBack<T> errorHandlingCallBack, 
        Call<T> call) {
        this.errorHandlingCallBack = errorHandlingCallBack;
        this.call = call.clone();
    }

    /**
     * Mandatory
     * To be called before execute or enqueue
     *
     * @param callBack
     */
    @Override
    public void initializeCallBack(ErrorHandlingCallBack callBack) {
        errorHandlingCallBack = callBack;
    }

    /***********************************************************
     *   implements interface Call<T>
     **********************************************************/

    /**
     * Synchronously send the request and return its response.
     *
     * @throws IOException      if a problem occurred talking to the server.
     * @throws RuntimeException (and subclasses) if an unexpected error occurs 
     * creating the request or decoding the response.
     */
    @Override
    public Response<T> execute() throws IOException {
        if (errorHandlingCallBack == null) {
            throw new IllegalStateException("You have to call  initializeCallBack(ErrorHandlingCallBack callBack) before execute");
        }
        //then analyse the response and do your expected work
        Response<T> response = call.execute();
        int code = response.code();
        if (code >= 200 && code < 300) {
            //it's ok
            return response;
        }
        //It's not ok anymore, return the response but make the errorCallBack
        else if (code == 401) {
            errorHandlingCallBack.unauthenticated(response);
        } else if (code >= 400 && code < 500) {
            errorHandlingCallBack.clientError(response);
        } else if (code >= 500 && code < 600) {
            errorHandlingCallBack.serverError(response);
        } else {
            errorHandlingCallBack.unexpectedError(new RuntimeException(
                "Unexpected response " + response));
        }
        return response;

   }

    /**
     * Asynchronously send the request and notify {@code callback} of its response 
     * or if an error occurred talking to the server, creating the request,
     * or processing the response.
     */
    @Override
    public void enqueue() {
        if (errorHandlingCallBack == null) {
            throw new IllegalStateException("You have to call initializeCallBack(ErrorHandlingCallBack callBack) before enqueue");
        }
        //do the job with the real call object
        call.enqueue(new Callback<T>() {
            /**
             * Invoked for a received HTTP response.
             * <p/>
             * Note: An HTTP response may still indicate an application-level failure 
             * such as a 404 or 500.
             * Call {@link Response#isSuccess()} to determine if the response indicates success.
             *
             * @param response
             */
            @Override
            public void onResponse(Response<T> response) {
                int code = response.code();
                if (code >= 200 && code < 300) {
                    errorHandlingCallBack.success(response);
                } else if (code == 401) {
                    errorHandlingCallBack.unauthenticated(response);
                } else if (code >= 400 && code < 500) {
                    errorHandlingCallBack.clientError(response);
                } else if (code >= 500 && code < 600) {
                    errorHandlingCallBack.serverError(response);
                } else {
                    errorHandlingCallBack.unexpectedError(new RuntimeException("Unexpected response " + response));
                }
            }

            /**
             * Invoked when a network exception occurred talking to the server or 
             * when an unexpected exception occurred creating the request
             * or processing the response.
             *
             * @param t
             */
            @Override
            public void onFailure(Throwable t) {
                if (t instanceof IOException) {
                    errorHandlingCallBack.networkError((IOException) t);
                } else {
                    errorHandlingCallBack.unexpectedError(t);
                }
            }
        });
    }

    /**
     * Returns true if this call has been either {@linkplain #execute() executed} or {@linkplain
     * #enqueue() enqueued}. It is an error to execute or enqueue a call more than once.
     */
    @Override
    public boolean isExecuted() {
        return call.isExecuted();
    }

    /**
     * Cancel this call. An attempt will be made to cancel in-flight calls, and if the call has not
     * yet been executed it never will be.
     */
    @Override
    public void cancel() {
        call.cancel();
    }

    /**
     * True if {@link #cancel()} was called.
     */
    @Override
    public boolean isCanceled() {
        return call.isCanceled();
    }

    /**
     * Create a new, identical call to this one which can be enqueued or executed even if this all has already been.
     */
    @Override
    public ErrorHandlingCallIntf<T> clone() {
        if (errorHandlingCallBack == null) {
            throw new IllegalStateException("You have to call initializeCallBack(ErrorHandlingCallBack callBack) before clone()");
        }
        return new ErrorHandlingCall<>(errorHandlingCallBack, call);
    }
}

public class BusinessService {
    // The call that handles errors
    ErrorHandlingCall<Post> getPostOneWithErrorCall;
    
    // The callBack that manages the errors when they appear
    ErrorHandlingCallBack errorHandlingCallBack=null;

    // Load a stuff with an errorHandlingCall
    public void loadWithErrorHandlingCall(){
        // First initialize your error handling callback
        if(errorHandlingCallBack==null){
            errorHandlingCallBack= instanciateErrorHandlingCallBack();
        }
        // Then instanciate
        getPostOneWithErrorCall=webServiceComplex.getPostOneWithError();
        // Initialize your errorCallBack
        getPostOneWithErrorCall.initializeCallBack(errorHandlingCallBack);
        // Make your call
        getPostOneWithErrorCall.enqueue();
    }
}

private ErrorHandlingCallBack instanciateErrorHandlingCallBack(){
    return new ErrorHandlingCallBack() {
        @Override
        public void success(Response response) {
            Log.e("BusinessService", "Reponse is Success" + response.body());
        }

        @Override
        public void unauthenticated(Response response) {
            Log.e("BusinessService", "UNAUTHENTICATED !!!");

        }

        @Override
        public void clientError(Response response) {
            Log.e("BusinessService", "CLIENT ERROR " + response.code());
        }

        @Override
        public void serverError(Response response) {
            Log.e("BusinessService", "Server ERROR " + response.code());
        }

        @Override
        public void networkError(IOException e) {
            Log.e("BusinessService", "IOException ", e);
        }

        @Override
        public void unexpectedError(Throwable t) {
            Log.e("BusinessService", "Death Metal Error without roses ", t);
        }
    };
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:22.2.0'
    //compile 'com.squareup.okhttp3:okhttp:3.0.1'<-a bug here
    compile 'com.squareup.retrofit2:retrofit:2.0.0-beta3'
    compile 'com.squareup.okhttp3:okhttp:3.0.0-RC1'
    compile 'com.squareup.retrofit2:converter-moshi:2.0.0-beta3'
    compile 'com.squareup.okhttp3:logging-interceptor:3.0.0-RC1'
}

public class RetrofitBuilder {
    @NonNull
    public static OkHttpClient getOkHttpClient(Context ctx) {
        // Define the OkHttp Client with its cach!
        // Assigning a CacheDirectory
        File myCacheDir = new File(ctx.getCacheDir(), "OkHttpCache");
        // You should create it...
        int cacheSize = 1024 * 1024;
        Cache cacheDir = new Cache(myCacheDir, cacheSize);
        HttpLoggingInterceptor httpLogInterceptor = new HttpLoggingInterceptor();
        httpLogInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
        return new OkHttpClient.Builder()
            //add a cach
        .cache(cacheDir)
        // Add interceptor (here to log the request)
        .addInterceptor(httpLogInterceptor)
        .build();
    }
}

public class CustomLoggingInterceptor implements Interceptor{
    //Code pasted from okHttp webSite itself
    @Override public Response intercept(Interceptor.Chain chain) throws IOException {
        Request request = chain.request();
        long t1 = System.nanoTime();
        Log.e("Interceptor Sample", String.format("Sending request %s on %s  %s.",
                request.url(), chain.connection(), request.headers().toString()));

        Response response = chain.proceed(request);

        long t2 = System.nanoTime();
        Log.e("Interceptor Sample", String.format("Received response for %s in %.1fms%n%s",
                response.request().url(), (t2 - t1) / 1e6d, response.headers()));
        return response;
    }
}

public class RetrofitBuilder {
    @NonNull
    public static OkHttpClient getOkHttpClient(Context ctx) {
        // Define the OkHttp Client with its cach!
        // Assigning a CacheDirectory
        File myCacheDir = new File(ctx.getCacheDir(), "OkHttpCache");
        // You should create it...
        int cacheSize = 1024 * 1024;
        Cache cacheDir = new Cache(myCacheDir, cacheSize);
        Interceptor customLoggingInterceptor = new CustomLoggingInterceptor();
        return new OkHttpClient.Builder()
            // Add a cach
            .cache(cacheDir)
            // Add interceptor (here to log the request)
            .addInterceptor(customLoggingInterceptor)
            .build();
    }
}