Push notifications (APNs + FCM) in iOS Swift

Introduction

Push notifications let apps send messages to users even when the app is closed. They help keep users informed and engaged.

To alert users about new messages or updates in a chat app.

To remind users about upcoming events or appointments.

To send promotional offers or news from a shopping app.

To notify users about important system alerts or security warnings.

Syntax

iOS Swift

import UserNotifications

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

// AppDelegate methods
func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
  // Send deviceToken to your server or Firebase
}

func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
  print("Failed to register: \(error)")
}

APNs (Apple Push Notification service) is Apple's system to send notifications to iOS devices.

FCM (Firebase Cloud Messaging) is a service by Google that helps send notifications to multiple platforms including iOS.

Examples

This asks the user if the app can send alerts and play sounds.

iOS Swift

// Request permission for notifications
UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound]) { granted, error in
  print("Permission granted: \(granted)")
}

This tells iOS to get a device token for push notifications.

iOS Swift

// Register for remote notifications
UIApplication.shared.registerForRemoteNotifications()

This converts the device token to a string to send to your server or Firebase.

iOS Swift

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
  let tokenString = deviceToken.map { String(format: "%02hhx", $0) }.joined()
  print("Device Token: \(tokenString)")
}

Sample App

This example shows how to ask permission, register for push notifications, and print the device token. It also handles showing notifications when the app is open.

iOS Swift

import UIKit
import UserNotifications

@main
class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    UNUserNotificationCenter.current().delegate = self
    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
      if granted {
        DispatchQueue.main.async {
          UIApplication.shared.registerForRemoteNotifications()
        }
      } else {
        print("Notification permission denied")
      }
    }
    return true
  }

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

  func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
    print("Failed to register: \(error.localizedDescription)")
  }

  // Handle notification when app is in foreground
  func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    completionHandler([.banner, .sound])
  }
}

Important Notes

Always test push notifications on a real device; the simulator does not support them.

Make sure your app's bundle ID matches the one in your Apple Developer account for push notifications.

FCM requires setting up Firebase in your project and uploading APNs certificates or keys.

Summary

Push notifications keep users updated even when the app is closed.

Use APNs to get device tokens and send notifications on iOS.

FCM helps manage and send notifications across platforms including iOS.

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