fix: 리프레시 토큰 로직 수정

android/app/src/main/AndroidManifest.xml

@@ -5,8 +5,12 @@
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+    <uses-permission
+        android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="32" />
+    <uses-permission
+        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="28" />
 
     <application
         android:name=".NaagaApplication"

android/app/src/main/java/com/now/naaga/NaagaApplication.kt

@@ -1,10 +1,7 @@
 package com.now.naaga
 
 import android.app.Application
-import androidx.appcompat.app.AppCompatDelegate
 import com.kakao.sdk.common.KakaoSdk
-import com.now.naaga.data.local.AuthDataSource
-import com.now.naaga.data.local.DefaultAuthDataSource
 import dagger.hilt.android.HiltAndroidApp
 
 @HiltAndroidApp
@@ -13,23 +10,9 @@ class NaagaApplication : Application() {
     override fun onCreate() {
         super.onCreate()
         initKakaoSdk()
-        initDataSources()
-        disableDarkMode()
-    }
-
-    private fun disableDarkMode() {
-        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
     }
 
     private fun initKakaoSdk() {
         KakaoSdk.init(this, BuildConfig.KAKAO_NATIVE_APP_KEY)
     }
-
-    private fun initDataSources() {
-        authDataSource = DefaultAuthDataSource(applicationContext)
-    }
-
-    companion object DependencyContainer {
-        lateinit var authDataSource: AuthDataSource
-    }
 }

android/app/src/main/java/com/now/naaga/data/remote/dto/post/RefreshTokenDto.kt

@@ -0,0 +1,10 @@
+package com.now.naaga.data.remote.dto.post
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class RefreshTokenDto(
+    @SerialName("refreshToken")
+    val refreshToken: String,
+)

android/app/src/main/java/com/now/naaga/data/remote/retrofit/AuthInterceptor.kt

@@ -1,110 +1,42 @@
 package com.now.naaga.data.remote.retrofit
 
-import com.google.gson.Gson
-import com.google.gson.JsonParser
-import com.now.naaga.BuildConfig
-import com.now.naaga.NaagaApplication
-import com.now.naaga.data.remote.dto.FailureDto
-import com.now.naaga.data.remote.dto.NaagaAuthDto
-import com.now.naaga.data.throwable.DataThrowable
-import kotlinx.coroutines.Dispatchers
+import com.now.domain.repository.AuthRepository
 import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withContext
 import okhttp3.Interceptor
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.OkHttpClient
 import okhttp3.Request
