Skip to main content

How to handle timeouts in OKHTTP in Kotlin Android

How to handle timeouts in OKHTTP in Kotlin Android.

Here's a detailed step-by-step tutorial on how to handle timeouts in OKHTTP in Kotlin Android.

Step 1: Add the OKHTTP dependency to your project​

To use OKHTTP in your Android project, you need to add the OKHTTP dependency to your build.gradle file. Open your module-level build.gradle file and add the following line to the dependencies block:

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

Sync your project to download the OKHTTP library.

Step 2: Create an instance of OkHttpClient​

To handle timeouts in OKHTTP, you need to create an instance of OkHttpClient with a configured timeout. Open your Kotlin class file and import the necessary OKHTTP classes:

import okhttp3.OkHttpClient

Then, create an instance of OkHttpClient and set the desired timeout values. For example, to set a connection timeout of 10 seconds and a read timeout of 30 seconds, you can use the following code:

val client = OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .build()

Step 3: Make a request using OkHttpClient​

Once you have the OkHttpClient instance with configured timeouts, you can use it to make HTTP requests. For example, you can make a GET request to a URL using the following code:

val request = Request.Builder()
    .url("https://example.com/api/data")
    .build()

client.newCall(request).enqueue(object : Callback {
    override fun onFailure(call: Call, e: IOException) {
        // Handle failure
    }

    override fun onResponse(call: Call, response: Response) {
        // Handle response
    }
})

In the onFailure method, you can handle the case when the request fails due to a timeout. In the onResponse method, you can handle the successful response from the server.

Step 4: Handle timeouts in onFailure method​

To handle timeouts specifically in the onFailure method, you can check if the exception is an instance of SocketTimeoutException. If it is, you can handle it as a timeout error. Here's an example:

override fun onFailure(call: Call, e: IOException) {
    if (e is SocketTimeoutException) {
        // Handle timeout error
    } else {
        // Handle other failure cases
    }
}

You can customize the timeout error handling based on your application's requirements. For example, you might want to show an error message to the user or retry the request after a certain interval.

Step 5: Handle timeouts during request execution​

In addition to handling timeouts in the onFailure method, you can also handle timeouts during the request execution. OKHTTP provides a Call object that represents a single request and response. You can use the Call object to explicitly set a timeout for a specific request. Here's an example:

val request = Request.Builder()
    .url("https://example.com/api/data")
    .build()

val call = client.newCall(request)

try {
    val response = call.execute()
    // Handle response
} catch (e: SocketTimeoutException) {
    // Handle timeout error
} catch (e: IOException) {
    // Handle other failure cases
}

In this example, the execute method is used to synchronously execute the request. If a timeout occurs, a SocketTimeoutException will be thrown, which you can catch and handle accordingly.

That's it! You have now learned how to handle timeouts in OKHTTP in Kotlin Android. You can customize the timeout values and error handling based on your specific needs.