Understanding Firebase Push Notifications and Their Limitations

Background and Context

Firebase is a popular backend-as-a-service platform that provides various tools for mobile app development, including push notifications. In this article, we’ll delve into the world of Firebase push notifications, exploring their functionality, limitations, and potential issues.

When it comes to push notifications, developers often face challenges in ensuring seamless delivery of notifications to users. This can be due to various factors, such as network connectivity, device configurations, or even testing environments.

The Problem: Silent Push Notifications Don’t Trigger didReceiveRemoteNotification

The problem at hand involves sending silent push notifications from Firebase using background modes enabled for our app. We’re trying to send a receipt confirmation to the backend when a user receives this type of notification. However, we’ve encountered an unexpected issue where the application(_:didReceiveRemoteNotification:fetchCompletionHandler:) method is not being called.

Background Push Notifications and Remote Notifications

Before diving into the specifics of our problem, let’s quickly review how Firebase push notifications work:

1. Background Push Notifications: These are notifications sent by the app while it’s running in the background or even when the user has moved to another app. We can use background modes for this purpose.
2. Remote Notifications: These are notifications delivered when a new message is received from the server, and the app is either in the foreground or background.

Code: Sending Background Push Notifications

Let’s take a closer look at our code snippet:

final var apnsConfig =
                ApnsConfig.builder()
                        .setAps(Aps.builder().setContentAvailable(true).build())
                        .putAllHeaders(Map.of("apns-push-type", "background", "apns-priority", "5"))
                        .putCustomData("customDataKey", "customDataValue")
                        .build();

final var multicastMessageBuilder =
                MulticastMessage.builder()
                        .setApnsConfig(apnsConfig)
                        .addAllTokens(
                                fcmEntities.stream()
                                        .map(FcmMessageEntity::getFcmRegistrationToken)
                                        .toList());

multicastMessageBuilder.putAllData(
        Map.of(
            "notificationTitle",
            notificationTitle,
            "notificationBody",
            notificationBody));

final var batchResponse =
                FirebaseMessaging.getInstance(firebaseService.getFirebaseApp())
                        .sendEachForMulticast(multicastMessageBuilder.build());

In this snippet, we’re creating an ApnsConfig instance with custom headers and data. Then, we build a multicast message using the MulticastMessage builder and add it to our Firebase app for sending.

Testing Environment

The problem arises when testing on a simulator:

We tried disabling the FirebaseAppDelegateProxy as some search results suggested, but were unsuccessful.

Additionally, we attempted adding UNUserNotificationCenterDelegate to our AppDelegate, which led to didReceiveRemoteNotification being called only while the app was in the foreground for visible notifications.

The Solution: Understanding the Simulator’s Role

The solution lies in understanding how simulators behave when it comes to push notifications. It appears that simulators don’t trigger the application(_:didReceiveRemoteNotification:fetchCompletionHandler:) method:

final var batchResponse =
                FirebaseMessaging.getInstance(firebaseService.getFirebaseApp())
                        .sendEachForMulticast(multicastMessageBuilder.build());

Conclusion

In conclusion, push notifications are a crucial feature for mobile apps, allowing developers to deliver critical messages and updates to users. However, there are limitations and potential issues that need attention.

When it comes to silent push notifications not triggering the application(_:didReceiveRemoteNotification:fetchCompletionHandler:) method, it’s essential to consider the testing environment. In this case, simulators seem to be the culprit:

By understanding how Firebase push notifications work, developers can better navigate these challenges and create seamless experiences for their users.

Exploring Firebase Push Notification Features

Additional Background

Firebase provides various features for enhancing push notification functionality. Here are a few notable ones:

• Message IDs: We can send unique message IDs to the backend using apns-priority headers.
• Custom Data: We can add custom data to our messages using the customDataKey header.

Let’s take a closer look at how we can utilize these features in our code:

// Create an ApnsConfig instance with custom headers and data
final var apnsConfig =
                ApnsConfig.builder()
                        .setAps(Aps.builder().setContentAvailable(true).build())
                        .putAllHeaders(Map.of(
                                "apns-push-type", "background",
                                "apns-priority", "5"
                        ))
                        .putCustomData("customDataKey", "customDataValue")
                        .build();

By incorporating these features into our code, we can create more sophisticated push notification strategies and enhance the overall user experience.

Push Notification Strategies

Background and Context

