[REFACTOR] QA 4차 수정

app/src/main/java/com/texthip/thip/MainScreen.kt

@@ -5,13 +5,17 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import com.texthip.thip.ui.navigator.BottomNavigationBar
 import com.texthip.thip.ui.navigator.MainNavHost
 import com.texthip.thip.ui.navigator.extensions.isMainTabRoute
+import com.texthip.thip.ui.navigator.routes.MainTabRoutes
 
 @Composable
 fun MainScreen(
@@ -20,19 +24,35 @@ fun MainScreen(
     val navController = rememberNavController()
     val navBackStackEntry by navController.currentBackStackEntryAsState()
     val currentDestination = navBackStackEntry?.destination
+    var feedReselectionTrigger by remember { mutableStateOf(0) }
 
     val showBottomBar = currentDestination?.isMainTabRoute() ?: true
 
     Scaffold(
         bottomBar = {
-            if (showBottomBar) BottomNavigationBar(navController)
+            if (showBottomBar) {
+                BottomNavigationBar(
+                    navController = navController,
+                    onTabReselected = { route ->
+                        when (route) {
+                            MainTabRoutes.Feed -> {
+                                feedReselectionTrigger += 1
+                            }
+                            else -> {
+                                // 다른 탭들은 향후 확장 가능
+                            }
+                        }
+                    }
+                )
+            }
         },
         containerColor = Color.Transparent
     ) { innerPadding ->
         Box(modifier = Modifier.padding(innerPadding)) {
             MainNavHost(
                 navController = navController,
-                onNavigateToLogin = onNavigateToLogin
+                onNavigateToLogin = onNavigateToLogin,
+                onFeedTabReselected = feedReselectionTrigger
             )
         }
     }

app/src/main/java/com/texthip/thip/data/di/NetworkModule.kt

@@ -1,12 +1,14 @@
 package com.texthip.thip.data.di
 
+import android.content.Context
 import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
 import com.texthip.thip.BuildConfig
-import com.texthip.thip.data.service.AuthService
 import com.texthip.thip.utils.auth.AuthInterceptor
+import com.texthip.thip.utils.image.ImageUploadHelper
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.json.Json
@@ -68,4 +70,10 @@ object NetworkModule {
             )
             .client(okHttpClient)
             .build()
+
+    @Provides
+    @Singleton
+    fun provideImageUploadHelper(
+        @ApplicationContext context: Context
+    ): ImageUploadHelper = ImageUploadHelper(context)
 }

app/src/main/java/com/texthip/thip/data/model/book/response/BookListResponse.kt

@@ -6,7 +6,9 @@ import kotlinx.serialization.Serializable
 
 @Serializable
 data class BookListResponse(
-    @SerialName("bookList") val bookList: List<BookSavedResponse> = emptyList()
+    @SerialName("bookList") val bookList: List<BookSavedResponse> = emptyList(),
+    @SerialName("nextCursor") val nextCursor: String? = null,
+    @SerialName("isLast") val isLast: Boolean = false
 )
 
 @Serializable

app/src/main/java/com/texthip/thip/data/model/book/response/BookUserSaveResponse.kt

@@ -1,10 +1,13 @@
 package com.texthip.thip.data.model.book.response
 
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
 @Serializable
 data class BookUserSaveResponse(
-    val bookList: List<BookUserSaveList>
+    val bookList: List<BookUserSaveList>,
+    @SerialName("nextCursor") val nextCursor: String? = null,
+    @SerialName("isLast") val isLast: Boolean = false
 )
 
 @Serializable

app/src/main/java/com/texthip/thip/data/model/feed/request/CreateFeedRequest.kt

@@ -12,5 +12,7 @@ data class CreateFeedRequest(
     @SerialName("isPublic")
     val isPublic: Boolean,
     @SerialName("tagList")
-    val tagList: List<String> = emptyList()
+    val tagList: List<String> = emptyList(),
+    @SerialName("imageUrls")
+    val imageUrls: List<String> = emptyList()
 )

app/src/main/java/com/texthip/thip/data/model/feed/request/PresignedUrlRequest.kt

@@ -0,0 +1,14 @@
+package com.texthip.thip.data.model.feed.request
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ImageMetadata(
+    @SerialName("extension")
+    val extension: String,
+    @SerialName("size")
+    val size: Long
+)
+
+typealias PresignedUrlRequest = List<ImageMetadata>

app/src/main/java/com/texthip/thip/data/model/feed/response/PresignedUrlResponse.kt

@@ -0,0 +1,18 @@
+package com.texthip.thip.data.model.feed.response
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class PresignedUrlInfo(
+    @SerialName("presignedUrl")
+    val presignedUrl: String,
+    @SerialName("fileUrl")
+    val fileUrl: String
+)
+
+@Serializable
+data class PresignedUrlResponse(
+    @SerialName("presignedUrls")
+    val presignedUrls: List<PresignedUrlInfo>
+)

app/src/main/java/com/texthip/thip/data/model/rooms/response/JoinedRoomListResponse.kt

@@ -8,10 +8,8 @@ import kotlinx.serialization.Serializable
 data class JoinedRoomListResponse(
     @SerialName("roomList") val roomList: List<JoinedRoomResponse>,
     @SerialName("nickname") val nickname: String,
-    @SerialName("page") val page: Int,
-    @SerialName("size") val size: Int,
-    @SerialName("last") val last: Boolean,
-    @SerialName("first") val first: Boolean
+    @SerialName("nextCursor") val nextCursor: String? = null,
+    @SerialName("isLast") val isLast: Boolean
 )
 
 @Serializable

app/src/main/java/com/texthip/thip/data/repository/BookRepository.kt

@@ -19,8 +19,8 @@ class BookRepository @Inject constructor(
 ) {
 
     /** 저장된 책 또는 모임 책 목록 조회 */
-    suspend fun getBooks(type: String): Result<BookListResponse?> = runCatching {
-        bookService.getBooks(type)
+    suspend fun getBooks(type: String, cursor: String? = null): Result<BookListResponse?> = runCatching {
+        bookService.getBooks(type, cursor)
             .handleBaseResponse()
             .getOrThrow()
     }
@@ -67,8 +67,8 @@ class BookRepository @Inject constructor(
             .getOrThrow()
     }
 
-    suspend fun getSavedBooks(): Result<BookUserSaveResponse?> = runCatching {
-        bookService.getSavedBooks()
+    suspend fun getSavedBooks(cursor: String? = null): Result<BookUserSaveResponse?> = runCatching {
+        bookService.getSavedBooks(cursor)
             .handleBaseResponse()
             .getOrThrow()
     }

app/src/main/java/com/texthip/thip/data/repository/FeedRepository.kt

@@ -1,12 +1,15 @@
 package com.texthip.thip.data.repository
 
-import android.content.Context
 import android.net.Uri
 import com.texthip.thip.data.model.base.handleBaseResponse
 import com.texthip.thip.data.model.feed.request.CreateFeedRequest
 import com.texthip.thip.data.model.feed.request.FeedLikeRequest
 import com.texthip.thip.data.model.feed.request.FeedSaveRequest
 import com.texthip.thip.data.model.feed.request.UpdateFeedRequest
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.withContext
 import com.texthip.thip.data.model.feed.response.AllFeedResponse
 import com.texthip.thip.data.model.feed.response.CreateFeedResponse
 import com.texthip.thip.data.model.feed.response.FeedDetailResponse
@@ -18,27 +21,17 @@ import com.texthip.thip.data.model.feed.response.MyFeedResponse
 import com.texthip.thip.data.model.feed.response.RelatedBooksResponse
 import com.texthip.thip.data.service.FeedService
 import com.texthip.thip.ui.feed.mock.FeedStateUpdateResult
-import dagger.hilt.android.qualifiers.ApplicationContext
-import kotlinx.coroutines.Dispatchers
+import com.texthip.thip.utils.image.ImageUploadHelper
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.withContext
-import kotlinx.serialization.json.Json
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.MultipartBody
-import okhttp3.RequestBody.Companion.asRequestBody
-import okhttp3.RequestBody.Companion.toRequestBody
-import java.io.File
-import java.io.FileOutputStream
 import javax.inject.Inject
 import javax.inject.Singleton
 
 @Singleton
 class FeedRepository @Inject constructor(
     private val feedService: FeedService,
-    @param:ApplicationContext private val context: Context,
-    private val json: Json
+    private val imageUploadHelper: ImageUploadHelper
 ) {
     private val _feedStateUpdateResult = MutableSharedFlow<FeedStateUpdateResult>()
     val feedStateUpdateResult: Flow<FeedStateUpdateResult> = _feedStateUpdateResult.asSharedFlow()
@@ -72,80 +65,67 @@ class FeedRepository @Inject constructor(
         tagList: List<String>,
         imageUris: List<Uri>
     ): Result<CreateFeedResponse?> = runCatching {
+        val imageUrls = if (imageUris.isNotEmpty()) {
+            uploadImagesToS3(imageUris)
+        } else {
+            emptyList()
+        }
+
         val request = CreateFeedRequest(
             isbn = isbn,
             contentBody = contentBody,
             isPublic = isPublic,
-            tagList = tagList
+            tagList = tagList,
+            imageUrls = imageUrls
         )
 
-        // JSON 요청 부분을 RequestBody로 변환
-        val requestJson = json.encodeToString(CreateFeedRequest.serializer(), request)
-        val requestBody = requestJson.toRequestBody("application/json".toMediaType())
-
-        // 임시 파일 목록 추적
-        val tempFiles = mutableListOf<File>()
+        feedService.createFeed(request)
+            .handleBaseResponse()
+            .getOrThrow()
+    }
 
-        // 이미지 파일들을 MultipartBody.Part로 변환
-        val imageParts = if (imageUris.isNotEmpty()) {
-            withContext(Dispatchers.IO) {
-                imageUris.mapNotNull { uri ->
-                    runCatching {
-                        uriToMultipartBodyPart(uri, "images", tempFiles)
-                    }.getOrNull()
+    /** 이미지들을 S3에 업로드하고 CloudFront URL 목록 반환 */
+    private suspend fun uploadImagesToS3(imageUris: List<Uri>): List<String> = withContext(Dispatchers.IO) {
+        val validImagePairs = imageUris.map { uri ->
+            async { 
+                imageUploadHelper.getImageMetadata(uri)?.let { metadata ->
+                    uri to metadata
                 }
             }
-        } else {
-            null
-        }
+        }.awaitAll().filterNotNull()
 
-        try {
-            feedService.createFeed(requestBody, imageParts)
-                .handleBaseResponse()
-                .getOrThrow()
-        } finally {
-            // 임시 파일들 정리
-            cleanupTempFiles(tempFiles)
-        }
-    }
+        if (validImagePairs.isEmpty()) return@withContext emptyList()
 
-    private fun uriToMultipartBodyPart(
-        uri: Uri,
-        paramName: String,
-        tempFiles: MutableList<File>
-    ): MultipartBody.Part? {
-        return runCatching {
-            // MIME 타입 확인
-            val mimeType = context.contentResolver.getType(uri) ?: "image/jpeg"
-            val extension = when (mimeType) {
-                "image/png" -> "png"
-                "image/gif" -> "gif"
-                "image/jpeg", "image/jpg" -> "jpg"
-                else -> "jpg" // 기본값
-            }
+        val presignedUrlRequest = validImagePairs.map { it.second }
+
+        val presignedResponse = feedService.getPresignedUrls(presignedUrlRequest)
+            .handleBaseResponse()
+            .getOrThrow() ?: throw Exception("Failed to get presigned URLs")
 
-            // 파일명 생성
-            val fileName = "feed_image_${System.currentTimeMillis()}.$extension"
-            val tempFile = File(context.cacheDir, fileName)
+        // 개수 검증
+        if (validImagePairs.size != presignedResponse.presignedUrls.size) {
+            throw Exception("Presigned URL count mismatch: expected ${validImagePairs.size}, got ${presignedResponse.presignedUrls.size}")
+        }
 
-            // 임시 파일 목록에 추가
-            tempFiles.add(tempFile)
+        val uploadedImageUrls = mutableListOf<String>()
 
-            // InputStream을 use 블록으로 안전하게 관리
-            context.contentResolver.openInputStream(uri)?.use { inputStream ->
-                FileOutputStream(tempFile).use { outputStream ->
-                    inputStream.copyTo(outputStream)
-                }
-            } ?: throw IllegalStateException("Failed to open input stream for URI: $uri")
+        validImagePairs.forEachIndexed { index, (uri, _) ->
+            val presignedInfo = presignedResponse.presignedUrls[index]
 
-            // MultipartBody.Part 생성
-            val requestFile = tempFile.asRequestBody(mimeType.toMediaType())
-            MultipartBody.Part.createFormData(paramName, fileName, requestFile)
-        }.onFailure { e ->
-            e.printStackTrace()
-        }.getOrNull()
+            imageUploadHelper.uploadImageToS3(
+                uri = uri,
+                presignedUrl = presignedInfo.presignedUrl
+            ).onSuccess {
+                uploadedImageUrls.add(presignedInfo.fileUrl)
+            }.onFailure { exception ->
+                throw Exception("Failed to upload image ${index + 1}: ${exception.message}")
+            }
+        }
+
+        uploadedImageUrls
     }
 
+
     /** 전체 피드 목록 조회 */
     suspend fun getAllFeeds(cursor: String? = null): Result<AllFeedResponse?> = runCatching {
         feedService.getAllFeeds(cursor)
@@ -205,18 +185,6 @@ class FeedRepository @Inject constructor(
             .getOrThrow()
     }
 
-    /** 임시 파일들을 정리하는 함수 */
-    private fun cleanupTempFiles(tempFiles: List<File>) {
-        tempFiles.forEach { file ->
-            runCatching {
-                if (file.exists()) {
-                    file.delete()
-                }
-            }.onFailure { e ->
-                e.printStackTrace()
-            }
-        }
-    }
 
     suspend fun getFeedUsersInfo(userId: Long) = runCatching {
         feedService.getFeedUsersInfo(userId)

app/src/main/java/com/texthip/thip/data/repository/RoomsRepository.kt

@@ -42,8 +42,8 @@ class RoomsRepository @Inject constructor(
     }
 
     /** 내가 참여 중인 모임방 목록 조회 */
-    suspend fun getMyJoinedRooms(page: Int): Result<JoinedRoomListResponse?> = runCatching {
-        val response = roomsService.getJoinedRooms(page)
+    suspend fun getMyJoinedRooms(cursor: String? = null): Result<JoinedRoomListResponse?> = runCatching {
+        val response = roomsService.getJoinedRooms(cursor)
             .handleBaseResponse()
             .getOrThrow()