Retrofit

Key Features of Retrofit:

1. Declarative API: Retrofit allows you to define API endpoints as Java/Kotlin interfaces with annotations specifying the HTTP request type, URL, headers, query parameters, and request body.

2. Type Safety: It generates implementation code at compile time based on the interface definitions. This provides compile-time checks for request and response types, reducing runtime errors.

3. Serialization: Retrofit integrates seamlessly with popular serialization libraries like Gson or Moshi to automatically convert JSON responses to Java/Kotlin objects and vice versa.

4. Support for different HTTP methods: It supports various HTTP methods like GET, POST, PUT, DELETE, etc., and allows customization of request headers, query parameters, and request bodies.

5. Interceptor Support: Being built on top of OkHttp, Retrofit leverages OkHttp's powerful features, including interceptors for logging, authentication, or manipulating requests and responses.

Explanation:

• all type of rest api method can be declared in interface and after that it can be fired from retrofit Instance object

• all method get response in json format to store them we will provide model class and Encapsulate using Call< > Class of Retrofit.

• Retrofit Builder: You configure Retrofit with a base URL and add converters like GsonConverterFactory to parse JSON responses.

• API Interface: You define the API endpoints as methods in an interface annotated with HTTP methods (e.g., @GET, @POST), specifying the endpoint paths and return types.

• Making Requests: Retrofit generates an implementation of the API interface, allowing you to make network requests synchronously or asynchronously. Responses are handled using callback methods.

Retrofit

Key Features

1. Declarative API using annotations

2. Type safety with compile-time checks

3. JSON serialization support (Gson, Moshi, Kotlin Serialization)

4. Supports multiple HTTP methods (GET, POST, PUT, DELETE…)

5. Interceptors and OkHttp support

Dependencies Setup

// Retrofit main dependency
implementation("com.squareup.retrofit2:retrofit:2.9.0")

// JSON Converter Libraries
implementation("com.squareup.retrofit2:converter-gson:2.9.0")
implementation("com.squareup.retrofit2:converter-moshi:2.9.0")

// Coroutines (optional)
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2")

object RetrofitInstance {

    private val retrofit by lazy {
        Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    val apiService: ApiService by lazy {
        retrofit.create(ApiService::class.java)
    }
}

interface ApiService {
    @GET("endpoint")
    fun getData(): Call<DataModel>
}

RetrofitInstance.apiService.getData().enqueue(object : Callback<DataModel> {
    override fun onResponse(call: Call<DataModel>, response: Response<DataModel>) {
        if (response.isSuccessful) {
            val data = response.body()
        }
    }

    override fun onFailure(call: Call<DataModel>, t: Throwable) {
        t.printStackTrace()
    }
})

@GET("posts/{id}")
fun getPostById(@Path("id") id: Int): Call<PostItem>

@GET("posts")
fun getPostsByUser(@Query("userId") userId: Int): Call<List<PostItem>

@GET("posts")
fun getPosts(
    @Query("userId") userId: Int,
    @Query("_sort") sort: String?,
    @Query("_order") order: String?
): Call<List<PostItem>>

@GET("posts")
fun getPostsQueryMap(@QueryMap params: HashMap<String, String>): Call<List<PostItem>>

@GET
fun getCommentsByUrl(@Url url: String): Call<List<Comment>>

@POST("posts")
fun createPost(@Body post: PostItem): Call<PostItem>

interface ApiService {
    @GET("posts")
    suspend fun getPosts(): Response<List<PostItem>>
}

viewModelScope.launch {
    val response = RetrofitInstance.apiService.getPosts()
    if (response.isSuccessful) {
        val list = response.body()
    }
}

sealed class ApiResult<T> {
    data class Success<T>(val data: T): ApiResult<T>()
    data class Error<T>(val message: String): ApiResult<T>()
}

suspend fun fetchPost(): ApiResult<List<PostItem>> {
    return try {
        val res = apiService.getPosts()
        if (res.isSuccessful) ApiResult.Success(res.body()!!)
        else ApiResult.Error(res.message())
    } catch (e: Exception) {
        ApiResult.Error(e.localizedMessage ?: "Error")
    }
}

val logging = HttpLoggingInterceptor().apply {
    level = HttpLoggingInterceptor.Level.BODY
}

val client = OkHttpClient.Builder()
    .addInterceptor(logging)
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .client(client)
    .addConverterFactory(GsonConverterFactory.create())
    .build()

Additional Network Request Scenarios

✅ Passing Headers / Token Authentication

// Example: Using OkHttp interceptor globally
val client = OkHttpClient.Builder()
    .addInterceptor { chain ->
        val original = chain.request()
        val request = original.newBuilder()
            .header("Authorization", "Bearer $token")         // pass token
            .header("Accept", "application/json")             // other custom header
            .build()
        chain.proceed(request)
    }
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .client(client)
    .addConverterFactory(GsonConverterFactory.create())
    .build()

interface ApiService {
    @GET("endpoint")
    fun getData(@Header("Authorization") token: String): Call<DataModel>
}

✅ Form-URL Encoded Requests (application/x-www-form-urlencoded)

interface ApiService {
    @FormUrlEncoded
    @POST("login")
    fun login(
        @Field("username") username: String,
        @Field("password") password: String
    ): Call<LoginResponse>
}

@FormUrlEncoded
@POST("submit")
fun submitForm(@FieldMap fields: Map<String, String>): Call<SubmitResponse>

✅ Uploading Image/File (Multipart)

interface ApiService {
    @Multipart
    @POST("upload")
    fun uploadFile(
        @Part file: MultipartBody.Part,
        @Part("description") description: RequestBody
    ): Call<UploadResponse>
}

val file = File(path)
val requestFile = file.asRequestBody("image/jpeg".toMediaTypeOrNull())
val body = MultipartBody.Part.createFormData("image", file.name, requestFile)

val description = "My image upload".toRequestBody("text/plain".toMediaTypeOrNull())

apiService.uploadFile(body, description).enqueue(...)

✅ Putting It All Together

// Retrofit setup with interceptor as above
// ...
interface ApiService {
    @Multipart
    @POST("user/profile/upload")
    fun uploadProfile(
        @Header("Authorization") token: String,
        @Part image: MultipartBody.Part,
        @Part("userId") userId: RequestBody
    ): Call<GenericResponse>
}

val tokenHeader = "Bearer $token"

val file = File(imagePath)
val imagePart = MultipartBody.Part.createFormData(
    "profile_pic", file.name,
    file.asRequestBody("image/jpeg".toMediaTypeOrNull())
)

val userIdPart = userId.toString()
    .toRequestBody("text/plain".toMediaTypeOrNull())

apiService.uploadProfile(tokenHeader, imagePart, userIdPart)
    .enqueue(…)