[Feature] 마이페이지 api 연결

app/src/main/java/com/flint/core/navigation/Route.kt

@@ -57,7 +57,9 @@ interface Route {
     ) : Route
 
     @Serializable
-    data object SavedContentList : Route
+    data class SavedContentList(
+        val userId: String? = null,
+    ) : Route
 
     @Serializable
     data object AddContent : Route

app/src/main/java/com/flint/data/api/ContentApi.kt

@@ -1,15 +1,24 @@
 package com.flint.data.api
 
 import com.flint.data.dto.base.BaseResponse
-import com.flint.data.dto.content.response.BookmarkedContentListResponseDto
+import com.flint.data.dto.content.response.BookmarkCountResponseDto
+import com.flint.data.dto.content.response.MyBookmarkedContentListResponseDto
 import com.flint.data.dto.ott.response.OttListResponseDto
 import retrofit2.http.GET
 import retrofit2.http.Path
+import retrofit2.http.Query
 
 interface ContentApi {
-    // 북마크한 콘텐츠 목록 조회
+    // 내 북마크한 콘텐츠 목록 조회 (커서 페이지네이션)
     @GET("/api/v1/contents/bookmarks")
-    suspend fun getBookmarkedContentList(): BaseResponse<BookmarkedContentListResponseDto>
+    suspend fun getBookmarkedContentList(
+        @Query("cursor") cursor: String? = null,
+        @Query("size") size: Int = 10,
+    ): BaseResponse<MyBookmarkedContentListResponseDto>
+
+    // 내 북마크한 콘텐츠 전체 개수 조회
+    @GET("/api/v1/contents/bookmarks/count")
+    suspend fun getBookmarkedContentCount(): BaseResponse<BookmarkCountResponseDto>
 
     // 콘텐츠별 OTT 목록 조회
     @GET("/api/v1/contents/ott/{contentId}")

app/src/main/java/com/flint/data/api/UserApi.kt

@@ -10,13 +10,19 @@ import com.flint.data.dto.user.response.BookmarkedCollectionListResponseDto
 import com.flint.data.dto.user.response.CreatedCollectionListResponseDto
 import com.flint.data.dto.user.response.UserKeywordsResponseDto
 import com.flint.data.dto.user.response.UserProfileResponseDto
+import retrofit2.Response
+import retrofit2.http.PATCH
 import retrofit2.http.Body
 import retrofit2.http.GET
 import retrofit2.http.PUT
 import retrofit2.http.Path
 import retrofit2.http.Query
 
 interface UserApi {
+    // 내 프로필 조회 (keywordRecalculatable 포함)
+    @GET("/api/v1/users/me")
+    suspend fun getMyProfile(): BaseResponse<UserProfileResponseDto>
+
     // 사용자 프로필 조회
     @GET("/api/v1/users/{userId}")
     suspend fun getUserProfile(
@@ -61,7 +67,9 @@ interface UserApi {
         @Path("userId") userId: String,
     ): BaseResponse<UserKeywordsResponseDto>
 
-    // 취향 키워드 재계산
+    // 취향 키워드 재계산 (응답 body에 data 필드xx)
+    @PATCH("/api/v1/users/me/keywords/recalculate")
+    suspend fun recalculateKeywords(): Response<Unit>
 
     // 닉네임 수정
     @PUT("/api/v1/users/me/nickname")

app/src/main/java/com/flint/data/di/interceptor/NetworkErrorInterceptor.kt

@@ -1,9 +1,12 @@
 package com.flint.data.di.interceptor
 
+import com.flint.data.dto.base.ErrorResponseDto
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
 import okhttp3.Interceptor
 import okhttp3.Response
 import java.io.IOException
@@ -13,6 +16,7 @@ import javax.inject.Inject
 
 class NetworkErrorInterceptor @Inject constructor(
     private val networkErrorManager: NetworkErrorManager,
+    private val json: Json,
 ) : Interceptor {
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
@@ -25,13 +29,17 @@ class NetworkErrorInterceptor @Inject constructor(
             if (!response.isSuccessful) {
                 when (response.code) {
                     in 300..599 -> {
-                        scope.launch {
-                            networkErrorManager.emitError(
-                                NetworkError.ConnectionError(
-                                    code = response.code,
-                                    message = response.message
+                        // errorCode 필드가 있으면 앱 레이어에서 직접 처리하는 비즈니스 에러 — 글로벌 에러 emit 생략
+                        val isBusinessError = response.isBusinessError()
+                        if (!isBusinessError) {
+                            scope.launch {
+                                networkErrorManager.emitError(
+                                    NetworkError.ConnectionError(
+                                        code = response.code,
+                                        message = response.message
+                                    )
                                 )
-                            )
+                            }
                         }
                     }
                 }
@@ -61,4 +69,17 @@ class NetworkErrorInterceptor @Inject constructor(
             throw e
         }
     }
+
+    private fun Response.isBusinessError(): Boolean {
+        val body = runCatching { peekBody(ERROR_BODY_PEEK_BYTES).string() }.getOrNull()
+            ?: return false
+
+        return runCatching {
+            json.decodeFromString<ErrorResponseDto>(body).errorCode != null
+        }.getOrDefault(false)
+    }
+
+    private companion object {
+        const val ERROR_BODY_PEEK_BYTES = 64 * 1024L
+    }
 }

app/src/main/java/com/flint/data/dto/base/ErrorResponseDto.kt

@@ -0,0 +1,12 @@
+package com.flint.data.dto.base
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ErrorResponseDto(
+    @SerialName("errorCode")
+    val errorCode: String? = null,
+    @SerialName("message")
+    val message: String? = null,
+)

app/src/main/java/com/flint/data/dto/content/response/BookmarkedContentListResponseDto.kt

@@ -3,14 +3,41 @@ package com.flint.data.dto.content.response
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
+// /api/v1/users/{userId}/bookmarked-contents 응답 (타 유저)
 @Serializable
 data class BookmarkedContentListResponseDto(
     @SerialName("totalCount")
-    val totalCount: Int = 0,
+    val totalCount: Int,
     @SerialName("contents")
     val contents: List<BookmarkedContentResponseDto>
 )
 
+// /api/v1/contents/bookmarks 응답 (내 프로필, 커서 페이지네이션)
+@Serializable
+data class MyBookmarkedContentListResponseDto(
+    @SerialName("data")
+    val data: List<BookmarkedContentResponseDto>,
+    @SerialName("meta")
+    val meta: BookmarkCursorMetaDto
+)
+
+@Serializable
+data class BookmarkCursorMetaDto(
+    @SerialName("type")
+    val type: String,
+    @SerialName("returned")
+    val returned: Int,
+    @SerialName("nextCursor")
+    val nextCursor: String? = null,
+)
+
+// /api/v1/contents/bookmarks/count 응답
+@Serializable
+data class BookmarkCountResponseDto(
+    @SerialName("totalCount")
+    val totalCount: Int
+)
+
 @Serializable
 data class BookmarkedContentResponseDto(
     @SerialName("id")
@@ -22,9 +49,10 @@ data class BookmarkedContentResponseDto(
     @SerialName("imageUrl")
     val imageUrl: String,
     @SerialName("bookmarkCount")
-    val bookmarkCount: Int = 0,
+    val bookmarkCount: Int,
+    // 내 북마크 목록 응답에는 isBookmarked 없음 → 기본값 true
     @SerialName("isBookmarked")
-    val isBookmarked: Boolean = false,
+    val isBookmarked: Boolean = true,
     @SerialName("getOttSimpleList")
     val getOttSimpleList: List<OttSimpleResponseDto>
 )
@@ -35,4 +63,4 @@ data class OttSimpleResponseDto(
     val ottName: String,
     @SerialName("logoUrl")
     val logoUrl: String
-)
+)

app/src/main/java/com/flint/data/dto/user/response/UserProfileResponseDto.kt

@@ -1,16 +1,18 @@
 package com.flint.data.dto.user.response
 
-import com.google.gson.annotations.SerializedName
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
 @Serializable
 data class UserProfileResponseDto(
-    @SerializedName("id")
+    @SerialName("id")
     val id: String,
-    @SerializedName("profileImageUrl")
+    @SerialName("profileImageUrl")
     val profileImageUrl: String?,
-    @SerializedName("isFliner")
+    @SerialName("isFliner")
     val isFliner: Boolean,
-    @SerializedName("nickname")
-    val nickname: String
-)
+    @SerialName("nickname")
+    val nickname: String,
+    @SerialName("keywordRecalculatable")
+    val keywordRecalculatable: Boolean = false,
+)

app/src/main/java/com/flint/domain/mapper/content/ContentMapper.kt

@@ -10,8 +10,10 @@ import com.flint.domain.model.content.ContentModel
 import com.flint.domain.type.OttType
 import kotlinx.collections.immutable.toImmutableList
 
+// /api/v1/users/{userId}/bookmarked-contents (타 유저)
 fun BookmarkedContentListResponseDto.toModel() : BookmarkedContentListModel {
     return BookmarkedContentListModel(
+        totalCount = totalCount,
         contents = contents.map { it.toModel() }.toImmutableList()
     )
 }
@@ -22,6 +24,8 @@ fun BookmarkedContentResponseDto.toModel() : BookmarkedContentItemModel {
         title = title,
         year = year,
         imageUrl = imageUrl,
+        bookmarkCount = bookmarkCount,
+        isBookmarked = isBookmarked,
         getOttSimpleList = getOttSimpleList.mapNotNull { ottSimple ->
             runCatching { OttType.valueOf(ottSimple.ottName) }.getOrNull()
         }
@@ -39,4 +43,4 @@ fun SearchBookmarkedContentsResponseDto.toModel() : List<ContentModel> {
             year = it.year
         )
     }
-}
+}

app/src/main/java/com/flint/domain/mapper/user/ProfileMapper.kt

@@ -8,5 +8,6 @@ fun UserProfileResponseDto.toModel(): UserProfileResponseModel =
         id = id,
         isFliner = isFliner,
         nickname = nickname,
-        profileImageUrl = profileImageUrl
+        profileImageUrl = profileImageUrl,
+        keywordRecalculatable = keywordRecalculatable,
     )

app/src/main/java/com/flint/domain/model/bookmark/BookmarkChange.kt

@@ -0,0 +1,16 @@
+package com.flint.domain.model.bookmark
+
+sealed class BookmarkChange {
+    abstract val id: String
+    abstract val isBookmarked: Boolean
+
+    data class Content(
+        override val id: String,
+        override val isBookmarked: Boolean,
+    ) : BookmarkChange()
+
+    data class Collection(
+        override val id: String,
+        override val isBookmarked: Boolean,
+    ) : BookmarkChange()
+}

app/src/main/java/com/flint/domain/model/bookmark/BookmarkException.kt

@@ -0,0 +1,6 @@
+package com.flint.domain.model.bookmark
+
+sealed class BookmarkException : Exception() {
+    /** 최소 저장 작품 수 제한으로 콘텐츠 북마크 해제 불가 */
+    object ContentMinLimitExceeded : BookmarkException()
+}

app/src/main/java/com/flint/domain/model/content/BookmarkedContentListModel.kt

@@ -5,16 +5,19 @@ import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
 
 data class BookmarkedContentListModel(
+    val totalCount: Int = 0,
     val contents: ImmutableList<BookmarkedContentItemModel> = persistentListOf()
 ) {
     companion object {
         val FakeList = BookmarkedContentListModel(
+            totalCount = 1,
             contents = persistentListOf(
                 BookmarkedContentItemModel(
                     id = "0",
                     title = "드라마 제목",
                     year = 2000,
                     imageUrl = "",
+                    bookmarkCount = 0,
                     getOttSimpleList = listOf(
                         OttType.Netflix,
                         OttType.Disney,
@@ -32,5 +35,7 @@ data class BookmarkedContentItemModel(
     val title: String = "",
     val year: Int = 0,
     val imageUrl: String = "",
+    val bookmarkCount: Int = 0,
+    val isBookmarked: Boolean = false,
     val getOttSimpleList: List<OttType> = emptyList()
 )

app/src/main/java/com/flint/domain/model/user/UserProfileResponseModel.kt

@@ -4,7 +4,8 @@ data class UserProfileResponseModel(
     val id: String,
     val isFliner: Boolean,
     val nickname: String,
-    val profileImageUrl: String?
+    val profileImageUrl: String?,
+    val keywordRecalculatable: Boolean = false,
 ) {
     companion object {
         val Empty = UserProfileResponseModel(

app/src/main/java/com/flint/domain/repository/BookmarkRepository.kt

@@ -2,23 +2,60 @@ package com.flint.domain.repository
 
 import com.flint.core.common.util.suspendRunCatching
 import com.flint.data.api.BookmarkApi
+import com.flint.data.dto.base.ErrorResponseDto
 import com.flint.domain.mapper.bookmark.toModel
+import com.flint.domain.model.bookmark.BookmarkChange
+import com.flint.domain.model.bookmark.BookmarkException
 import com.flint.domain.model.bookmark.CollectionBookmarkUsersModel
 import javax.inject.Inject
+import javax.inject.Singleton
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.serialization.json.Json
+import retrofit2.HttpException
 
+@Singleton
 class BookmarkRepository @Inject constructor(
     private val api: BookmarkApi,
+    private val json: Json,
 ) {
+    private val _bookmarkChanges = MutableSharedFlow<BookmarkChange>()
+    val bookmarkChanges = _bookmarkChanges.asSharedFlow()
+
     // 컬렉션 북마크 유저 조회
     suspend fun getCollectionBookmarkUsers(collectionId: String): Result<CollectionBookmarkUsersModel> {
         return suspendRunCatching { api.getCollectionBookmarkUsers(collectionId).data.toModel() }
     }
 
     // 컬렉션 북마크 토글
-    suspend fun toggleCollectionBookmark(collectionId: String): Result<Boolean> =
-        suspendRunCatching { api.toggleCollectionBookmark(collectionId).data }
+    suspend fun toggleCollectionBookmark(collectionId: String): Result<Boolean> {
+        val result = suspendRunCatching { api.toggleCollectionBookmark(collectionId).data }
+        result.getOrNull()?.let { isBookmarked ->
+            _bookmarkChanges.emit(BookmarkChange.Collection(collectionId, isBookmarked))
+        }
+        return result
+    }
 
     // 콘텐츠 북마크 토글
-    suspend fun toggleContentBookmark(contentId: String): Result<Boolean> =
-        suspendRunCatching { api.toggleContentBookmark(contentId).data }
+    // 최소 저장 수 제한 초과 시 BookmarkException.ContentMinLimitExceeded 반환
+    suspend fun toggleContentBookmark(contentId: String): Result<Boolean> {
+        val result = suspendRunCatching {
+            try {
+                api.toggleContentBookmark(contentId).data
+            } catch (e: HttpException) {
+                val errorCode = e.response()?.errorBody()?.string()
+                    ?.let { runCatching { json.decodeFromString(ErrorResponseDto.serializer(), it).errorCode }.getOrNull() }
+                if (errorCode == CONTENT_MIN_LIMIT_ERROR_CODE) throw BookmarkException.ContentMinLimitExceeded
+                throw e
+            }
+        }
+        result.getOrNull()?.let { isBookmarked ->
+            _bookmarkChanges.emit(BookmarkChange.Content(contentId, isBookmarked))
+        }
+        return result
+    }
+
+    private companion object {
+        const val CONTENT_MIN_LIMIT_ERROR_CODE = "BOOKMARK.CONTENT_MIN_LIMIT"
+    }
 }