Push notifications are a powerful tool for mobile apps. By understanding various strategies for delivering notifications, developers can create engaging experiences for their users.

Here are some key concepts to keep in mind:

• Background Modes: These allow our app to receive notifications while running in the background or even when the user has moved to another app.
• Remote Notifications: These are notifications delivered when a new message is received from the server, and the app is either in the foreground or background.

Code: Implementing Background Push Notification Strategies

Let’s explore how we can implement these strategies using our Firebase push notification functionality:

// Enable Background Modes for our App
// ...

// Send a Silent Background Notification
final var apnsConfig =
                ApnsConfig.builder()
                        .setAps(Aps.builder().setContentAvailable(true).build())
                        .putAllHeaders(Map.of(
                                "apns-push-type", "background",
                                "apns-priority", "5"
                        ))
                        .putCustomData("customDataKey", "customDataValue")
                        .build();

final var multicastMessageBuilder =
                MulticastMessage.builder()
                        .setApnsConfig(apnsConfig)
                        .addAllTokens(
                                fcmEntities.stream()
                                        .map(FcmMessageEntity::getFcmRegistrationToken)
                                        .toList());

In this snippet, we’re enabling background modes for our app and sending a silent background notification using the MulticastMessage builder.

Customizing Push Notifications

By customizing push notifications, developers can create more engaging experiences for their users. Here are some key concepts to keep in mind:

• Custom Data: We can add custom data to our messages using the customDataKey header.
• Notification Titles and Bodies: We can customize notification titles and bodies using the notificationTitle and notificationBody properties.

Let’s take a closer look at how we can use these features in our code:

// Create an ApnsConfig instance with custom headers and data
final var apnsConfig =
                ApnsConfig.builder()
                        .setAps(Aps.builder().setContentAvailable(true).build())
                        .putAllHeaders(Map.of(
                                "apns-push-type", "background",
                                "apns-priority", "5"
                        ))
                        .putCustomData("customDataKey", "customDataValue")
                        .build();

final var multicastMessageBuilder =
                MulticastMessage.builder()
                        .setApnsConfig(apnsConfig)
                        .addAllTokens(
                                fcmEntities.stream()
                                        .map(FcmMessageEntity::getFcmRegistrationToken)
                                        .toList())
                        .putAllData(Map.of(
                                "notificationTitle", notificationTitle,
                                "notificationBody", notificationBody
                        ));

By incorporating these features into our code, we can create more sophisticated push notification strategies and enhance the overall user experience.

Troubleshooting Push Notification Issues

Background and Context

Push notifications are a powerful tool for mobile apps. However, issues can arise when sending or receiving notifications. By understanding common pitfalls and troubleshooting techniques, developers can resolve problems quickly and efficiently.

Here are some key concepts to keep in mind:

• Server-Side Errors: These occur when errors occur on the server-side while sending or receiving notifications.
• Client-Side Errors: These occur when errors occur on the client-side while receiving notifications.

Code: Troubleshooting Server-Side Errors

Let’s explore how we can troubleshoot server-side errors using our Firebase push notification functionality:

// Catch any exceptions that may occur during message sending or receiving
try {
    // Send a background notification
    final var apnsConfig =
            ApnsConfig.builder()
                    .setAps(Aps.builder().setContentAvailable(true).build())
                    .putAllHeaders(Map.of(
                            "apns-push-type", "background",
                            "apns-priority", "5"
                    ))
                    .putCustomData("customDataKey", "customDataValue")
                    .build();

    final var multicastMessageBuilder =
            MulticastMessage.builder()
                    .setApnsConfig(apnsConfig)
                    .addAllTokens(
                            fcmEntities.stream()
                                    .map(FcmMessageEntity::getFcmRegistrationToken)
                                    .toList());
} catch (Exception e) {
    // Handle any exceptions that may occur
    Log.d("Error", "Server-side error occurred");
}

In this snippet, we’re catching any exceptions that may occur during message sending or receiving and logging the error.

Conclusion

Push notifications are a powerful tool for mobile apps. By understanding various strategies for delivering notifications, developers can create engaging experiences for their users.

By troubleshooting common pitfalls and incorporating best practices into our code, we can resolve issues quickly and efficiently. Whether it’s server-side errors or customizing push notifications, there are numerous techniques to explore when working with Firebase push notification functionality.

Let’s continue exploring the world of mobile app development and discover even more exciting opportunities for creating engaging experiences using push notifications!

Last modified on 2023-12-02