Push notifications (APNs + FCM) in iOS Swift - Build, Publish & Deploy

Build & Publish - Push notifications (APNs + FCM)

Performance Impact

Push notifications use minimal device resources when idle. They rely on system services (APNs on iOS, FCM on Android) to deliver messages efficiently.

Receiving notifications does not affect frame rate or battery significantly unless your app processes heavy tasks on notification receipt.

Background processing triggered by notifications can increase CPU and battery use, so keep tasks short and efficient.

Optimization Tips

Use silent notifications sparingly to avoid waking the app unnecessarily.

Process notification data quickly and defer heavy work to background tasks or server-side.

Batch notifications on the server to reduce frequency and avoid spamming users.

Use APNs and FCM best practices: set appropriate priority and expiration to avoid wasted resources.

App Size and Startup Impact

Integrating APNs requires no extra app size as it is built into iOS.

Adding Firebase Cloud Messaging (FCM) SDK increases app size by a few megabytes depending on included features.

Keep Firebase SDK minimal by only including messaging if needed to reduce bundle size.

Push notification setup does not affect app startup time significantly.

iOS vs Android Differences

iOS uses Apple Push Notification service (APNs) which requires device tokens and strict code signing.

Android uses Firebase Cloud Messaging (FCM) which supports topic messaging and direct device tokens.

iOS notifications require user permission prompt; Android permissions vary by OS version.

Handling notification payloads differs: iOS uses UNUserNotificationCenter, Android uses NotificationManager.

Store Review Guidelines

• Request notification permissions only when needed and explain why clearly to users.
• Do not use notifications for spam or irrelevant content; follow Apple App Store and Google Play policies.
• Ensure notifications respect user privacy and data protection rules.
• Test notifications thoroughly to avoid crashes or unexpected behavior.

Self-Check Question

Your app takes 5 seconds to load this screen after receiving a push notification. What's likely wrong?

Answer: The app is performing heavy processing on the main thread when handling the notification. Optimize by moving work to background threads and keep notification handling lightweight.

Key Result

Push notifications use minimal resources but require careful handling to avoid battery drain and app slowdowns. Use APNs for iOS and FCM for Android with best practices to keep app size small and ensure smooth user experience.

Practice

1. What is the primary purpose of APNs in iOS push notifications?

easy

A. To store app data locally

B. To manage user authentication

C. To deliver push notifications to iOS devices

D. To create user interface elements

Solution

1. Step 1: Understand APNs role

   APNs stands for Apple Push Notification service and is designed to send notifications to iOS devices.

2. Step 2: Differentiate from other services

   It does not handle authentication, data storage, or UI creation, only notification delivery.

3. Final Answer:

   To deliver push notifications to iOS devices -> Option C

4. Quick Check:

   APNs = notification delivery [OK]

Hint: APNs is Apple's service for sending notifications [OK]

Common Mistakes:

• Confusing APNs with authentication services
• Thinking APNs manages app data
• Assuming APNs creates UI elements

2. Which Swift code snippet correctly requests permission for push notifications?

easy

A. UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound]) { granted, error in }

B. UNUserNotificationCenter.requestAuthorization(options: [.alert])

C. UNNotificationCenter.current().requestPermission()

D. UserNotificationCenter.requestAuthorization(options: [.badge])

Solution

1. Step 1: Identify correct class and method

   The correct class is UNUserNotificationCenter and the method is requestAuthorization with options and completion handler.

2. Step 2: Check syntax correctness

   UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound]) { granted, error in } uses the correct syntax with options array and closure parameters.

3. Final Answer:

   UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound]) { granted, error in } -> Option A

4. Quick Check:

   Correct class and method = UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound]) { granted, error in } [OK]

Hint: Use UNUserNotificationCenter.current().requestAuthorization with options [OK]

Common Mistakes:

• Using wrong class names like UNNotificationCenter
• Omitting the completion handler closure
• Incorrect method names like requestPermission

3. Given this Swift code snippet, what will be printed if the device token is successfully received?

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
    let token = tokenParts.joined()
    print("Device Token: \(token)")
}

medium

A. Device Token: nil

B. Device Token:

C. Device Token: deviceToken

D. Device Token: [data]

Solution

1. Step 1: Understand deviceToken processing

   The deviceToken is converted byte-by-byte to a hexadecimal string representation.

2. Step 2: Analyze print output

   The print statement outputs "Device Token: " followed by the joined hex string, not the raw data or nil.

3. Final Answer:

   Device Token: <hexadecimal string> -> Option B

4. Quick Check:

   Device token converted to hex string = Device Token: <hexadecimal string> [OK]

Hint: Device token is hex string printed, not raw data [OK]

Common Mistakes:

• Expecting raw Data object printed
• Assuming deviceToken is nil
• Printing deviceToken without conversion

4. Identify the error in this Swift code snippet for registering remote notifications:

func registerForPushNotifications() {
    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
        if granted {
            DispatchQueue.main.async {
                UIApplication.shared.registerForRemoteNotifications()
            }
        }
    }
}

medium

A. Incorrect options array syntax

B. Missing call to UNUserNotificationCenter.current().delegate assignment

C. registerForRemoteNotifications() should be called outside DispatchQueue.main.async

D. No error, code is correct

Solution

1. Step 1: Verify permission request syntax

   UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in ... } uses correct class, method, options, and completion handler.

2. Step 2: Confirm registration call

   DispatchQueue.main.async ensures UIApplication.shared.registerForRemoteNotifications() runs on the main thread, which is correct practice.

3. Final Answer:

   No error, code is correct -> Option D

4. Quick Check:

   Standard registration flow followed correctly [OK]

Hint: This code correctly requests permission and registers for remote notifications [OK]

Common Mistakes:

• Thinking UNUserNotificationCenter delegate is required inside this registration function
• Claiming incorrect options array syntax
• Believing registerForRemoteNotifications should avoid DispatchQueue.main.async

5. You want to send a push notification to an iOS app using Firebase Cloud Messaging (FCM). Which step is essential to link APNs with FCM for this to work correctly?

hard

A. Upload the APNs authentication key or certificates to the Firebase Console

B. Enable Background Modes in Xcode without any APNs setup

C. Register the device token only with APNs, ignoring FCM

D. Use only APNs without configuring Firebase

Solution

1. Step 1: Understand FCM and APNs integration

   FCM requires APNs credentials to send notifications to iOS devices through Apple's service.

2. Step 2: Identify required configuration

   You must upload the APNs authentication key or certificates to Firebase Console to enable this link.

3. Final Answer:

   Upload the APNs authentication key or certificates to the Firebase Console -> Option A

4. Quick Check:

   APNs key upload to Firebase = Upload the APNs authentication key or certificates to the Firebase Console [OK]

Hint: Upload APNs key to Firebase to enable iOS push via FCM [OK]

Common Mistakes:

• Skipping APNs key upload to Firebase
• Relying only on Background Modes without APNs
• Ignoring FCM device token registration