[mod/#61] QA 반영

app/src/main/java/com/kiero/KieroApplication.kt

@@ -53,4 +53,4 @@ class KieroApplication : Application(), ImageLoaderFactory {
             .bitmapConfig(Bitmap.Config.HARDWARE)
             .build()
     }
-}
+}

app/src/main/java/com/kiero/core/designsystem/component/button/KieroButtonMedium.kt

@@ -39,8 +39,8 @@ fun KieroButtonMedium(
         enabled = isEnabled,
         modifier = modifier.fillMaxWidth(),
         shape = RoundedCornerShape(8.dp),
-        color = if (isEnabled) containerColor else KieroTheme.colors.gray300,
-        contentColor = if (isEnabled) contentColor else KieroTheme.colors.gray600
+        color = if (isEnabled) containerColor else KieroTheme.colors.gray900,
+        contentColor = if (isEnabled) contentColor else KieroTheme.colors.white
     ) {
         Row(
             modifier = Modifier.padding(vertical = 13.dp, horizontal = 16.dp),
@@ -76,7 +76,7 @@ private fun KieroButtonMediumPreview() {
             horizontalAlignment = Alignment.CenterHorizontally
         ) {
             KieroButtonMedium(
-                text = "시작하기", onClick = { })
+                text = "시작하기", onClick = { }, isEnabled = false)
             KieroButtonMedium(
                 text = "일정 추가하기",
                 leadingIcon = ImageVector.vectorResource(id = com.kiero.R.drawable.ic_kid_camera),

app/src/main/java/com/kiero/data/auth/remote/datasourceimpl/AuthDataSourceImpl.kt

@@ -32,8 +32,13 @@ class AuthDataSourceImpl @Inject constructor(
             val accountCallback: (OAuthToken?, Throwable?) -> Unit = { token, error ->
                 when {
                     error != null -> {
-                        Timber.e(error, "❌ 카카오 계정 로그인 실패")
-                        continuation.resume(Result.failure(error))
+                        if (error is ClientError && error.reason == ClientErrorCause.Cancelled) {
+                            Timber.d("⚠️ 사용자 웹 로그인 취소")
+                            continuation.resume(Result.failure(error))
+                        } else {
+                            Timber.e(error, "❌ 카카오 계정 로그인 실패")
+                            continuation.resume(Result.failure(error))
+                        }
                     }
                     token != null -> {
                         Timber.i("✅ 카카오 계정 로그인 성공")
@@ -89,4 +94,4 @@ class AuthDataSourceImpl @Inject constructor(
     override suspend fun postAuthKidLogin(authKidRequestDto: AuthKidRequestDto): BaseResponse<AuthKidResponseDto> =
         authService.postAuthKidLogin(body = authKidRequestDto)
 
-}
+}

app/src/main/java/com/kiero/data/sse/manager/SseManager.kt

@@ -5,17 +5,21 @@ import com.kiero.data.sse.repository.SseRepository
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import timber.log.Timber
 import javax.inject.Inject
 import javax.inject.Singleton
+import kotlin.coroutines.cancellation.CancellationException
 
 @Singleton
 class SseManager @Inject constructor(
@@ -25,7 +29,7 @@ class SseManager @Inject constructor(
 
     private var sseJob: Job? = null
     private var tokenRefreshJob: Job? = null
-
+    private var cachedAccessToken: String? = null
     private val mutex = Mutex()
 
     // 부모 이벤트
@@ -50,148 +54,141 @@ class SseManager @Inject constructor(
     private var isParentMode = true
 
     fun startParentSubscription() {
+        initSubscription(isParent = true)
+    }
+
+    fun startChildSubscription() {
+        initSubscription(isParent = false)
+    }
+
+    private fun initSubscription(isParent: Boolean) {
         scope.launch {
             mutex.withLock {
-                if (isSubscribed) {
-                    Timber.d("SSE 이미 구독 중 - 중복 시작 방지")
-                    return@launch
-                }
+                if (isSubscribed && isParentMode == isParent) return@launch
+
+                stopSubscriptionInternal()
 
                 isSubscribed = true
-                isParentMode = true
-                stopSubscription()
+                isParentMode = isParent
+                cachedAccessToken = null
 
                 sseJob = launch {
-                    sseRepository.issueSubscribeToken()
-                        .onSuccess { accessToken ->
-                            _connectionState.emit(true)
-                            startTokenRefreshTimer()
-
-                            sseRepository.subscribeEvents(accessToken)
-                                .collect { event ->
-                                    handleParentEvent(event)
-                                }
-                        }
-                        .onFailure { e ->
-                            Timber.e(e, "SSE 구독 실패")
-                            isSubscribed = false
-                            _connectionState.emit(false)
-                        }
+                    subscriptionLoop(isParent)
                 }
+
+                startTokenRefreshTimer()
             }
         }
     }
+    private suspend fun subscriptionLoop(isParent: Boolean) {
+        while (currentCoroutineContext().isActive && isSubscribed) {
+            try {
+                // 실패 시 재발급으로 continue
+                val token = getValidToken() ?: continue
 
-    fun startChildSubscription() {
-        scope.launch {
-            mutex.withLock {
-                if (isSubscribed) {
-                    Timber.d("SSE 이미 구독 중 - 중복 시작 방지")
-                    return@launch
-                }
+                Timber.d("🔄 SSE 연결 시도 (Token: ${token.take(10)}...)")
 
-                isSubscribed = true
-                isParentMode = false
-                stopSubscription()
+                sseRepository.subscribeEvents(token)
+                    .collect { event ->
+                        _connectionState.emit(true)
+                        if (isParent) handleParentEvent(event)
+                        else handleChildEvent(event)
+                    }
 
-                sseJob = launch {
-                    sseRepository.issueSubscribeToken()
-                        .onSuccess { accessToken ->
-                            _connectionState.emit(true)
-                            startTokenRefreshTimer()
-
-                            sseRepository.subscribeEvents(accessToken)
-                                .collect { event ->
-                                    handleChildEvent(event)
-                                }
-                        }
-                        .onFailure { e ->
-                            Timber.e(e, "SSE 구독 실패")
-                            isSubscribed = false
-                            _connectionState.emit(false)
-                        }
+                Timber.w("SSE 스트림 종료됨. 즉시 재연결 시도.")
+
+            } catch (e: Exception) {
+                // 상위에 에러 던지기
+                if (e is CancellationException) throw e
+
+                Timber.e(e, "SSE 연결 중 에러 발생")
+                _connectionState.emit(false)
+
+                if (isTokenExpiredError(e)) {
+                    Timber.w("토큰 만료 감지 -> 캐시 삭제 후 재발급 예정")
+                    cachedAccessToken = null
                 }
+
+                delay(3000L)
             }
         }
     }
+
     private fun startTokenRefreshTimer() {
         tokenRefreshJob?.cancel()
-
         tokenRefreshJob = scope.launch {
             while (isActive) {
                 delay(180_000L)
-                Timber.d("🔄 SSE 토큰 자동 갱신 (3분 주기)")
-                restartSubscription()
-            }
-        }
-    }
+                Timber.d("⏰ SSE 토큰 갱신 주기 도래 (3분)")
 
-    private fun restartSubscription() {
-        Timber.d("🔄 SSE 재연결 시작")
-        sseJob?.cancel()
+                mutex.withLock {
+                    if (isSubscribed) {
+                        cachedAccessToken = null
 
-        isSubscribed = false
+                        // 현재 job 취소
+                        sseJob?.cancel()
 
-        if (isParentMode) {
-            startParentSubscription()
-        } else {
-            startChildSubscription()
+                        sseJob = launch {
+                            subscriptionLoop(isParentMode)
+                        }
+                    }
+                }
+            }
         }
     }
 
-    private suspend fun handleParentEvent(event: SseEvent) {
-        when (event) {
-            is SseEvent.Connected -> {
-                Timber.d("SSE 연결 완료")
-            }
-
-            is SseEvent.Invite -> {
-                Timber.d("📨 초대 이벤트: childId=${event.data.childId}")
-                _parentInviteEvents.emit(event)
-            }
-
-            is SseEvent.Feed -> {
-                Timber.d("📢 피드 이벤트: ${event.data.eventType}")
-                _parentFeedEvents.emit(event)
-            }
+    private suspend fun getValidToken(): String? {
+        cachedAccessToken?.let { return it }
 
-            is SseEvent.Mission,
-            is SseEvent.Schedule -> {
-                Timber.w("부모 SSE에서 자녀 이벤트 수신: $event")
+        return try {
+            val result = sseRepository.issueSubscribeToken()
+            result.getOrNull()?.also { newToken ->
+                cachedAccessToken = newToken
+                Timber.d("새 SSE 토큰 발급 완료")
             }
+        } catch (e: Exception) {
+            Timber.e(e, "토큰 발급 실패")
+            delay(5000L)
+            null
         }
     }
 
-    private suspend fun handleChildEvent(event: SseEvent) {
-        when (event) {
-            is SseEvent.Connected -> {
-                Timber.d("SSE 연결 완료")
-            }
-
-            is SseEvent.Mission -> {
-                Timber.d("📋 미션 이벤트: ${event.data.missionName}, 보상: ${event.data.reward}금화")
-                _childMissionEvents.emit(event)
-            }
-
-            is SseEvent.Schedule -> {
-                Timber.d("📅 일정 이벤트: ${event.data.scheduleName}")
-                _childScheduleEvents.emit(event)
-            }
+    private fun isTokenExpiredError(t: Throwable): Boolean {
+        return t.message?.contains("403") == true || t.message?.contains("Unauthorized") == true
+    }
 
-            is SseEvent.Invite,
-            is SseEvent.Feed -> {
-                Timber.w("자녀 SSE에서 부모 이벤트 수신: $event")
+    fun stopSubscription() {
+        scope.launch {
+            mutex.withLock {
+                stopSubscriptionInternal()
             }
         }
     }
 
-    fun stopSubscription() {
+    private suspend fun stopSubscriptionInternal() {
         isSubscribed = false
-        sseJob?.cancel()
+        cachedAccessToken = null
+        sseJob?.cancelAndJoin()
         tokenRefreshJob?.cancel()
-        scope.launch {
-            _connectionState.emit(false)
+        _connectionState.emit(false)
+        Timber.d("⛔ SSE 구독 완전 중지")
+    }
+
+    private suspend fun handleParentEvent(event: SseEvent) {
+        when (event) {
+            is SseEvent.Connected -> Timber.d("부모 SSE Connected")
+            is SseEvent.Invite -> _parentInviteEvents.emit(event)
+            is SseEvent.Feed -> _parentFeedEvents.emit(event)
+            else -> Timber.w("부모 모드에서 알 수 없는 이벤트: $event")
+        }
+    }
+
+    private suspend fun handleChildEvent(event: SseEvent) {
+        when (event) {
+            is SseEvent.Connected -> Timber.d("아이 SSE Connected")
+            is SseEvent.Mission -> _childMissionEvents.emit(event)
+            is SseEvent.Schedule -> _childScheduleEvents.emit(event)
+            else -> Timber.w("자녀 모드에서 알 수 없는 이벤트: $event")
         }
-        Timber.d("SSE 구독 중지")
     }
-}
+}

app/src/main/java/com/kiero/data/sse/model/SseEvent.kt

@@ -1,9 +1,9 @@
 package com.kiero.data.sse.model
 
-import com.kiero.data.sse.remote.dto.event.FeedDataDto
-import com.kiero.data.sse.remote.dto.event.InviteDataDto
-import com.kiero.data.sse.remote.dto.event.MissionDataDto
-import com.kiero.data.sse.remote.dto.event.ScheduleDataDto
+import com.kiero.data.sse.remote.dto.response.FeedDataDto
+import com.kiero.data.sse.remote.dto.response.InviteDataDto
+import com.kiero.data.sse.remote.dto.response.MissionDataDto
+import com.kiero.data.sse.remote.dto.response.ScheduleDataDto
 
 sealed interface SseEvent {
     // 공통

app/src/main/java/com/kiero/data/sse/remote/datasourceimpl/SseDataSourceImpl.kt

@@ -31,12 +31,16 @@ class SseDataSourceImpl @Inject constructor(
         accessToken: String
     ): Flow<RawSseEvent> = callbackFlow {
         val request = Request.Builder()
-            .url("${BuildConfig.BASE_URL}/api/v1/subscribe")
+            .url("${BuildConfig.BASE_URL}api/v1/subscribe")
             .header("Accept", "text/event-stream")
             .header("Authorization", "Bearer $accessToken")
             .build()
 
-        val eventSource = EventSources.createFactory(okHttpClient)
+        val sseClient = okHttpClient.newBuilder()
+            .readTimeout(0, java.util.concurrent.TimeUnit.MILLISECONDS)
+            .build()
+
+        val eventSource = EventSources.createFactory(sseClient)
             .newEventSource(request, object : EventSourceListener() {
 
                 override fun onOpen(eventSource: EventSource, response: Response) {
@@ -74,4 +78,4 @@ class SseDataSourceImpl @Inject constructor(
             eventSource.cancel()
         }
     }
-}
+}

app/src/main/java/com/kiero/data/sse/remote/dto/response/ChildEventDto.kt

@@ -1,4 +1,4 @@
-package com.kiero.data.sse.remote.dto.event
+package com.kiero.data.sse.remote.dto.response
 
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable

app/src/main/java/com/kiero/data/sse/remote/dto/response/ParentEventDto.kt

@@ -1,4 +1,4 @@
-package com.kiero.data.sse.remote.dto.event
+package com.kiero.data.sse.remote.dto.response
 
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable

app/src/main/java/com/kiero/data/sse/repositoryimpl/SseRepositoryImpl.kt

@@ -1,14 +1,13 @@
 package com.kiero.data.sse.repositoryimpl
 
-import com.kiero.core.common.util.suspendRunCatching
 import com.kiero.data.sse.remote.datasource.SseDataSource
 import com.kiero.data.sse.model.RawSseEvent
 import com.kiero.data.sse.model.SseEvent
 import com.kiero.data.sse.model.SseEventType
-import com.kiero.data.sse.remote.dto.event.FeedDataDto
-import com.kiero.data.sse.remote.dto.event.InviteDataDto
-import com.kiero.data.sse.remote.dto.event.MissionDataDto
-import com.kiero.data.sse.remote.dto.event.ScheduleDataDto
+import com.kiero.data.sse.remote.dto.response.FeedDataDto
+import com.kiero.data.sse.remote.dto.response.InviteDataDto
+import com.kiero.data.sse.remote.dto.response.MissionDataDto
+import com.kiero.data.sse.remote.dto.response.ScheduleDataDto
 import com.kiero.data.sse.repository.SseRepository
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.mapNotNull