[BOOK-433] refactor: 멀티디바이스에서 유효하지 않은 FID/FCM 토큰 정리 로직 추가 (#129)

Author: minwoo1999

batch/src/main/kotlin/org/yapp/batch/service/FcmSendResult.kt

@@ -0,0 +1,7 @@
+package org.yapp.batch.service
+
+data class FcmSendResult(
+    val successCount: Int,
+    val failureCount: Int,
+    val invalidTokens: List<String>
+)

batch/src/main/kotlin/org/yapp/batch/service/FcmService.kt

@@ -1,46 +1,72 @@
 package org.yapp.batch.service
 
-import com.google.firebase.messaging.FirebaseMessaging
-import com.google.firebase.messaging.Message
-import com.google.firebase.messaging.Notification
+import com.google.firebase.messaging.*
 import org.slf4j.LoggerFactory
 import org.springframework.stereotype.Service
 
 @Service
 class FcmService {
     private val logger = LoggerFactory.getLogger(FcmService::class.java)
 
-    fun sendNotification(token: String, title: String, body: String): String? {
-        try {
-            val notification = Notification.builder()
-                .setTitle(title)
-                .setBody(body)
-                .build()
+    fun sendMulticastNotification(tokens: List<String>, title: String, body: String): FcmSendResult {
+        if (tokens.isEmpty()) {
+            logger.warn("FCM token list is empty. Skipping notification.")
+            return FcmSendResult(0, 0, emptyList())
+        }
 
-            val message = Message.builder()
-                .setToken(token)
+        val notification = buildNotification(title, body)
+        val messages = tokens.map { token ->
+            Message.builder()
                 .setNotification(notification)
+                .setToken(token)
                 .build()
+        }
 
-            val response = FirebaseMessaging.getInstance().send(message)
-            logger.info("Successfully sent message: {}", response)
-            return response
-        } catch (e: Exception) {
-            logger.error("Failed to send FCM notification", e)
-            return null
+        try {
+            val response = FirebaseMessaging.getInstance().sendEach(messages)
+            return processFcmResponse(response, tokens)
+        } catch (e: FirebaseMessagingException) {
+            logger.error("Failed to send FCM notification to ${tokens.size} tokens", e)
+            return FcmSendResult(0, tokens.size, emptyList())
         }
     }
 
-    fun sendMulticastNotification(tokens: List<String>, title: String, body: String): List<String> {
-        val successfulSends = mutableListOf<String>()
+    private fun buildNotification(title: String, body: String): Notification {
+        return Notification.builder()
+            .setTitle(title)
+            .setBody(body)
+            .build()
+    }
 
-        tokens.forEach { token ->
-            val messageId = sendNotification(token, title, body)
-            if (messageId != null) {
-                successfulSends.add(messageId)
+    private fun processFcmResponse(response: BatchResponse, tokens: List<String>): FcmSendResult {
+        val invalidTokens = mutableListOf<String>()
+
+        if (response.failureCount > 0) {
+            response.responses.forEachIndexed { index, sendResponse ->
+                if (!sendResponse.isSuccessful) {
+                    val failedToken = tokens[index]
+                    val errorCode = sendResponse.exception?.messagingErrorCode
+                    if (errorCode == MessagingErrorCode.UNREGISTERED || errorCode == MessagingErrorCode.INVALID_ARGUMENT) {
+                        invalidTokens.add(failedToken)
+                        logger.warn("Invalid FCM token found: {}. Error: {}", failedToken, errorCode)
+                    } else {
+                        logger.error("Failed to send to token: {}. Error: {}", failedToken, errorCode, sendResponse.exception)
+                    }
+                }
             }
         }
 
-        return successfulSends
+        logger.info(
+            "FCM multicast message sent. Success: {}, Failure: {}, Invalid Tokens: {}",
+            response.successCount,
+            response.failureCount,
+            invalidTokens.size
+        )
+
+        return FcmSendResult(
+            successCount = response.successCount,
+            failureCount = response.failureCount,
+            invalidTokens = invalidTokens
+        )
     }
 }

batch/src/main/kotlin/org/yapp/batch/service/NotificationService.kt

@@ -121,20 +121,22 @@ class NotificationService(
         message: String
     ): Int {
         val validTokens = devices
-            .filter { it.fcmToken.isNotBlank() }
             .map { it.fcmToken }
+            .filter { it.isNotBlank() }
 
         if (validTokens.isEmpty()) {
+            logger.warn("No valid FCM tokens found for devices: {}", devices.map { it.id })
             return 0
         }
 
-        return try {
-            val results = fcmService.sendMulticastNotification(validTokens, title, message)
-            results.size
-        } catch (e: Exception) {
-            logger.error("Error sending notifications to devices", e)
-            0
+        val result = fcmService.sendMulticastNotification(validTokens, title, message)
+
+        if (result.invalidTokens.isNotEmpty()) {
+            logger.info("Found ${result.invalidTokens.size} invalid tokens to remove.")
+            deviceDomainService.removeDevicesByTokens(result.invalidTokens)
         }
+
+        return result.successCount
     }
 
     @Transactional

domain/src/main/kotlin/org/yapp/domain/device/DeviceDomainService.kt

@@ -20,4 +20,10 @@ class DeviceDomainService(
         return deviceRepository.findByUserId(userId)
             .map { DeviceVO.from(it) }
     }
+
+    fun removeDevicesByTokens(tokens: List<String>) {
+        if (tokens.isNotEmpty()) {
+            deviceRepository.deleteByTokens(tokens)
+        }
+    }
 }

domain/src/main/kotlin/org/yapp/domain/device/DeviceRepository.kt

@@ -6,4 +6,5 @@ interface DeviceRepository {
     fun findByDeviceId(deviceId: String): Device?
     fun save(device: Device): Device
     fun findByUserId(userId: UUID): List<Device>
+    fun deleteByTokens(tokens: List<String>)
 }

infra/src/main/kotlin/org/yapp/infra/device/DeviceJpaRepository.kt

@@ -1,10 +1,16 @@
 package org.yapp.infra.device
 
 import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Modifying
+import org.springframework.data.jpa.repository.Query
 import org.yapp.infra.device.entity.DeviceEntity
 import java.util.UUID
 
 interface DeviceJpaRepository : JpaRepository<DeviceEntity, UUID> {
     fun findByDeviceId(deviceId: String): DeviceEntity?
     fun findByUserId(userId: UUID): List<DeviceEntity>
+
+    @Modifying
+    @Query("DELETE FROM DeviceEntity d WHERE d.fcmToken IN :tokens")
+    fun deleteByFcmTokenIn(tokens: List<String>)
 }

infra/src/main/kotlin/org/yapp/infra/device/DeviceRepositoryImpl.kt

@@ -21,4 +21,8 @@ class DeviceRepositoryImpl(
     override fun findByUserId(userId: UUID): List<Device> {
         return deviceJpaRepository.findByUserId(userId).map { it.toDomain() }
     }
+
+    override fun deleteByTokens(tokens: List<String>) {
+        deviceJpaRepository.deleteByFcmTokenIn(tokens)
+    }
 }