feat/#19: week7 compose 과제 구현

app/build.gradle

@@ -1,8 +1,13 @@
 plugins {
     id 'com.android.application'
     id 'org.jetbrains.kotlin.android'
+    id 'org.jetbrains.kotlin.plugin.serialization' version '1.9.0'
+    id 'kotlin-parcelize'
 }
 
+Properties properties = new Properties()
+properties.load(project.rootProject.file('local.properties').newDataInputStream())
+
 android {
     namespace 'com.sopt.now.compose'
     compileSdk 34
@@ -15,6 +20,8 @@ android {
         versionName "1.0"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        buildConfigField "String", "AUTH_BASE_URL", properties["auth.base.url"]
+
         vectorDrawables {
             useSupportLibrary true
         }
@@ -36,6 +43,7 @@ android {
     buildFeatures {
         compose true
         viewBinding true
+        buildConfig true
     }
     composeOptions {
         kotlinCompilerExtensionVersion '1.5.1'
@@ -69,4 +77,24 @@ dependencies {
     androidTestImplementation 'androidx.compose.ui:ui-test-junit4'
     debugImplementation 'androidx.compose.ui:ui-tooling'
     debugImplementation 'androidx.compose.ui:ui-test-manifest'
+
+    //Gson
+    implementation "com.google.code.gson:gson:2.8.9"
+
+    // Glide
+    implementation("com.github.bumptech.glide:compose:1.0.0-beta01")
+
+    // retrofit2
+    implementation("com.squareup.retrofit2:retrofit:2.11.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
+    implementation("com.jakewharton.retrofit:retrofit2-kotlinx-serialization-converter:1.0.0")
+    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.4.0")
+
+    // define a BOM and its version
+    implementation(platform("com.squareup.okhttp3:okhttp-bom:4.10.0"))
+    implementation ("androidx.compose.runtime:runtime-livedata:1.0.5")
+
+    // define any required OkHttp artifacts without version
+    implementation("com.squareup.okhttp3:okhttp")
+    implementation("com.squareup.okhttp3:logging-interceptor")
 }

app/src/main/AndroidManifest.xml

@@ -2,6 +2,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <uses-permission android:name="android.permission.INTERNET" />
+
     <application
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
@@ -11,16 +13,17 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.NOWSOPTAndroid"
+        android:usesCleartextTraffic="true"
         tools:targetApi="31">
         <activity
-            android:name=".MainActivity"
+            android:name=".presentation.MainActivity"
             android:exported="false"/>
 
         <activity
-            android:name=".SignUpActivity"
+            android:name=".presentation.SignUpActivity"
             android:exported="false"/>
 
-        <activity android:name=".LoginActivity"
+        <activity android:name=".presentation.LoginActivity"
             android:exported="true"
             android:label="@string/app_name"
             android:theme="@style/Theme.NOWSOPTAndroid">

app/src/main/java/com/sopt/now/compose/data/ApiFactory.kt

@@ -0,0 +1,57 @@
+package com.sopt.now.compose.data
+
+import android.util.Log
+import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
+import com.sopt.now.BuildConfig
+import kotlinx.serialization.json.Json
+import okhttp3.Interceptor
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Response
+import retrofit2.Retrofit
+import java.io.IOException
+
+object ApiFactory {
+    private const val BASE_URL: String = BuildConfig.AUTH_BASE_URL
+    lateinit var userPreference: UserPreference
+    var isInitialized = false
+        private set
+
+    fun initializeUserPreference(userPreference: UserPreference) {
+        ApiFactory.userPreference = userPreference
+    }
+
+    val retrofit: Retrofit by lazy {
+        Retrofit.Builder()
+            .baseUrl(BASE_URL)
+            .client(provideOkHttpClient())
+            .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
+            .build()
+    }
+
+    private fun provideOkHttpClient(): OkHttpClient = OkHttpClient.Builder()
+        .addInterceptor(HeaderInterceptor())
+        .build()
+
+    class HeaderInterceptor : Interceptor {
+        @Throws(IOException::class)
+        override fun intercept(chain: Interceptor.Chain): Response {
+            if (!ApiFactory::userPreference.isInitialized) {
+                throw IllegalStateException("UserPreference is not initialized")
+            }
+
+            val newRequest = chain.request().newBuilder()
+                .addHeader("memberId", userPreference.getUserId().toString())
+                .build()
+            Log.d("userPreference API", "${userPreference.getUserId().toString()}")
+            return chain.proceed(newRequest)
+        }
+    }
+
+    inline fun <reified T> create(): T = retrofit.create(T::class.java)
+}
+
+object ServicePool {
+    val authService = ApiFactory.create<AuthService>()
+    val userService = ApiFactory.create<UserService>()
+}

app/src/main/java/com/sopt/now/compose/data/AuthService.kt

@@ -0,0 +1,20 @@
+package com.sopt.now.compose.data
+
+import com.sopt.now.compose.data.dto.request.RequestLoginDto
+import com.sopt.now.compose.data.dto.request.RequestSignUpDto
+import com.sopt.now.compose.data.dto.response.ResponseAuthDto
+import retrofit2.Call
+import retrofit2.http.Body
+import retrofit2.http.POST
+
+interface AuthService {
+    @POST("member/join")
+    fun signUp(
+        @Body request: RequestSignUpDto,
+    ): Call<ResponseAuthDto>
+
+    @POST("member/login")
+    fun login(
+        @Body request: RequestLoginDto,
+    ): Call<ResponseAuthDto>
+}

app/src/main/java/com/sopt/now/compose/data/BaseState.kt

@@ -0,0 +1,12 @@
+package com.sopt.now.compose.data
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class BaseState(
+    @SerialName("isSuccess")
+    val isSuccess: Boolean,
+    @SerialName("message")
+    val message: String
+)

app/src/main/java/com/sopt/now/compose/data/Friend.kt

@@ -0,0 +1,14 @@
+package com.sopt.now.compose.data
+
+import androidx.annotation.DrawableRes
+
+data class Friend(
+    @DrawableRes val profileImage: Int,
+    val name: String,
+    val phone: String,
+) {
+    companion object {
+        const val TYPE_USER = 0
+        const val TYPE_FRIEND = 1
+    }
+}

app/src/main/java/com/sopt/now/compose/data/UserPreference.kt

@@ -0,0 +1,55 @@
+package com.sopt.now.compose.data
+
+import android.content.Context
+
+import androidx.core.content.edit
+import com.sopt.now.compose.data.UserPreference.UserPreferenceKeys.KEY_USER_ID
+import com.sopt.now.compose.data.UserPreference.UserPreferenceKeys.KEY_USER_NAME
+import com.sopt.now.compose.data.UserPreference.UserPreferenceKeys.KEY_USER_PHONE
+import com.sopt.now.compose.data.UserPreference.UserPreferenceKeys.PREF_USER_DATA
+
+class UserPreference(context: Context) {
+    private val sharedPreferences = context.applicationContext.getSharedPreferences(PREF_USER_DATA, Context.MODE_PRIVATE)
+
+    // 사용자 아이디 저장
+    fun saveUserId(userId: String) {
+        sharedPreferences.edit {
+            putString(KEY_USER_ID, userId)
+        }
+    }
+
+    // 사용자 아이디 가져오기
+    fun getUserId(): String? {
+        return sharedPreferences.getString(KEY_USER_ID, null)
+    }
+
+    // 사용자 데이터 저장
+    fun saveUserData(userData: UserData) {
+        sharedPreferences.edit {
+            putString(KEY_USER_ID, userData.userId)
+            putString(KEY_USER_NAME, userData.userName)
+            putString(KEY_USER_PHONE, userData.userPhone)
+        }
+    }
+
+    // 사용자 데이터 가져오기
+    fun getUserData(): UserData? {
+        with(sharedPreferences){
+            val userId = getString("userId", null)
+            val userName = getString("userName", null)
+            val userPhone = getString("userPhone", null)
+
+            return if (userId != null && userName != null && userPhone != null) {
+                UserData(userId, userName, userPhone)
+            } else {
+                null
+            }
+        }
+    }
+    object UserPreferenceKeys {
+        const val PREF_USER_DATA = "userData"
+        const val KEY_USER_ID = "userId"
+        const val KEY_USER_NAME = "userName"
+        const val KEY_USER_PHONE = "userPhone"
+    }
+}

app/src/main/java/com/sopt/now/compose/data/UserService.kt

@@ -0,0 +1,11 @@
+package com.sopt.now.compose.data
+
+import com.sopt.now.compose.data.dto.response.ResponseUserInfoDto
+import retrofit2.Call
+import retrofit2.http.GET
+
+interface UserService {
+    @GET("member/info")
+    fun userInfo(
+    ): Call<ResponseUserInfoDto>
+}

app/src/main/java/com/sopt/now/compose/data/dto/request/RequestLoginDto.kt

@@ -0,0 +1,12 @@
+package com.sopt.now.compose.data.dto.request
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class RequestLoginDto(
+    @SerialName("authenticationId")
+    val authenticationId: String,
+    @SerialName("password")
+    val password: String
+)

app/src/main/java/com/sopt/now/compose/data/dto/request/ResponseSignUpDto.kt

@@ -0,0 +1,16 @@
+package com.sopt.now.compose.data.dto.request
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class RequestSignUpDto(
+    @SerialName("authenticationId")
+    val authenticationId: String,
+    @SerialName("password")
+    val password: String,
+    @SerialName("nickname")
+    val nickname: String,
+    @SerialName("phone")
+    val phone: String,
+)

app/src/main/java/com/sopt/now/compose/data/dto/response/ResponseAuthDto.kt

@@ -0,0 +1,12 @@
+package com.sopt.now.compose.data.dto.response
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ResponseAuthDto(
+    @SerialName("code")
+    val code: Int,
+    @SerialName("message")
+    val message: String,
+)

app/src/main/java/com/sopt/now/compose/data/dto/response/ResponseUserInfoDto.kt

@@ -0,0 +1,24 @@
+package com.sopt.now.compose.data.dto.response
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ResponseUserInfoDto(
+    @SerialName("code")
+    val code: Int,
+    @SerialName("message")
+    val message: String,
+    @SerialName("data")
+    val data: UserInfo
+)
+
+@Serializable
+data class UserInfo(
+    @SerialName("authenticationId")
+    val authenticationId: String,
+    @SerialName("nickname")
+    val nickname: String,
+    @SerialName("phone")
+    val phone: String
+)

app/src/main/java/com/sopt/now/compose/data/repository/LoginRepository.kt

@@ -0,0 +1,33 @@
+package com.sopt.now.compose.data.repository
+
+import com.sopt.now.compose.core.view.UiState
+import com.sopt.now.compose.data.ApiFactory
+import com.sopt.now.compose.data.ServicePool.authService
+import com.sopt.now.compose.data.dto.request.RequestLoginDto
+import com.sopt.now.compose.data.dto.response.ResponseAuthDto
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class LoginRepository {
+    suspend fun postLogin(request: RequestLoginDto): UiState<ResponseAuthDto> {
+        return withContext(Dispatchers.IO) {
+            runCatching {
+                authService.postLogin(request)
+            }.fold(
+                { response ->
+                    val userId = response.headers()["location"]
+                    if (userId != null) {
+                        ApiFactory.userPreference.saveUserId(userId)
+                    }
+                    UiState.Success(
+                        response.body() ?: ResponseAuthDto(
+                            -1,
+                            "Empty response body"
+                        )
+                    )
+                },
+                { UiState.Failure(it.message.toString()) }
+            )
+        }
+    }
+}

app/src/main/java/com/sopt/now/compose/data/repository/SignUpRepository.kt

@@ -0,0 +1,21 @@
+package com.sopt.now.compose.data.repository
+
+import com.sopt.now.compose.core.view.UiState
+import com.sopt.now.compose.data.ServicePool
+import com.sopt.now.compose.data.dto.request.RequestSignUpDto
+import com.sopt.now.compose.data.dto.response.ResponseAuthDto
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class SignUpRepository {
+    suspend fun postSignUp(requestSignUp: RequestSignUpDto): UiState<ResponseAuthDto> {
+        return withContext(Dispatchers.IO) {
+            runCatching {
+                ServicePool.authService.postSignUp(requestSignUp)
+            }.fold(
+                { UiState.Success(it) },
+                { UiState.Failure(it.message.toString()) }
+            )
+        }
+    }
+}