[#608] Mac에서 앱이 온그라운드 상태가 될 때 FCM 토큰이 과도하게 업데이트되는 현상을 해결한다 (#668)

* fix: 온그라운드로 되면 fcm 토큰을 업데이트 하는 트리거 제거

* fix: FCM token 중복 저장 방지

* fix: FCM token 세션 전이 처리

* test: TodoList 취소 테스트 동기화 보강

Author: opficdev

Application/App/Sources/App/Assembler/AppLayerAssembler.swift

@@ -12,8 +12,10 @@ final class AppLayerAssembler: Assembler {
     func assemble(_ container: any DIContainer) {
         container.register(FCMTokenSyncHandler.self) {
             FCMTokenSyncHandler(
+                authService: container.resolve(AuthService.self),
                 messagingService: container.resolve(PushMessagingService.self),
-                userService: container.resolve(UserService.self)
+                userService: container.resolve(UserService.self),
+                store: container.resolve(UserDefaultsStore.self)
             )
         }
         container.register(UserTimeZoneSyncHandler.self) {

Application/App/Sources/App/Delegate/AppDelegate.swift

@@ -32,12 +32,6 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         _ = container.resolve(UserTimeZoneSyncHandler.self)
         _ = container.resolve(WidgetSyncEventHandler.self)
         _ = container.resolve(WidgetSessionSyncHandler.self)
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(handleSceneDidActivate),
-            name: UIScene.didActivateNotification,
-            object: nil
-        )
         NotificationCenter.default.addObserver(
             self,
             selector: #selector(handleRemoteNotificationRegistrationRequest),
@@ -73,10 +67,6 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         return true
     }
 
-    @objc private func handleSceneDidActivate() {
-        NotificationCenter.default.post(name: .didRequestFCMTokenSync, object: nil)
-    }
-
     @objc private func handleRemoteNotificationRegistrationRequest() {
         Task { @MainActor in
             UIApplication.shared.registerForRemoteNotifications()

Application/App/Sources/App/Handler/FCMTokenSyncHandler.swift

@@ -7,25 +7,44 @@
 
 import Combine
 import Core
+import CryptoKit
 import Data
 import Foundation
+import Infra
 
 final class FCMTokenSyncHandler {
+    private enum Key {
+        static let fcmTokenHash = "FCMTokenSyncHandler.fcmTokenHash"
+    }
+
+    private let authService: AuthService
     private let messagingService: PushMessagingService
     private let userService: UserService
+    private let store: UserDefaultsStore
     private let notificationCenter: NotificationCenter
     private let logger = Logger(category: "FCMTokenSyncHandler")
     private var cancellables = Set<AnyCancellable>()
 
     init(
+        authService: AuthService,
         messagingService: PushMessagingService,
         userService: UserService,
+        store: UserDefaultsStore,
         notificationCenter: NotificationCenter = .default
     ) {
+        self.authService = authService
         self.messagingService = messagingService
         self.userService = userService
+        self.store = store
         self.notificationCenter = notificationCenter
 
+        authService.observeSignedIn()
+            .removeDuplicates()
+            .sink { [weak self] isSignedIn in
+                self?.handleSessionUpdate(isSignedIn: isSignedIn)
+            }
+            .store(in: &cancellables)
+
         notificationCenter.publisher(for: .didRefreshFCMToken)
             .compactMap { $0.userInfo?["fcmToken"] as? String }
             .sink { [weak self] fcmToken in
@@ -49,12 +68,19 @@ final class FCMTokenSyncHandler {
 }
 
 private extension FCMTokenSyncHandler {
+    func handleSessionUpdate(isSignedIn: Bool) {
+        guard isSignedIn else {
+            store.setString(nil, forKey: Key.fcmTokenHash)
+            return
+        }
+
+        requestFCMTokenSync()
+    }
+
     func requestFCMTokenSync() {
         Task { [weak self] in
             guard let self else { return }
-            guard await messagingService.isNotificationAuthorized() else {
-                return
-            }
+            guard await messagingService.isNotificationAuthorized() else { return }
             notificationCenter.post(name: .didRequestRemoteNotificationRegistration, object: nil)
             await syncCurrentFCMToken()
         }
@@ -69,10 +95,8 @@ private extension FCMTokenSyncHandler {
 
     func syncCurrentFCMToken() async {
         do {
-            guard let fcmToken = try await messagingService.fetchFCMToken() else {
-                return
-            }
-            try await userService.updateFCMToken(fcmToken)
+            guard let fcmToken = try await messagingService.fetchFCMToken() else { return }
+            try await syncFCMTokenIfNeeded(fcmToken)
         } catch {
             logger.error("Failed to sync current FCM token", error: error)
         }
@@ -81,10 +105,33 @@ private extension FCMTokenSyncHandler {
     func syncFCMToken(_ fcmToken: String) {
         Task { [weak self] in
             do {
-                try await self?.userService.updateFCMToken(fcmToken)
+                try await self?.syncFCMTokenIfNeeded(fcmToken)
             } catch {
                 self?.logger.error("Failed to sync refreshed FCM token", error: error)
             }
         }
     }
+
+    func syncFCMTokenIfNeeded(_ fcmToken: String) async throws {
+        guard let uid = authService.uid else {
+            store.setString(nil, forKey: Key.fcmTokenHash)
+            logger.info("Skipping FCM token update because no authenticated user exists")
+            return
+        }
+
+        let tokenHash = makeTokenHash(uid: uid, fcmToken: fcmToken)
+        guard store.string(forKey: Key.fcmTokenHash) != tokenHash else {
+            logger.info("Skipping FCM token update because token hash is unchanged")
+            return
+        }
+
+        try await userService.updateFCMToken(fcmToken)
+        store.setString(tokenHash, forKey: Key.fcmTokenHash)
+    }
+
+    func makeTokenHash(uid: String, fcmToken: String) -> String {
+        let value = "\(uid)|\(FirebaseConfiguration.databaseID)|\(fcmToken)"
+        let digest = SHA256.hash(data: Data(value.utf8))
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
 }