Chore/#126 link

app/src/androidTest/java/com/linku/link/ExampleInstrumentedTest.kt

@@ -1,32 +1,17 @@
-<<<<<<<< HEAD:app/src/androidTest/java/com/linku/link/ExampleInstrumentedTest.kt
 package com.linku.link
-========
-package com.linku
->>>>>>>> fd1304faab6b86e04c17e31a0786ce151290d292:app/src/androidTest/java/com/linku/ExampleInstrumentedTest.kt
 
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.ext.junit.runners.AndroidJUnit4
-
 import org.junit.Test
 import org.junit.runner.RunWith
-
 import org.junit.Assert.*
 
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
 @RunWith(AndroidJUnit4::class)
 class ExampleInstrumentedTest {
+
     @Test
     fun useAppContext() {
-        // Context of the app under test.
         val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-<<<<<<<< HEAD:app/src/androidTest/java/com/linku/link/ExampleInstrumentedTest.kt
-        assertEquals("com.linku.link", appContext.packageName)
-========
         assertEquals("com.linku", appContext.packageName)
->>>>>>>> fd1304faab6b86e04c17e31a0786ce151290d292:app/src/androidTest/java/com/linku/ExampleInstrumentedTest.kt
     }
 }

app/src/main/AndroidManifest.xml

@@ -79,6 +79,10 @@
 
         </activity>
 
+        <meta-data
+            android:name="com.google.firebase.messaging.default_notification_channel_id"
+            android:value="default_channel" />
+
         <!--    FCM Service    -->
         <service
             android:name="com.linku.LinkUFireBaseMessageService"

app/src/main/java/com/linku/LinkUFireBaseMessageService.kt

@@ -1,18 +1,94 @@
 package com.linku
 
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.util.Log
+import androidx.core.app.NotificationCompat
 import com.google.firebase.messaging.FirebaseMessagingService
 import com.google.firebase.messaging.RemoteMessage
+import com.linku.core.di.ApplicationScope
+import com.linku.core.repository.AlarmRepository
+import com.linku.data.preference.NotificationPreference
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import javax.inject.Inject
 
+
+@AndroidEntryPoint
 class LinkUFireBaseMessageService : FirebaseMessagingService() {
 
+    // FirebaseMessagingService는 생성자 주입이 불가. 따라서 필드 주입 사용
+    @Inject
+    lateinit var alarmRepository: AlarmRepository
+    @Inject
+    lateinit var notificationPreference: NotificationPreference
+
+    @Inject
+    @ApplicationScope
+    lateinit var externalScope: CoroutineScope
+
+    //FireBase에서 새 토큰이 발급되었을 때 호출되는 콜백
     override fun onNewToken(token: String) {
         super.onNewToken(token)
-        // TODO: 서버에 FCM 토큰 전송
+        if (BuildConfig.DEBUG) {
+            Log.d("FCM Token", token)
+        }
+
+        notificationPreference.setFcmToken(token)
+
+        externalScope.launch {
+            alarmRepository.registerFCMToken(token)
+        }
     }
 
+    // FireBase로부터 메세지를 받았을 때 호출되는 콜백
     override fun onMessageReceived(message: RemoteMessage) {
         super.onMessageReceived(message)
-        // TODO: 푸시 알림 처리
+
+        // 푸시알림 활성화 안되어있으면 종료
+        if (!notificationPreference.isMasterNotificationEnabled()) return
+
+        // FCM 메시지 타입에 따라 title/body 추출
+        // Notification Message: message.notification에서 추출
+        // Data Message: message.data에서 추출
+        // 둘 다 없으면 처리 불필요로 판단하여 종료
+        val title = message.notification?.title ?: message.data["title"] ?: return
+        val body = message.notification?.body ?: message.data["message"] ?: return
+        val targetId = message.data["targetId"] ?: "null"
+
+        Log.d("FCM", """
+            FCM 수신
+            title: $title
+            body: $body
+            targetId: $targetId
+            """.trimIndent()
+        )
+
+        // 일단은 액티비티로의 이동처리만 구현. 추후 수정 예정
+        val pendingIntent = PendingIntent.getActivity(
+            this,
+            0,
+            packageManager.getLaunchIntentForPackage(packageName),
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+        )
+
+        // 알림 제작
+        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_logo)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .setAutoCancel(true)
+            .setContentIntent(pendingIntent)
+            .build()
+
+        // 알림 출력
+        getSystemService(NotificationManager::class.java)
+            .notify(System.currentTimeMillis().toInt(), notification)
     }
 
-}
+    companion object {
+        const val CHANNEL_ID = "default_channel"
+    }
+}

app/src/main/java/com/linku/MainApp.kt

