HTTP Networking in Android Apps

In the previous chapter, we discussed how to use the Room database for data storage in Android applications. Today, most apps need to interact with the network; therefore, in this chapter, we’ll learn how to perform network access using HTTP requests. This section will help you understand how to fetch data from remote servers and how to process that data.

Understanding HTTP Requests

HTTP (Hypertext Transfer Protocol) is the protocol used for communication between a client—typically an application—and a server. HTTP requests primarily fall into the following categories:

• GET: Retrieve data from the server.
• POST: Send data to the server.
• PUT: Update data on the server.
• DELETE: Delete data from the server.

Performing a GET Request Using HttpURLConnection

In Android, there are multiple ways to issue HTTP requests. The most fundamental approach is using HttpURLConnection. Below is a simple example of a GET request:

public String makeGetRequest(String urlString) {
    HttpURLConnection urlConnection = null;
    BufferedReader reader = null;

    try {
        URL url = new URL(urlString);
        urlConnection = (HttpURLConnection) url.openConnection();
        urlConnection.setRequestMethod("GET");
        urlConnection.connect();

        // Check response code
        int responseCode = urlConnection.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            InputStream inputStream = urlConnection.getInputStream();
            reader = new BufferedReader(new InputStreamReader(inputStream));
            StringBuilder stringBuilder = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line).append('\n');
            }
            return stringBuilder.toString();
        } else {
            return "Error: " + responseCode;
        }
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    } finally {
        if (urlConnection != null) {
            urlConnection.disconnect();
        }
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

The code above uses HttpURLConnection to fetch data from the specified urlString. While this approach works, it’s not recommended for production use due to its complexity and high potential for errors.

Making Network Requests with the OkHttp Library

To simplify HTTP request handling, many developers opt for third-party libraries such as OkHttp. OkHttp is a highly efficient HTTP & HTTP/2 client, renowned for significantly simplifying HTTP request implementation.

Example: Performing a GET Request with OkHttp

First, add the OkHttp dependency to your build.gradle file:

implementation 'com.squareup.okhttp3:okhttp:4.9.0'

Then, use the following code to execute a GET request:

OkHttpClient client = new OkHttpClient();

public void makeGetRequest(String url) {
    Request request = new Request.Builder()
            .url(url)
            .build();

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

        @Override
        public void onResponse(Call call, Response response) throws IOException {
            if (response.isSuccessful()) {
                final String responseData = response.body().string();
                // Update UI on the main thread
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // Process response data
                        Log.d("Response", responseData);
                    }
                });
            }
        }
    });
}

With OkHttp, sending a GET request becomes straightforward, and responses are handled via callbacks. As a developer, you no longer need to manually manage threading—OkHttp handles this automatically.

Handling JSON Data

When you send a request and receive a response, the data is often formatted as JSON. To parse this data, you’ll need a library such as Gson or Moshi.

Example: Parsing JSON with Gson

First, ensure the Gson dependency is added to your build.gradle:

implementation 'com.google.code.gson:gson:2.8.6'

Then, you can deserialize JSON into Java objects:

public class User {
    private String name;
    private int age;

    // Getter & Setter methods
}

public void parseJson(String jsonData) {
    Gson gson = new Gson();
    User user = gson.fromJson(jsonData, User.class);
    Log.d("User Name", user.getName());
}

Summary

In this chapter, we covered how to communicate with servers using HTTP requests—including basic GET requests with HttpURLConnection, and simplified network operations using the OkHttp library. We also introduced Gson for parsing JSON responses.

In the next chapter, we’ll go further by exploring Retrofit, a powerful library that streamlines network request handling. With Retrofit, you’ll be able to manage complex network interactions in a much more concise and maintainable way.

Stay tuned!