-import okhttp3.RequestBody
-import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 import okhttp3.internal.closeQuietly
-import org.json.JSONObject
-
-class AuthInterceptor : Interceptor {
-    private val gson = Gson()
-    private val client = OkHttpClient.Builder().build()
+import java.io.IOException
 
+class AuthInterceptor(
+    private val authRepository: AuthRepository,
+) : Interceptor {
     override fun intercept(chain: Interceptor.Chain): Response {
-        val accessToken = getAccessToken() ?: return chain.proceed(chain.request())
+        val accessToken = authRepository.getAccessToken() ?: return chain.proceed(chain.request())
 
-        val headerAddedRequest = chain.request().newBuilder().addHeader(AUTH_KEY, accessToken).build()
-        val response: Response = chain.proceed(headerAddedRequest)
+        val tokenAddedRequest = chain.request().putToken(accessToken)
+        val response: Response = chain.proceed(tokenAddedRequest)
 
-        if (response.code == 401) {
-            val newAccessToken = getAccessTokenAfterRefresh(accessToken).getOrElse { return response }
+        if (response.isTokenInvalid()) {
             response.closeQuietly()
-            return chain.proceed(chain.request().newBuilder().addHeader(AUTH_KEY, newAccessToken).build())
+            runCatching { runBlocking { authRepository.refreshAccessToken() } }
+                .onFailure { throw IOException(it) }
+            return chain.proceed(chain.request().putToken(authRepository.getAccessToken()!!))
         }
         return response
     }
 
-    private fun getAccessTokenAfterRefresh(accessToken: String): Result<String> {
-        val requestBody = createRefreshRequestBody()
-        val request = createRefreshRequest(requestBody, accessToken)
-
-        val auth: NaagaAuthDto = requestRefresh(request).getOrElse {
-            return Result.failure(it)
-        }
-        storeToken(auth.accessToken, auth.refreshToken)
-        return Result.success(BEARER + auth.accessToken)
-    }
-
-    private fun createRefreshRequestBody(): RequestBody {
-        return JSONObject()
-            .put(AUTH_REFRESH_KEY, getRefreshToken())
-            .toString()
-            .toRequestBody(contentType = "application/json".toMediaType())
+    private fun Response.isTokenInvalid(): Boolean {
+        return this.code == 401
     }
 
-    private fun createRefreshRequest(requestBody: RequestBody, accessToken: String): Request {
-        return Request.Builder()
-            .url(BuildConfig.BASE_URL + AUTH_REFRESH_PATH)
-            .post(requestBody)
+    private fun Request.putToken(accessToken: String): Request {
+        return this.newBuilder()
             .addHeader(AUTH_KEY, accessToken)
             .build()
     }
 
-    private fun requestRefresh(request: Request): Result<NaagaAuthDto> {
-        val response: Response = runBlocking {
-            withContext(Dispatchers.IO) { client.newCall(request).execute() }
-        }
-        if (response.isSuccessful) {
-            return Result.success(response.getDto<NaagaAuthDto>())
-        }
-        val failedResponse = response.getDto<FailureDto>()
-        if (failedResponse.code == 101) {
-            return Result.failure(DataThrowable.AuthorizationThrowable(failedResponse.code, failedResponse.message))
-        }
-        return Result.failure(IllegalStateException(REFRESH_FAILURE))
-    }
-
-    private fun getAccessToken(): String? {
-        return NaagaApplication.authDataSource.getAccessToken()
-    }
-
-    private fun getRefreshToken(): String {
-        return requireNotNull(NaagaApplication.authDataSource.getRefreshToken()) { NO_REFRESH_TOKEN }
-    }
-
-    private fun storeToken(accessToken: String, refreshToken: String) {
-        NaagaApplication.authDataSource.setAccessToken(accessToken)
-        NaagaApplication.authDataSource.setRefreshToken(refreshToken)
-    }
-
-    private inline fun <reified T> Response.getDto(): T {
-        val responseObject = JsonParser.parseString(body?.string()).asJsonObject
-        return gson.fromJson(responseObject, T::class.java)
-    }
-
     companion object {
         private const val AUTH_KEY = "Authorization"
-        private const val AUTH_REFRESH_KEY = "refreshToken"
-
-        private const val AUTH_REFRESH_PATH = "/auth/refresh"
-
-        private const val BEARER = "Bearer "
-
-        private const val NO_REFRESH_TOKEN = "리프레시 토큰이 없습니다"
-        private const val REFRESH_FAILURE = "토큰 리프레시 실패"
     }
 }

android/app/src/main/java/com/now/naaga/data/remote/retrofit/service/AuthService.kt

@@ -2,9 +2,11 @@ package com.now.naaga.data.remote.retrofit.service
 
 import com.now.naaga.data.remote.dto.NaagaAuthDto
 import com.now.naaga.data.remote.dto.PlatformAuthDto
+import com.now.naaga.data.remote.dto.post.RefreshTokenDto
 import retrofit2.Response
 import retrofit2.http.Body
 import retrofit2.http.DELETE
+import retrofit2.http.Header
 import retrofit2.http.POST
 
 interface AuthService {
@@ -14,8 +16,17 @@ interface AuthService {
     ): Response<NaagaAuthDto>
 
     @DELETE("/auth/unlink")
-    suspend fun withdrawalMember(): Response<Unit>
+    suspend fun withdrawalMember(
+        @Header("Authorization") accessToken: String,
+    ): Response<Unit>
 
     @DELETE("/auth")
-    suspend fun requestLogout(): Response<Unit>
+    suspend fun requestLogout(
+        @Header("Authorization") accessToken: String,
+    ): Response<Unit>
+
+    @POST("/auth/refresh")
+    suspend fun requestRefresh(
+        @Body refreshToken: RefreshTokenDto,
+    ): Response<NaagaAuthDto>
 }

android/app/src/main/java/com/now/naaga/data/repository/DefaultAuthRepository.kt

@@ -4,42 +4,55 @@ import com.now.domain.model.PlatformAuth
 import com.now.domain.repository.AuthRepository
 import com.now.naaga.data.local.AuthDataSource
 import com.now.naaga.data.mapper.toDto
+import com.now.naaga.data.remote.dto.post.RefreshTokenDto
 import com.now.naaga.data.remote.retrofit.service.AuthService
 import com.now.naaga.util.extension.getValueOrThrow
 import com.now.naaga.util.unlinkWithKakao
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
 
 class DefaultAuthRepository(
     private val authDataSource: AuthDataSource,
     private val authService: AuthService,
-    private val dispatcher: CoroutineDispatcher = Dispatchers.IO,
 ) : AuthRepository {
 
-    override suspend fun getToken(platformAuth: PlatformAuth): Boolean {
-        return withContext(dispatcher) {
-            val response = authService.requestAuth(platformAuth.toDto())
-            runCatching {
-                val naagaAuthDto = response.getValueOrThrow()
-                authDataSource.setAccessToken(naagaAuthDto.accessToken)
-                authDataSource.setRefreshToken(naagaAuthDto.refreshToken)
-                return@withContext true
-            }
-            return@withContext false
-        }
+    override suspend fun logIn(platformAuth: PlatformAuth): Boolean {
+        val response = authService.requestAuth(platformAuth.toDto())
+        val naagaAuthDto = response.getValueOrThrow()
+        storeToken(naagaAuthDto.accessToken, naagaAuthDto.refreshToken)
+        return true
     }
 
     override suspend fun logout() {
-        withContext(dispatcher) {
-            val response = authService.requestLogout()
-            authDataSource.resetToken()
-            response.getValueOrThrow()
-        }
+        val response = authService.requestLogout(getAccessToken()!!)
+        response.getValueOrThrow()
+        authDataSource.resetToken()
     }
 
     override suspend fun withdrawalMember() {
-        authService.withdrawalMember()
+        val response = authService.withdrawalMember(getAccessToken()!!)
+        response.getValueOrThrow()
         unlinkWithKakao()
     }
+
+    override fun getAccessToken(): String? {
+        return authDataSource.getAccessToken()
+    }
+
+    private fun getRefreshToken(): String {
+        return requireNotNull(authDataSource.getRefreshToken()) { NO_REFRESH_TOKEN }
+    }
+
+    private fun storeToken(accessToken: String, refreshToken: String) {
+        authDataSource.setAccessToken(accessToken)
+        authDataSource.setRefreshToken(refreshToken)
+    }
+
+    override suspend fun refreshAccessToken() {
+        val response = authService.requestRefresh(RefreshTokenDto(getRefreshToken()))
+        val naagaAuthDto = response.getValueOrThrow()
+        storeToken(naagaAuthDto.accessToken, naagaAuthDto.refreshToken)
+    }
+
+    companion object {
+        private const val NO_REFRESH_TOKEN = "리프레시 토큰이 없습니다"
+    }
 }

android/app/src/main/java/com/now/naaga/di/ServiceModule.kt

@@ -1,6 +1,7 @@
 package com.now.naaga.di
 
 import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
+import com.now.domain.repository.AuthRepository
 import com.now.naaga.BuildConfig
 import com.now.naaga.data.remote.retrofit.AuthInterceptor
 import com.now.naaga.data.remote.retrofit.service.AdventureService
@@ -17,48 +18,71 @@ import kotlinx.serialization.json.Json
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.OkHttpClient
 import retrofit2.Retrofit
+import javax.inject.Qualifier
 import javax.inject.Singleton
 
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class AuthRetrofit
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class CommonRetrofit
+
 @Module
 @InstallIn(SingletonComponent::class)
 class ServiceModule {
     private val BASE_URL = BuildConfig.BASE_URL
 
     @Singleton
     @Provides
-    fun provideOkHttpClient(): OkHttpClient = OkHttpClient.Builder().apply {
-        addInterceptor(AuthInterceptor())
+    fun provideOkHttpClient(authRepository: AuthRepository): OkHttpClient = OkHttpClient.Builder().apply {
+        addInterceptor(AuthInterceptor(authRepository))
     }.build()
 
+    @AuthRetrofit
     @Singleton
     @Provides
-    fun provideRetrofit(okHttpClient: OkHttpClient): Retrofit = Retrofit.Builder()
+    fun provideAuthRetrofit(okHttpClient: OkHttpClient): Retrofit = Retrofit.Builder()
         .baseUrl(BASE_URL)
         .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
         .client(okHttpClient)
         .build()
 
+    @CommonRetrofit
+    @Singleton
+    @Provides
+    fun provideNormalRetrofit(): Retrofit = Retrofit.Builder()
+        .baseUrl(BASE_URL)
+        .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
+        .build()
+
     @Singleton
     @Provides
-    fun provideRankService(retrofit: Retrofit): RankService = retrofit.create(RankService::class.java)
+    fun provideRankService(@AuthRetrofit retrofit: Retrofit): RankService = retrofit.create(RankService::class.java)
 
     @Singleton
     @Provides
-    fun provideStatisticsService(retrofit: Retrofit): StatisticsService = retrofit.create(StatisticsService::class.java)
+    fun provideStatisticsService(@AuthRetrofit retrofit: Retrofit): StatisticsService = retrofit.create(
+        StatisticsService::class.java,
+    )
 
     @Singleton
     @Provides
-    fun provideAdventureService(retrofit: Retrofit): AdventureService = retrofit.create(AdventureService::class.java)
+    fun provideAdventureService(@AuthRetrofit retrofit: Retrofit): AdventureService = retrofit.create(
+        AdventureService::class.java,
+    )
 
     @Singleton
     @Provides
-    fun providePlaceService(retrofit: Retrofit): PlaceService = retrofit.create(PlaceService::class.java)
+    fun providePlaceService(@AuthRetrofit retrofit: Retrofit): PlaceService = retrofit.create(PlaceService::class.java)
 
     @Singleton
     @Provides
-    fun provideAuthService(retrofit: Retrofit): AuthService = retrofit.create(AuthService::class.java)
+    fun provideAuthService(@CommonRetrofit retrofit: Retrofit): AuthService = retrofit.create(AuthService::class.java)
 
     @Singleton
     @Provides
-    fun provideLetterService(retrofit: Retrofit): LetterService = retrofit.create(LetterService::class.java)
+    fun provideLetterService(@AuthRetrofit retrofit: Retrofit): LetterService =
+        retrofit.create(LetterService::class.java)
 }