@@ -49,7 +49,8 @@ import com.linku.file.FileViewModel
 import com.linku.file.viewmodel.folder.state.FolderStateViewModel
 import com.linku.home.HomeApp
 import com.linku.home.HomeViewModel
-import com.linku.home.screen.SaveLinkResultScreen
+import com.linku.home.component.LinkCategoryOption
+import com.linku.home.screen.LinkDetailScreen
 import com.linku.home.screen.SaveLinkScreen
 import com.linku.linku_android.curation.curationGraph
 import com.linku.login.navigation.LoginApp
@@ -159,10 +160,9 @@ fun MainApp(
     // 권한 요청 런쳐
     val notificationPermissionLauncher = rememberLauncherForActivityResult(
         ActivityResultContracts.RequestPermission()
-    ) { isGranted -> // 시스템 권한 요청 결과를 로컬에 저장
+    ) { isGranted ->
         viewModel.setNotificationEnabled(isGranted)
         Log.d("MainApp", "알림 권한 요청 결과: $isGranted")
-        Log.d("MainApp", "시스템 권한 상태: ${ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED}")
     }
 
 
@@ -173,6 +173,8 @@ fun MainApp(
             // Android 13 이상에서는 POST_NOTIFICATIONS 런타임 권한이 필요하므로 조건부 요청
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                 notificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
+            } else {
+                viewModel.setNotificationEnabled(true)
             }
             requestNotificationPermission = false // 한 번만 요청하도록 처리
         }
