Push Notifications Part 2

Create your AppDelegate

The AppDelegate is an object that manages your app. It listens to when your app is launched, when it's receiving data, or the state of the app - if it's in the background or in the foreground, for example. The AppDelegate is useful for notifications as there are methods, like didReceiveRemoteNotification, that will tell the app that a remote notifications has arrived.

To start off, let's import these three elements at the top of our ProjectNameApp.swift file:

import SwiftUI
import Firebase
import UserNotifications

Then, we'll need to create our AppDelegate. Create it below your App structure.

class AppDelegate: NSObject, UIApplicationDelegate {
    let gcmMessageIDKey = "gcm.message_id"

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        FirebaseApp.configure()

        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)
          application.registerUserNotificationSettings(settings)
        }

        application.registerForRemoteNotifications()
        return true
    }

    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any],
                     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {

      if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
      }

      print(userInfo)

      completionHandler(UIBackgroundFetchResult.newData)
    }
}

Here, we created two functions. The first one is executed once the app finished launching. We are configuring Firebase, then asking the user for permission to send them push notifications. The second function listens to remote notifications and will alert the app when a new push notification comes in.

Next, let's create an extension on AppDelegate. The messaging() function inside of this extension will print the device token. It'll be useful when we'll be sending a test notification through the Firebase Cloud Messaging Console to our device.

extension AppDelegate: MessagingDelegate {
    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {

      let deviceToken:[String: String] = ["token": fcmToken ?? ""]
        print("Device token: ", deviceToken) // This token can be used for testing notifications on FCM
    }
}

Finally, we'll create one last extension on AppDelegate. It's a UNUserNotificationCenterDelegate and you can think of it as a Notification Center. This is where all the notification actions are handled. Don't forget to add @available(iOS 10, *) before the extension as it's only available after iOS 10.

@available(iOS 10, *)
extension AppDelegate : UNUserNotificationCenterDelegate {

  // Receive displayed notifications for iOS 10 devices.
  func userNotificationCenter(_ center: UNUserNotificationCenter,
                              willPresent notification: UNNotification,
    withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    let userInfo = notification.request.content.userInfo

    if let messageID = userInfo[gcmMessageIDKey] {
        print("Message ID: \(messageID)")
    }

    print(userInfo)

    // Change this to your preferred presentation option
    completionHandler([[.banner, .badge, .sound]])
  }

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

    }

    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {

    }

  func userNotificationCenter(_ center: UNUserNotificationCenter,
                              didReceive response: UNNotificationResponse,
                              withCompletionHandler completionHandler: @escaping () -> Void) {
    let userInfo = response.notification.request.content.userInfo

    if let messageID = userInfo[gcmMessageIDKey] {
      print("Message ID from userNotificationCenter didReceive: \(messageID)")
    }

    print(userInfo)

    completionHandler()
  }
}

Link AppDelegate to App

Add the var appDelegate to your app structure in order to link the AppDelegate to your App.

// ProjectNameApp.swift

@main
struct ProjectNameApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

Run your app

Now, build and run (⌘ + R) you app. When you build your app and run it for the first time after adding the AppDelegate code above, you'll see an alert asking you for permission to send you push notifications. Click on Allow then head back to Xcode.

Note that it's best to test on a device connected to your Mac and not the Simulator, as the test notifications we'll send won't work on the Simulator.

In the console in Xcode, you'll see that a token has been printed. This token is a unique token that will allow Firebase Cloud Messaging to send a push notifications to your device. It's like an address to your device. Copy that token because we'll need it in the next step.

Send a test notification

Now, the coding part is done. Yay! Let's head back the the Firebase Console. Under Engage, click on Cloud Messaging. In the banner, click on Send your first message. It'll lead you to the Notifications Composer.

Fill in the Notification title and Notification text. You can fill in the other fields if you wish. On the right, you'll see a Send test message blue button. Click on that. In the Add an FCM registration token field, paste the token you copied from the Xcode console and click on +, then Test.

And ta-dah! Now you've just received your first push notification sent from Firebase Console! If you haven't, it can be tricky to debug and see what went wrong because you don't get any error message. Scroll down to the Debugging section below to have some leads as to why you're not receiving any notification.

If everything is working fine, you can move on to the last section of this Push notifications series to configure sending notifications for production.

Debugging

You're not receiving any notification on your device? Here are some leads as to why you can't receive your notification:

• Stop the current build, and rebuild your project again on your device.
• Make sure that your Bundle Identifier (or BundleID) in Firebase is the same as the one in your Xcode project.
• Make sure you added the APNs authentication key in Firebase. If you haven't, go to the Push Notifications Part I of this series to learn how to create one and upload it to Firebase Cloud Messaging.
• Make sure that you copied all the AppDelegate code and added the two extensions.
• You are testing on the Simulator - notifications only work on an actual device, so connect a device to your Mac and test again.
• You didn't copy the exact device token - make sure you copy the entire token and paste it in Firebase Cloud Messaging.
• Your device doesn't have an activated SIM card - make sure you have an activated SIM card in your device or that you're connected to a mobile data service to receive push notifications.
• Your Wifi network is blocking the push notifications - connect to another Wifi network or to your mobile data service in order to receive notifications.
• As per Firebase's documentation, you need to make sure you app is in Background mode - that is, make sure your app is not open nor in the foreground. After your app has launched, simply click on the Home button once.
• You can also read this article on the Firebase Blog to help you debug further.