Can a single iOS app installation have two valid apns tokens simultaneously?

This comment says:
> silent push is the only way that your server can make your app send some data whenever it needs. But this works only when you already have a valid token.

This implies that to periodically get the latest valid apns token once the user stops launching the app: (1) The remote server sends a silent push using token X it got from an earlier app launch, then (2) the silent push causes the app's code to run which gets the token Y from apns library and sends it to the remote server.

If token X != token Y, which of these is true:

• token X and token Y are both valid at the same time
• as soon as the app gets token Y, token X becomes invalid
• the scenario described above (Steps 1 and 2) is not possible

whenever the app lauches then you have to send updated token against that user so there is no way of two FCM token against one user, once you implement slient notification there are a few points that are very important.

1. The application(_:didReceiveRemoteNotification:fetchCompletionHandler:) delegate method will still trigger even though the app is in the foreground.

2. The silent push notification will wake up a terminated app. As a result, the application(_:didFinishLaunchingWithOptions:) delegate method and the initial view controller’s viewDidLoad() method will be triggered as well.

3. The background operation triggered by a silent push notification will have roughly 30 seconds of execution time.

   extension AppDelegate: MessagingDelegate
   {
   // Once you get new token this delegate call and you need to update user token on server
   func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {

    	let params = ["fcmToken":token,"deviceType":"ios"]
    	APIClient.updateFCM(userID:user.ID , bodyParams:params).done { (response) in
   
   
    	}
    }	
   
    func setFirebasePushNotification(){
   
        Messaging.messaging().delegate = self
   
        if #available(iOS 10.0, *) {
            // For iOS 10 display notification (sent via APNS)
            UNUserNotificationCenter.current().delegate = self
   
            let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
            UNUserNotificationCenter.current().requestAuthorization(
                options: authOptions,
                completionHandler: {_, _ in })
        } else {
            let settings: UIUserNotificationSettings =
            UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)
            UIApplication.shared.registerUserNotificationSettings(settings)
        }
   
        UIApplication.shared.registerForRemoteNotifications()
    }
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    	setFirebasePushNotification()
    }
   

   }

Please check these links for reference.

https://swiftsenpai.com/testing/send-silent-push-notifications/

https://swiftsenpai.com/testing/send-silent-push-notifications/

The short answer is No

The application (and libraries like FCM) should update their token using:

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) { ... }

As the documentation says:
> Device tokens can change periodically, so caching the value risks sending an invalid token to your server.

So as soon as the app gets token Y, token X becomes invalid

Note: FCM uses method swizzling in two key areas and one of them is mapping APNs token So it may be hidden from your implementation but it is updating the token each time its needed and the invalidate the previous one

No, it can not.

1. From the Apple official documentation

    func application(
    _ application: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
    )

> Never cache the device token locally on the user's device. Device tokens can change periodically, so caching the value risks sending an invalid token to your server. If the device token hasn't changed, registering with APNs and returning the token happens quickly.

You may need to call this function: registerForRemoteNotifications(), whenever your app becomes active, again. And submit this deviceToken to Firebase Messaging, your BE, OneSignal,...

func registerForRemoteNotifications()

When you call the above method, it will request to APNs to get a new or current device token. This is the moment that APNs will identify your App & Device status.

2. Why it changes periodically? Here are the mechanics, methods, or reasons why Apple may use, do in changing DeviceToken, this is used for explaining what will or may happen behind the scene, they are both theories and facts.

• This is how Apple does to improve user experience. Changing the Token periodically is like your app call /refresh-token to BE to get a new token. Because the old token already expired or is invalid. This increases security, protects user's privacy, etc. Imagine that you can still spam push notifications to user's devices when app is deleted/uninstalled, this is a horrible UX.
• Push Notification is processed/transferred over the Internet connection. Apple Push Notification service will have to check your Device & App periodically to make sure that your Phone is alive, and your App is installed, to successfully send a push notification to the target App on the target Device.
• You can imagine that the Device Token = Phone UUID + App Bundle ID + Time + Some encoding, encrypting,... even Phone IP, Socket connection ID,...
• Ex: Wifi lost? Phone Public IP changes, Socket Connection ID changes,... Now, we need to regenerate a new Device Token. This is just an example of changing process. It doesn't means that Device Token will 100% change when Phone Public IP changes. Apple decides this, we just handle the result of the changing process.