fix: FCMTokenSyncHandler에서 토큰 backfill 흐름을 처리하도록 수정

Author: opficdev

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

@@ -12,6 +12,7 @@ final class AppLayerAssembler: Assembler {
     func assemble(_ container: any DIContainer) {
         container.register(FCMTokenSyncHandler.self) {
             FCMTokenSyncHandler(
+                messagingService: container.resolve(PushMessagingService.self),
                 userService: container.resolve(UserService.self)
             )
         }

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

@@ -11,27 +11,82 @@ import DevLogData
 import Foundation
 
 final class FCMTokenSyncHandler {
+    private let messagingService: PushMessagingService
     private let userService: UserService
+    private let notificationCenter: NotificationCenter
     private let logger = Logger(category: "FCMTokenSyncHandler")
     private var cancellables = Set<AnyCancellable>()
 
     init(
+        messagingService: PushMessagingService,
         userService: UserService,
         notificationCenter: NotificationCenter = .default
     ) {
+        self.messagingService = messagingService
         self.userService = userService
+        self.notificationCenter = notificationCenter
 
         notificationCenter.publisher(for: .didRefreshFCMToken)
             .compactMap { $0.userInfo?["fcmToken"] as? String }
             .sink { [weak self] fcmToken in
-                Task {
-                    do {
-                        try await self?.userService.updateFCMToken(fcmToken)
-                    } catch {
-                        self?.logger.error("Failed to sync refreshed FCM token", error: error)
-                    }
-                }
+                self?.syncFCMToken(fcmToken)
+            }
+            .store(in: &cancellables)
+
+        notificationCenter.publisher(for: .didRequestFCMTokenSync)
+            .sink { [weak self] _ in
+                self?.requestFCMTokenSync()
             }
             .store(in: &cancellables)
+
+        notificationCenter.publisher(for: .didReceiveAPNSToken)
+            .compactMap { $0.userInfo?["deviceToken"] as? Data }
+            .sink { [weak self] deviceToken in
+                self?.handleAPNSToken(deviceToken)
+            }
+            .store(in: &cancellables)
+    }
+}
+
+private extension FCMTokenSyncHandler {
+    func requestFCMTokenSync() {
+        Task { [weak self] in
+            guard let self else { return }
+            guard await messagingService.isNotificationAuthorized() else {
+                return
+            }
+            notificationCenter.post(name: .didRequestRemoteNotificationRegistration, object: nil)
+            syncCurrentFCMToken()
+        }
+    }
+
+    func handleAPNSToken(_ deviceToken: Data) {
+        messagingService.setAPNSToken(deviceToken)
+        syncCurrentFCMToken()
+    }
+
+    func syncCurrentFCMToken() {
+        Task { [weak self] in
+            guard let self else { return }
+
+            do {
+                guard let fcmToken = try await messagingService.fetchFCMToken() else {
+                    return
+                }
+                try await userService.updateFCMToken(fcmToken)
+            } catch {
+                logger.error("Failed to sync current FCM token", error: error)
+            }
+        }
+    }
+
+    func syncFCMToken(_ fcmToken: String) {
+        Task { [weak self] in
+            do {
+                try await self?.userService.updateFCMToken(fcmToken)
+            } catch {
+                self?.logger.error("Failed to sync refreshed FCM token", error: error)
+            }
+        }
     }
 }

Application/DevLogData/Sources/Protocol/PushMessagingService.swift

@@ -10,6 +10,8 @@ import Foundation
 public protocol PushMessagingService: AnyObject {
     func setDelegate(_ delegate: PushMessagingServiceDelegate?)
     func setAPNSToken(_ deviceToken: Data)
+    func isNotificationAuthorized() async -> Bool
+    func fetchFCMToken() async throws -> String?
 }
 
 public protocol PushMessagingServiceDelegate: AnyObject {

Application/DevLogInfra/Sources/Service/PushMessagingServiceImpl.swift

@@ -8,6 +8,7 @@
 import Foundation
 import DevLogData
 import FirebaseMessaging
+import UserNotifications
 
 final class PushMessagingServiceImpl: NSObject, PushMessagingService {
     private weak var delegate: PushMessagingServiceDelegate?
@@ -20,10 +21,41 @@ final class PushMessagingServiceImpl: NSObject, PushMessagingService {
     func setAPNSToken(_ deviceToken: Data) {
         Messaging.messaging().apnsToken = deviceToken
     }
+
+    func isNotificationAuthorized() async -> Bool {
+        let settings = await UNUserNotificationCenter.current().notificationSettings()
+
+        switch settings.authorizationStatus {
+        case .authorized, .provisional, .ephemeral:
+            return true
+        case .denied, .notDetermined:
+            return false
+        @unknown default:
+            return false
+        }
+    }
+
+    func fetchFCMToken() async throws -> String? {
+        do {
+            return try await Messaging.messaging().token()
+        } catch {
+            if error.isMissingAPNSTokenForFCMToken {
+                return nil
+            }
+            throw error
+        }
+    }
 }
 
 extension PushMessagingServiceImpl: MessagingDelegate {
     func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
         delegate?.pushMessagingService(self, didReceiveRegistrationToken: fcmToken)
     }
 }
+
+private extension Error {
+    var isMissingAPNSTokenForFCMToken: Bool {
+        let nsError = self as NSError
+        return nsError.domain == "com.google.fcm" && nsError.code == 505
+    }
+}