feat: Implement user data fetching with Retrofit

This commit introduces the ability to fetch user data from a remote API using Retrofit. It includes setting up the network layer, defining data classes, and creating a repository to handle the data retrieval.

Changes:

-   Created `UserApi` interface to define the API endpoint for fetching users using `@GET("/users")`.
-   Created `RetrofitInstance` to provide a configured Retrofit instance and `UserApi`. It includes:
    -   A `provideRetrofit` function that configures Retrofit with a base URL, an `OkHttpClient` with a logging interceptor, and a `GsonConverterFactory`.
    -   A `provideUserApi` function that creates and returns an instance of the `UserApi`.
-   Added `UserRepository` to manage fetching user data. It uses a flow to emit results and handles network errors.
-   Added `User`, `Address`, `Geo`, and `Company` data classes to represent the user data structure.
-   `UserRepository` now handles API responses, emits either a list of users or an error Result, and shifts network operations to `Dispatchers.IO` using `flowOn`.
- Added dependencies `okhttp3`, `logging-interceptor`, `retrofit2`, `converter-gson`

Author: CGreenP

app/src/main/java/com/example/techexactly/model/dataclass/User.kt

@@ -0,0 +1,31 @@
+package com.example.techexactly.model.dataclass
+
+data class User(
+    val id: Long,
+    val name: String,
+    val username: String,
+    val email: String,
+    val address: Address,
+    val phone: String,
+    val website: String,
+    val company: Company,
+)
+
+data class Address(
+    val street: String,
+    val suite: String,
+    val city: String,
+    val zipcode: String,
+    val geo: Geo,
+)
+
+data class Geo(
+    val lat: String,
+    val lng: String,
+)
+
+data class Company(
+    val name: String,
+    val catchPhrase: String,
+    val bs: String,
+)

app/src/main/java/com/example/techexactly/model/network/RetrofitInstance.kt

@@ -0,0 +1,27 @@
+package com.example.techexactly.model.network
+
+import com.google.gson.GsonBuilder
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+
+private const val BASE_URL = "https://jsonplaceholder.typicode.com/"
+
+fun provideRetrofit(): Retrofit {
+    val loggingInterceptor = HttpLoggingInterceptor().apply {
+        level = HttpLoggingInterceptor.Level.BODY
+    }
+    val okHttpClient = OkHttpClient.Builder().addInterceptor(loggingInterceptor).build()
+    val gson = GsonBuilder().setLenient().create()
+
+    return Retrofit.Builder()
+        .baseUrl(BASE_URL)
+        .client(okHttpClient)
+        .addConverterFactory(GsonConverterFactory.create(gson))
+        .build()
+}
+
+fun provideUserApi(retrofit: Retrofit): UserApi {
+    return retrofit.create(UserApi::class.java)
+}

app/src/main/java/com/example/techexactly/model/network/UserApi.kt

@@ -0,0 +1,10 @@
+package com.example.techexactly.model.network
+
+import com.example.techexactly.model.dataclass.User
+import retrofit2.Response
+import retrofit2.http.GET
+
+interface UserApi {
+    @GET("/users")
+    suspend fun getUsers(): Response<List<User>>
+}

app/src/main/java/com/example/techexactly/model/repository/UserRepository.kt

@@ -0,0 +1,28 @@
+package com.example.techexactly.model.repository
+
+import com.example.techexactly.model.dataclass.User
+import com.example.techexactly.model.network.UserApi
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+
+class UserRepository(private val userApi: UserApi) {
+    fun getUsers(): Flow<Result<List<User>>> = flow {
+        try {
+            // Switch to Dispatchers.IO for the network call.
+            val response = userApi.getUsers()
+            if (response.isSuccessful) {
+                // Handle success case.
+                val users = response.body() ?: emptyList()
+                emit(Result.success(users))
+            } else {
+                // Handle HTTP error cases.
+                emit(Result.failure(Exception("Error: ${response.code()} ${response.message()}")))
+            }
+        } catch (e: Exception) {
+            // Handle any exception during the network call.
+            emit(Result.failure(Exception("Error fetching users: ${e.message}")))
+        }
+    }.flowOn(Dispatchers.IO) // Use flowOn to change the context of the flow to Dispatchers.IO
+}