Making a minimal post request with retrofit

Question

I am trying to learn about Retrofit since it seems to take care of a lot of the issues I am currently having with JSON requests and handling.

first and foremost, I understand that the methods we use are defined inside of interfaces, while making simple requests to obtain data it is quite simple to specify what is to be retrieved from the url as well as all the necessary endpoints based on the famous github example.

So if we are retrieving information form the github api, we would first create all the necessary pojo models and such and then define the interface as:

public interface GithubService {
    @GET("users/{username}")
    Observable<Github>getGithHubUser(@Path("username")String userName);
}

From that on the main activity we would have something like:

Retrofit retrofit = new Retrofit.Builder()
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .baseUrl("https://api.github.com/")
                .build();

        GithubService githubService = retrofit.create(GithubService.class);
        Observable<Github> githubUser = githubService.getGithHubUser("usersName");
        githubUser.subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .map(user -> "Github Username: " + user.getName() + "\nUrl:" +user.getUrl() + "\nfollowing: "+ user.getHireable())
                .subscribe(userInfo -> Log.d("Output", userInfo));

My question here would be how to send JSON information if the url requires something like this:

"data={\"process\":\"procesNumber\", \"phone\":\"123456\"}"

Basically, in order to get any response form the server I have been doing this using simple okhttp:

OkHttpClient client = new OkHttpClient();
        RequestBody body = RequestBody.create(CREATE_MEDIA_TYPE, "data={\"process\":\"procesNumber\", \"phone\":\"123456\"}");
        String ALLWAYS_API = "http://something something bla bla";
        Request request = new Request.Builder()
                .url("https://blablabla")
                .post(body)
                .build();

        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                    ... etc etc etc
            }   

To my understanding, even I need to create a pojo class that represents the data that needs to be sent to retrofit, something along the lines of:

public class DataRequest {
    final String proces;
    final String phone;

    DataRequest(String process, String phone) {
        this.process = process;
        this.phone = phone;

    }
}

Which would comply to the information being sent to the request, but how would I actually parse that to the interface implementation?

interface DataService {
    @Post(not a clue what to place here)
    DataRequest postJson(@Body how?)

}

And how would I actually add that to the retrofit builder? The examples that I am using come from different forums on the web as well as other questions asked by other users, this one in particular helped a lot in understanding a couple of things: How to POST raw whole JSON in the body of a Retrofit request? but I still don't understand where everything goes and some of the other questions and examples are far too complex for what I need to do.

Answer 1

Ok, so in order to leave an answer here for anyone trying to do this. By default, retrofit comes with many utilities which handle the passing of data as JSON, but in this case what I am passing is a string that looks like json inside of a tag called data......I know..

But in order to answer this for the people facing similar issues, in order to pass in the string we need to import a scalar convertor much in the same way that we need to import a gson converter to work with our retrofit services:

compile  'com.squareup.retrofit2:converter-scalars:2.0.2'

After that, our service can be handled as:

public interface CreateService {
    @Headers({ "Content-Type: application/x-www-form-urlencoded;charset=UTF-8"})
    @POST("your/post/path/goes/here")
    Call<String> getStringScalar(@Body String body);
}

I write my service generators in a separate file, in this case, the whole thing can be used in this way:

public class ServiceGeneratorWithScalarConvertor {
    private static final String API_BASE_URL = "your/base/url/goes/here";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    // basically, this code is the same as the one from before with the added instance of creating and making use of the scalar converter factory.....scratch that i took it off
    private static Retrofit.Builder builder =
            new Retrofit.Builder()
                    .baseUrl(API_BASE_URL)
                    .addConverterFactory(ScalarsConverterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create());



    public static <S> S createService(Class<S> serviceClass) {
        builder.client(httpClient.build());
        Retrofit retrofit = builder.build();
        return retrofit.create(serviceClass);
    }
}

From there, we can access the results with this particular method(i am using this method inside my main activity:

public void retroFitCreateAPIExample() {


        CreateService service = ServiceGeneratorWithScalarConvertor.createService(CreateService.class);
        String body = "data={\"process\":\"process1\",\"phone\":\"12345\"}";
        Call<String> call = service.getStringScalar(body);
        call.enqueue(new Callback<String>() {
            @Override
            public void onResponse(Call<String> call, Response<String> response) {
                if(response.isSuccessful()){
                    Log.d("Response Body>>>>>", response.body());
                    createR = new Gson().fromJson(response.body().toString(), CreateModels.class);
                    Log.d("CREATED RESPONSE",createR.getCreate().getStops().get(0).getCity());

                }
            }

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

            }
        });


    }

The instance is this passed to the service generator that uses scalar convertors, the body of the post request is saved as a simple string(as it was specified in the interface) and we can do with the response whatever we want.