Retrofit basic usage on Java Android

retrofit_basic_usage_android.java

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import org.jetbrains.annotations.NotNull;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitConfig {

    private static final String API_URL = "http://127.0.0.1:8000/api/"; // YOUR API URL
    
    public RetrofitConfig() {

    }

    public Retrofit getRetrofit(UserSession userSession, Boolean... params) {
        boolean sendCredentials;

        if (params.length == 0) {
            sendCredentials = true;
        } else {
            sendCredentials = params[0];
        }

        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BASIC);

        OkHttpClient.Builder builder = new OkHttpClient
                .Builder()
                .addInterceptor(logging)
                .connectTimeout(1, TimeUnit.MINUTES)
                .writeTimeout(1, TimeUnit.MINUTES)
                .readTimeout(1, TimeUnit.MINUTES);


        builder.addInterceptor(new Interceptor() {
            @Override
            public Response intercept(@NotNull Chain chain) throws IOException {

                Request.Builder builder = chain.request()
                        .newBuilder()
                        .addHeader("Content-Type", "application/json")
                        .addHeader("Accept", "application/json");

                // envia as credencias
                if (sendCredentials) {
                    builder.addHeader("Authorization", "Bearer "+ userSession.getUserToken());
                }

                Request newRequest = builder.build();
                return chain.proceed(newRequest);
            }
        });


        OkHttpClient client = builder.build();

        Gson gson = new GsonBuilder()
                .setLenient()
                .setDateFormat("yyyy-MM-dd HH:mm:ss")
                .create();

        return new Retrofit.Builder()
                .baseUrl(Config.API_URL)
                .client(client)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();
    }

}


/**************************
* USAGE
**************************/

/** User API Interface **/
public interface WorkDayAPI {

    @POST("users/store")
    Call<BasicResponse> store(@Body RequestBody requestBody);
}

/** A generic class to map basic fields returned by the API **/
public class BasicResponse {

    private Boolean success;

    private String message;

    public Boolean getSuccess() {
        return success;
    }

    public void setSuccess(Boolean success) {
        this.success = success;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}


/** Service to call the requests **/

import okhttp3.FormBody;
import okhttp3.RequestBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;

public class UserService {

  public static void store(@NonNull Context context, @NonNull User user) {
  
        // Body da requisicao
        // Obs.: Não usar o FormBody para envio de imagem em base64 pois ele transforma o byte-code danificando a imagem,
        // inves disso, crie uma classe de request
        
        FormBody.Builder bodyBuilder = new FormBody.Builder()
                .addEncoded("name", user.getName())
                .addEncoded("cpf", user.getCpf())
                .addEncoded("age", user.getAge().toString());  


        UserSession userSession = UserSession.getInstance(context);

        Retrofit retrofit = new RetrofitConfig()
                .getRetrofit(userSession, true);
                
                
        Call<BasicResponse> call = retrofit.create(UserAPI.class).store(requestBody);
        call.enqueue(new Callback<BasicResponse>() {
            @Override
            public void onResponse(@NotNull Call<BasicResponse> call, @NotNull Response<BasicResponse> response) {

                BasicResponse responseBody = response.body();

                if (response.isSuccessful() && responseBody != null) {

                    if (responseBody.getSuccess()) {

                        user.setSent(true);

                    } else {
                        Log.d("DEV", "UserService->store() - Erro: "+ responseBody.getMessage());
                    }
                }

                realm.close();
            }

            @Override
            public void onFailure(@NotNull Call<BasicResponse> call, @NotNull Throwable t) {
                Log.d("DEV", "UserService->store() - Erro no request: " + t.getMessage());
                t.printStackTrace();
                realm.close();
            }
        });                
  }
}