@@ -359,7 +361,7 @@ fun MainApp(
                         HomeApp(
                             viewModel = homeViewModel,
                             nickname = nickname.orEmpty().ifBlank { "링큐" },
-                            onNavigateToMyPage = {  // TODO: 추후 알림 설정 페이지로 이동
+                            onNavigateToMyPage = {
                                 navigator.navigate(NavigationRoute.MyPage.route) {
                                     popUpTo(navigator.graph.findStartDestination().id) {
                                         saveState = true
@@ -369,6 +371,13 @@ fun MainApp(
                                     restoreState = true
                                 }
                             },
+                            onNavigateToSaveLink = { url ->
+                                homeViewModel.setUrl(url)
+                                navigator.navigate("savelink")
+                            },
+                            onNavigateToLinkDetail = { linkuId ->
+                                navigator.navigate("savelinkresult/$linkuId")
+                            },
                             onShowNavBar = { showNavBar = it }
                         )
                     }
@@ -453,18 +462,29 @@ fun MainApp(
                     SaveLinkScreen(
                         image = vm.image,
                         url = vm.url,
+                        title = vm.title,
                         memo = vm.memo,
                         selectedEmotionId = vm.selectedEmotionId,
+                        selectedSituationId = vm.selectedSituationId,
+                        jobId = vm.jobId ?: 3L,
                         onPickImage = { imagePicker.launch("image/*") },
                         onUrlChange = vm::setUrl,
+                        onTitleChange = vm::setTitle,
                         onMemoChange = vm::setMemo,
                         onEmotionSelect = vm::selectEmotion,
+                        onSituationSelect = vm::selectSituation,
                         onSaveClick = {
-                            // 저장 버튼 로그 + API 호출
-                            Log.d("SaveLink", "try save -> url=${vm.url}, memo=${vm.memo}, emotionId=${vm.selectedEmotionId}, image=${vm.image?.name}")
+                            Log.d(
+                                "SaveLink",
+                                "try save -> url=${vm.url}, memo=${vm.memo}, emotionId=${vm.selectedEmotionId}, situationId=${vm.selectedSituationId}, image=${vm.image?.name}"
+                            )
+
                             vm.saveLink(
                                 onSucceed = { saved ->
-                                    Log.d("SaveLink", "success -> id=${saved.linkuId}, title=${saved.title}, domain=${saved.domain}")
+                                    Log.d(
+                                        "SaveLink",
+                                        "success -> id=${saved.linkuId}, title=${saved.title}, domain=${saved.domain}"
+                                    )
                                     vm.loadLinkDetail(saved.linkuId)
                                     vm.resetForm()
                                     navigator.navigate("savelinkresult/${saved.linkuId}")
@@ -496,48 +516,115 @@ fun MainApp(
                         vm.loadCategoryColors()
                     }
 
+                    fun emotionNameOf(id: Long?): String {
+                        return when (id) {
+                            1L -> "즐거움"
+                            2L -> "평온"
+                            3L -> "설렘"
+                            4L -> "슬픔"
+                            5L -> "짜증"
+                            6L -> "분노"
+                            else -> "감정"
+                        }
+                    }
+
+                    // TODO: 카테고리 API 연동 후 categoryId 기준 실제 카테고리명/색상 매핑으로 교체
+                    val CATEGORY_MAP = linkedMapOf(
+                        1L to "어학",
+                        2L to "뉴스",
+                        3L to "공부법",
+                        4L to "IT·개발",
+                        5L to "자기계발",
+                        6L to "취업·이직",
+                        7L to "비즈니스 인사이트",
+                        8L to "생산성·툴",
+                        9L to "라이프스타일",
+                        10L to "심리·자기이해",
+                        11L to "에세이·칼럼",
+                        12L to "트렌드",
+                        13L to "디자인·예술",
+                        14L to "영상·뮤직",
+                        15L to "맛집·여행",
+                        16L to "기타"
+                    )
+
+                    fun categoryNameOf(id: Long?): String {
+                        return CATEGORY_MAP[id] ?: "카테고리"
+                    }
+
+                    fun categoryIdOf(name: String): Long? {
+                        return CATEGORY_MAP.entries
+                            .firstOrNull { it.value == name }
+                            ?.key
+                    }
+
+                    fun keywordToTags(keyword: String?): List<String> {
+                        return keyword
+                            .orEmpty()
+                            .split(",", " ", "#")
+                            .map { it.trim() }
+                            .filter { it.isNotBlank() }
+                            .take(4)
+                    }
+
                     // 진행률/색상 맵 수집
                     val aiProgress = vm.aiProgress.collectAsState().value
                     val categoryColorMap = vm.categoryColorMap.collectAsState().value
 
+                    val categoryOptions = categoryColorMap.mapNotNull { (name, style) ->
+                        val id = categoryIdOf(name) ?: return@mapNotNull null
+
+                        LinkCategoryOption(
+                            id = id,
+                            name = name,
+                            color = style.color4
+                        )
+                    }
+
                     // 외부 브라우저 열기
                     fun openUrl(url: String) {
                         runCatching {
-                            val fixed = if (url.startsWith("http")) url else "https://$url"
+                            val fixed = if (
+                                url.startsWith("http://") || url.startsWith("https://")
+                            ) {
+                                url
+                            } else {
+                                "https://$url"
+                            }
+
                             val intent = Intent(
                                 Intent.ACTION_VIEW,
                                 fixed.toUri()
                             )
+
                             context.startActivity(intent)
                         }.onFailure {
                             Toast.makeText(context, "링크를 열 수 없어요.", Toast.LENGTH_SHORT).show()
                         }
                     }
 
-                    SaveLinkResultScreen(
-                        link = vm.linkDetail,
-                        aiArticle = vm.aiArticleDetail,
-                        isLoading = vm.isLoadingLinkDetail || vm.isLoadingAiArticle,
-                        isAiLoading = vm.isLoadingAiArticle,
-                        onBack = { navigator.popBackStack() },
-                        onOpenLink = { url -> openUrl(url) },
-                        categoryColorMap = categoryColorMap,
-                        onSubmitEdit = { title, memo, categoryId, emotionId ->
-                            vm.updateLink(
-                                title = title,
-                                memo = memo,
-                                categoryId = categoryId,
-                                emotionId = emotionId,
-                                onSucceed = { Toast.makeText(context, "수정 완료", Toast.LENGTH_SHORT).show() },
-                                onFailed = { e ->
-                                    Log.e("SaveLinkResult", "수정 실패", e)
-                                    Toast.makeText(context, e.message ?: "수정에 실패했습니다.", Toast.LENGTH_SHORT).show()
-                                }
-                            )
-                        },
-                        onRequestAiSummary = { vm.loadAiArticle(linkuId) },
-                        aiProgress = aiProgress,
-                        onCancelAi = { vm.cancelAiArticleJob() }
+                    val linkDetail = vm.linkDetail
+                    val aiArticle = vm.aiArticleDetail
+
+                    val displayKeyword = aiArticle?.keyword?.trim().orEmpty()
+                        .ifEmpty { linkDetail?.keyword.orEmpty() }
+
+                    val displaySummary = aiArticle?.summary?.trim().orEmpty()
+                        .ifEmpty { linkDetail?.summary.orEmpty() }
+
+                    LinkDetailScreen(
+                        linkTitle = linkDetail?.title.orEmpty(),
+                        category = categoryNameOf(linkDetail?.categoryId),
+                        emotion = emotionNameOf(linkDetail?.emotionId),
+                        situationId = null, // TODO: 상세 API에 situationId 생기면 linkDetail?.situationId로 변경
+                        linkUrl = linkDetail?.linku.orEmpty(),
+                        memo = linkDetail?.memo.orEmpty(),
+                        tags = keywordToTags(displayKeyword),
+                        aiSummary = displaySummary,
+                        categoryOptions = categoryOptions,
+                        onBack = {
+                            navigator.popBackStack()
+                        }
                     )
                 }