AuthInterceptor.java

public class AuthInterceptor implements Interceptor {

    private String mAccessToken;
    private final Context mContext;

    public AuthInterceptor(Context context) {
        AccessToken accessToken = AccessToken.get(context);
        mAccessToken = accessToken.accessToken;
        mContext = context;
    }

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();

        Request newRequest = request.newBuilder()
                .addHeader("Authorization", String.format("Bearer %s", mAccessToken))
                .build();

        Timber.i("Request AccessToken %s", mAccessToken);
        Timber.i("Request %s on %s%n%s", newRequest.url(), chain.connection(), newRequest.headers());
        Timber.i("Request Body : %s", bodyToString(newRequest));

        Response response = chain.proceed(newRequest);

        // Unauthorized
        if (response.code() == 401/* || response.code() == 406*/) {
            try {
                AccessToken newAccessToken = refreshAccessToken();
                if (newAccessToken == null) return null;
                Request authorizedRequest = response.request().newBuilder()
                        .header("Authorization", String.format("Bearer %s", newAccessToken.accessToken))
                        .build();
                response = chain.proceed(authorizedRequest);
            } catch (IOException e) {
                Timber.e("Authorization Error");
            }
        }

        ResponseBody responseBody = response.body();
        String responseBodyString = response.body().string();

        // now we have extracted the response body but in the process
        // we have consumed the original response and can't read it again
        // so we need to build a new one to return from this method
        Response newResponse = response.newBuilder()
                .body(ResponseBody.create(responseBody.contentType(), responseBodyString.getBytes()))
                .build();

        Timber.i("Response %d for %s, %s", response.code(), response.request().url(), response.headers());
        Timber.i("Response Body %s", responseBodyString);

        return newResponse;
    }

    private AccessToken refreshAccessToken() throws IOException {
        // Refresh access_token using a synchronous api request
        AccessToken accessToken = AccessToken.get(mContext);

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(BuildConfig.CONNECT_BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        AuthService authService = retrofit.create(AuthService.class);
        Call<AccessToken> call = authService.refreshToken(
                mContext.getString(R.string.client_id),
                mContext.getString(R.string.client_secret),
                mContext.getString(R.string.grant_type_refresh_token),
                accessToken.refreshToken
        );
        AccessToken newAccessToken = call.execute().body();

        if (newAccessToken == null || !newAccessToken.isValid()) return null;
        newAccessToken.store(mContext);
        mAccessToken = newAccessToken.accessToken;

        Timber.i("AccessToken_Refreshed: %s", newAccessToken.accessToken);

        return newAccessToken;
    }

    private static String bodyToString(final Request request) {

        try {
            Request copy = request.newBuilder().build();
            Buffer buffer = new Buffer();
            copy.body().writeTo(buffer);
            return buffer.readUtf8();
        } catch (IOException e) {
            return "Didn't work";
        } catch (Exception e) {
            return "Empty";
        }

    }

}