Android Network Access with Retrofit

In the previous chapter, we discussed how to interact with networks using standard HTTP requests. This chapter introduces Retrofit, a powerful networking framework that simplifies network request handling and data processing.

What Is Retrofit?

Retrofit is a networking library developed by Square that helps you easily access web services. It supports calling RESTful APIs and can automatically convert network response data into Java objects—greatly streamlining the process of making network requests.

Basic Usage of Retrofit

1. Add Dependencies

First, add Retrofit dependencies to your build.gradle file:

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0' // Required if using Gson for JSON parsing
}

2. Define an API Interface

Create an interface to declare your network endpoints. In this example, we’ll fetch a list of users from a public API.

import retrofit2.Call;
import retrofit2.http.GET;
import java.util.List;

public interface ApiService {
    @GET("users")
    Call<List<User>> getUsers();
}

3. Configure a Retrofit Instance

Next, create a Retrofit instance and use it to generate an implementation of your ApiService interface.

import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {
    private static final String BASE_URL = "https://jsonplaceholder.typicode.com/";
    private static Retrofit retrofit = null;

    public static Retrofit getClient() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        }
        return retrofit;
    }
}

4. Make an API Call

Now you can use Retrofit to invoke the API. Below is an example of using Retrofit inside an Activity:

import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import java.util.List;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

public class MainActivity extends AppCompatActivity {
    private ApiService apiService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        apiService = RetrofitClient.getClient().create(ApiService.class);
        fetchUsers();
    }

    private void fetchUsers() {
        Call<List<User>> call = apiService.getUsers();
        call.enqueue(new Callback<List<User>>() {
            @Override
            public void onResponse(Call<List<User>> call, Response<List<User>> response) {
                if (response.isSuccessful()) {
                    List<User> users = response.body();
                    // Process the user list
                    for (User user : users) {
                        Log.d("MainActivity", "User: " + user.getName());
                    }
                }
            }

            @Override
            public void onFailure(Call<List<User>> call, Throwable t) {
                Log.e("MainActivity", "Error: " + t.getMessage());
            }
        });
    }
}

5. Define the User Class

To allow Retrofit to correctly parse JSON responses, define a User class matching the structure of the returned data.

public class User {
    private int id;
    private String name;
    private String username;
    private String email;

    // Getters and setters

    public String getName() {
        return name;
    }
}

6. Run the App

Ensure your device or emulator has a working internet connection. After launching the app, you’ll see user data fetched from the network and logged to Logcat with each user’s name.

Summary

In this chapter, we learned how to perform network requests using Retrofit. Through straightforward steps, we created a Retrofit instance, defined an API interface, and successfully retrieved remote data. The biggest advantage of Retrofit is its ability to automatically deserialize response bodies—reducing boilerplate code, minimizing errors, and boosting development efficiency.

In the next chapter, we’ll explore how to parse JSON data more deeply, enabling richer integration of fetched data into your application. Stay tuned!