Skip to main content

How to send DELETE requests using Retrofit in Kotlin Android

How to send DELETE requests using Retrofit in Kotlin Android.

Here is a step-by-step tutorial on how to send DELETE requests using Retrofit in Kotlin Android.

Step 1: Set up Retrofit in your Android project​

To use Retrofit, you need to add the necessary dependencies to your project. Open your project's build.gradle file and add the following lines of code:

dependencies {
    // Other dependencies...

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
}

Step 2: Create a data model class​

Before sending a DELETE request, you need to define a data model class that represents the data you will send or receive. For example, let's say we have a User class:

data class User(
    val id: Int,
    val name: String,
    val email: String
)

Step 3: Define an API interface​

Next, you need to define an API interface that describes the endpoints you will be calling. In this case, we'll create a UserService interface:

interface UserService {
    @DELETE("users/{id}")
    suspend fun deleteUser(@Path("id") userId: Int): Response<Void>
}

Here, we use the @DELETE annotation to specify that this endpoint should handle DELETE requests. The {id} placeholder will be replaced with the actual user ID.

Step 4: Create a Retrofit instance​

To send DELETE requests, you need to create a Retrofit instance. In your Kotlin file, create a variable to hold the Retrofit instance:

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/") // Replace with your base URL
    .addConverterFactory(GsonConverterFactory.create())
    .build()

val userService = retrofit.create(UserService::class.java)

Make sure to replace "https://api.example.com/" with the base URL of your API.

Step 5: Send a DELETE request​

Now, you can use the userService instance to send DELETE requests. For example, to delete a user with ID 1:

val userId = 1
userService.deleteUser(userId).enqueue(object : Callback<Void> {
    override fun onResponse(call: Call<Void>, response: Response<Void>) {
        if (response.isSuccessful) {
            // User deleted successfully
        } else {
            // Handle error
        }
    }

    override fun onFailure(call: Call<Void>, t: Throwable) {
        // Handle failure
    }
})

Here, we call the deleteUser function on the userService instance and pass the user ID as a parameter. We use the enqueue method to asynchronously send the request and handle the response using a callback.

Alternatively, you can use coroutines to send the DELETE request:

val userId = 1
try {
    val response = userService.deleteUser(userId)
    if (response.isSuccessful) {
        // User deleted successfully
    } else {
        // Handle error
    }
} catch (e: Exception) {
    // Handle failure
}

In this case, we use the suspend modifier on the deleteUser function to make it a coroutine. We use a try-catch block to handle any exceptions that may occur.

And that's it! You have now learned how to send DELETE requests using Retrofit in Kotlin Android.