[feature/#7] 4주차 과제 구현

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:name=".AtSoptApplication"
         android:allowBackup="true"
@@ -12,8 +14,9 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.ATSOPTANDROID"
+        android:usesCleartextTraffic="true"
         tools:targetApi="31">
 
     </application>
 
-</manifest>
+</manifest>

data/build.gradle.kts

@@ -1,3 +1,5 @@
+import java.util.Properties
+
 plugins {
     alias(libs.plugins.android.library)
     alias(libs.plugins.jetbrains.kotlin.android)
@@ -7,6 +9,10 @@ plugins {
     alias(libs.plugins.dagger.hilt)
 }
 
+val properties = Properties().apply {
+    load(project.rootProject.file("local.properties").inputStream())
+}
+
 android {
     namespace = "org.sopt.at.data"
     compileSdk = libs.versions.compileSdk.get().toInt()
@@ -16,6 +22,7 @@ android {
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles("consumer-rules.pro")
+        buildConfigField("String", "BASE_URL", properties["base.url"].toString())
     }
 
     buildTypes {
@@ -34,6 +41,9 @@ android {
     kotlinOptions {
         jvmTarget = "11"
     }
+    buildFeatures {
+        buildConfig = true
+    }
 }
 
 dependencies {
@@ -62,6 +72,13 @@ dependencies {
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.activity.compose)
 
+    implementation(platform(libs.okhttp.bom))
+    implementation(libs.okhttp)
+    implementation(libs.okhttp.logging.interceptor)
+    implementation(libs.retrofit)
+    implementation(libs.retrofit.kotlin.serialization.converter)
+    implementation(libs.kotlinx.serialization.json)
+
     implementation(libs.androidx.ui)
     implementation(libs.androidx.ui.graphics)
     implementation(libs.androidx.ui.tooling.preview)

data/src/main/java/org/sopt/at/data/datasource/AuthDataSource.kt

@@ -0,0 +1,14 @@
+package org.sopt.at.data.datasource
+
+import org.sopt.at.data.dto.request.SignInRequestDto
+import org.sopt.at.data.dto.request.SignUpRequestDto
+import org.sopt.at.data.service.AuthService
+import javax.inject.Inject
+
+internal class AuthDataSource @Inject constructor(
+    private val authService: AuthService
+) {
+    suspend fun signUp(signUpRequest: SignUpRequestDto) = authService.signUp(signUpRequest)
+
+    suspend fun signIn(signInRequest: SignInRequestDto) = authService.signIn(signInRequest)
+}

data/src/main/java/org/sopt/at/data/datasource/UserDataSource.kt → data/src/main/java/org/sopt/at/data/datasource/UserLocalDataSource.kt

@@ -4,7 +4,7 @@ import android.content.SharedPreferences
 import javax.inject.Inject
 import androidx.core.content.edit
 
-internal class UserDataSource @Inject constructor(
+internal class UserLocalDataSource @Inject constructor(
     private val userSharedPreference: SharedPreferences
 ) {
     var id: String
@@ -15,15 +15,22 @@ internal class UserDataSource @Inject constructor(
         get() = userSharedPreference.getString(PASSWORD, "").toString()
         set(value) = userSharedPreference.edit { putString(PASSWORD, value) }
 
+    var userId: Long
+        get() = userSharedPreference.getLong(USER_ID, -1)
+        set(value) = userSharedPreference.edit { putLong("userId", value) }
+
+
     fun clearUserPreference() {
         id = DEFAULT_STRING
         password = DEFAULT_STRING
+        userId = -1
         userSharedPreference.edit { clear() }
     }
 
     companion object {
         private const val ID = "id"
         private const val PASSWORD = "password"
+        private const val USER_ID = "userId"
         private const val DEFAULT_STRING = ""
     }
 }

data/src/main/java/org/sopt/at/data/datasource/UserRemoteDataSource.kt

@@ -0,0 +1,10 @@
+package org.sopt.at.data.datasource
+
+import org.sopt.at.data.service.UserService
+import javax.inject.Inject
+
+internal class UserRemoteDataSource @Inject constructor(
+    private val userService: UserService
+) {
+    suspend fun getMyNickName() = userService.getMyNickName()
+}

data/src/main/java/org/sopt/at/data/di/NetworkModule.kt

@@ -0,0 +1,66 @@
+package org.sopt.at.data.di
+
+import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import org.sopt.at.data.BuildConfig
+import org.sopt.at.data.datasource.UserLocalDataSource
+import org.sopt.at.data.service.AuthInterceptor
+import retrofit2.Converter
+import retrofit2.Retrofit
+import java.util.concurrent.TimeUnit
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object NetworkModule {
+
+    @Provides
+    @Singleton
+    fun providesLoggingInterceptor() = HttpLoggingInterceptor().apply {
+        level = if (BuildConfig.DEBUG) {
+            HttpLoggingInterceptor.Level.BODY
+        } else {
+            HttpLoggingInterceptor.Level.NONE
+        }
+
+    }
+
+    @Provides
+    @Singleton
+    fun providesOkHttpClient(
+        loggingInterceptor: HttpLoggingInterceptor,
+        authInterceptor: AuthInterceptor
+    ): OkHttpClient = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(10, TimeUnit.SECONDS)
+        .addInterceptor(authInterceptor)
+        .addInterceptor(loggingInterceptor)
+        .build()
+
+    @Provides
+    @Singleton
+    fun provideAuthInterceptor(userLocalDataSource: UserLocalDataSource): AuthInterceptor =
+        AuthInterceptor(userLocalDataSource)
+
+    @Provides
+    @Singleton
+    fun providesConverterFactory(): Converter.Factory = Json.asConverterFactory("application/json".toMediaType())
+
+    @Provides
+    @Singleton
+    fun providesRetrofit(
+        client: OkHttpClient,
+        converterFactory: Converter.Factory
+    ): Retrofit = Retrofit.Builder()
+        .baseUrl(BuildConfig.BASE_URL)
+        .addConverterFactory(converterFactory)
+        .client(client)
+        .build()
+}

data/src/main/java/org/sopt/at/data/di/RepositoryModule.kt

@@ -4,12 +4,17 @@ import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
+import org.sopt.at.data.repository.AuthRepositoryImpl
 import org.sopt.at.data.repository.UserRepositoryImpl
+import org.sopt.at.repository.AuthRepository
 import org.sopt.at.repository.UserRepository
 
 @Module
 @InstallIn(SingletonComponent::class)
 internal interface RepositoryModule {
     @Binds
     fun bindUserRepository(userRepositoryImpl: UserRepositoryImpl): UserRepository
+
+    @Binds
+    fun bindAuthRepository(authRepositoryImpl: AuthRepositoryImpl): AuthRepository
 }

data/src/main/java/org/sopt/at/data/di/ServiceModule.kt

@@ -0,0 +1,24 @@
+package org.sopt.at.data.di
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import org.sopt.at.data.service.AuthService
+import org.sopt.at.data.service.UserService
+import retrofit2.Retrofit
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object ServiceModule {
+    @Provides
+    @Singleton
+    fun provideAuthService(retrofit: Retrofit): AuthService =
+        retrofit.create(AuthService::class.java)
+
+    @Provides
+    @Singleton
+    fun provideUserService(retrofit: Retrofit): UserService =
+        retrofit.create(UserService::class.java)
+}

data/src/main/java/org/sopt/at/data/dto/request/SignInRequestDto.kt

@@ -0,0 +1,15 @@
+package org.sopt.at.data.dto.request
+
+import kotlinx.serialization.Serializable
+import org.sopt.at.entity.SignInEntity
+
+@Serializable
+internal data class SignInRequestDto(
+    val loginId: String,
+    val password: String
+)
+
+internal fun SignInEntity.toDto() = SignInRequestDto(
+    loginId = id,
+    password = password
+)

data/src/main/java/org/sopt/at/data/dto/request/SignUpRequestDto.kt

@@ -0,0 +1,17 @@
+package org.sopt.at.data.dto.request
+
+import kotlinx.serialization.Serializable
+import org.sopt.at.entity.SignUpEntity
+
+@Serializable
+internal data class SignUpRequestDto(
+    val loginId: String,
+    val nickname: String,
+    val password: String
+)
+
+internal fun SignUpEntity.toDto() = SignUpRequestDto(
+    loginId = loginId,
+    nickname = nickname,
+    password = password
+)

data/src/main/java/org/sopt/at/data/dto/response/BaseResponseDto.kt

@@ -0,0 +1,11 @@
+package org.sopt.at.data.dto.response
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class BaseResponseDto<T>(
+    val success: Boolean,
+    val code: String,
+    val message: String,
+    val data: T?
+)

data/src/main/java/org/sopt/at/data/dto/response/MyNicknameResponseDto.kt

@@ -0,0 +1,13 @@
+package org.sopt.at.data.dto.response
+
+import kotlinx.serialization.Serializable
+import org.sopt.at.entity.MyNicknameEntity
+
+@Serializable
+data class MyNicknameResponseDto(
+    val nickname: String
+) {
+    fun toEntity() = MyNicknameEntity(
+        nickname = nickname
+    )
+}

data/src/main/java/org/sopt/at/data/dto/response/SignInResponseDto.kt

@@ -0,0 +1,13 @@
+package org.sopt.at.data.dto.response
+
+import kotlinx.serialization.Serializable
+import org.sopt.at.entity.SignInUserEntity
+
+@Serializable
+data class SignInResponseDto(
+    val userId: Long
+) {
+    fun toEntity() = SignInUserEntity(
+        userId = userId
+    )
+}

data/src/main/java/org/sopt/at/data/dto/response/SignUpResponseDto.kt

@@ -0,0 +1,15 @@
+package org.sopt.at.data.dto.response
+
+import kotlinx.serialization.Serializable
+import org.sopt.at.entity.SignUpUserEntity
+
+@Serializable
+data class SignUpResponseDto(
+    val userId: Long,
+    val nickname: String
+) {
+    fun toEntity() = SignUpUserEntity(
+        userId = userId,
+        nickname = nickname
+    )
+}

data/src/main/java/org/sopt/at/data/repository/AuthRepositoryImpl.kt

@@ -0,0 +1,66 @@
+package org.sopt.at.data.repository
+
+import org.sopt.at.data.datasource.AuthDataSource
+import org.sopt.at.data.dto.request.toDto
+import org.sopt.at.data.service.jsonToErrorMessage
+import org.sopt.at.entity.ApiException
+import org.sopt.at.entity.SignInEntity
+import org.sopt.at.entity.SignInUserEntity
+import org.sopt.at.entity.SignUpEntity
+import org.sopt.at.entity.SignUpUserEntity
+import org.sopt.at.repository.AuthRepository
+import retrofit2.HttpException
+import javax.inject.Inject
+
+internal class AuthRepositoryImpl @Inject constructor(
+    private val authDataSource: AuthDataSource
+) : AuthRepository {
+
+    override suspend fun signUp(signUpData: SignUpEntity): Result<SignUpUserEntity> =
+        runCatching {
+            val response = authDataSource.signUp(signUpData.toDto())
+
+            if (!response.success || response.data == null) {
+                throw ApiException(response.message)
+            }
+
+            response.data.toEntity()
+        }.recoverCatching { throwable ->
+            when (throwable) {
+                is HttpException -> {
+                    val errorBodyStr = throwable.response()?.errorBody()?.string()
+
+                    val message = jsonToErrorMessage(errorBodyStr)
+                        ?: "Unknown error"
+
+                    throw ApiException(message)
+                }
+
+                else -> throw throwable
+            }
+        }
+
+    override suspend fun signIn(signInEntity: SignInEntity): Result<SignInUserEntity?> =
+        runCatching {
+            val response = authDataSource.signIn(signInEntity.toDto())
+
+            if (!response.success || response.data == null) {
+                throw ApiException(response.message)
+            }
+
+            response.data.toEntity()
+        }.recoverCatching { throwable ->
+            when (throwable) {
+                is HttpException -> {
+                    val errorBodyStr = throwable.response()?.errorBody()?.string()
+
+                    val message = jsonToErrorMessage(errorBodyStr)
+                        ?: "Unknown error"
+
+                    throw ApiException(message)
+                }
+
+                else -> throw throwable
+            }
+        }
+}