Implementing Push Notifications: Receiving and Handling Push Messages from Services like Firebase Cloud Messaging.

Lecture: Taming the Push Notification Beast 🦁 – Receiving and Handling Push Messages from Firebase Cloud Messaging (FCM)

Alright class, settle down, settle down! Today, we’re diving headfirst into the thrilling, occasionally frustrating, but ultimately rewarding world of Push Notifications! 🚀 Specifically, we’ll be focusing on receiving and handling those delightful (or annoying, depending on your implementation) messages sent via Firebase Cloud Messaging (FCM).

Think of FCM as your friendly neighborhood messenger pigeon, but instead of a feathered friend, it’s a powerful cloud service, and instead of handwritten notes, it delivers JSON payloads directly to your users’ devices.

Why bother with Push Notifications, you ask? 🤨 Well, imagine trying to run a restaurant 🍽️ and only relying on customers stumbling upon your location by accident. Push notifications are your digital waiter, tapping customers on the shoulder and saying, "Hey, Chef made a killer new dish! Come check it out!" They’re crucial for:

Re-engagement: Bringing users back to your app, even when they’ve forgotten you exist. (We’ve all been there, right? 🙋)
Timely Information: Delivering critical updates, like breaking news 📰, appointment reminders 📅, or that suspiciously low bank balance alert 💸.
Personalized Experiences: Tailoring content based on user preferences and behavior, making them feel like you actually know them (in a non-creepy way, of course). 🕵️‍♀️

So, let’s get started!

I. Setting the Stage: FCM Fundamentals 🎭

Before we unleash the notification Kraken, let’s recap some essential FCM concepts:

Concept	Description	Analogy
FCM Server	The brain of the operation. It’s responsible for sending push messages to the correct devices. Think of it as Firebase’s very own mailroom.	The Post Office 🏢
Client App	Your mobile application (Android, iOS, Web). It’s the recipient of the push notification. It’s the user’s mailbox.	Your Mailbox 📮
Registration Token	A unique identifier assigned to each instance of your app on a device. It’s like your mailbox’s address. This token is crucial for sending targeted notifications.	Your Mailbox Address 🏠
Notification Payload	The actual message you want to send. It contains the title, body, and any additional data you want to include. Think of it as the letter you’re sending.	The Letter ✉️
Message Types:	Notification Message: Sent directly to the system tray. Requires minimal client-side handling. Data Message: Delivered directly to your app code. Allows for more complex processing and customization. A combination of both is also possible.	Notification Message: A postcard that shows up directly in your mailbox. Data Message: A package delivered to your doorstep.

II. The Grand Reception: Receiving Push Notifications in Your App 🤝

Now, let’s get our hands dirty with some code! We’ll focus on Android and iOS for illustrative purposes. Remember, the specifics may vary slightly depending on the frameworks and libraries you’re using.

A. Android: Welcoming the Android Green Robot’s Mail 🤖

Setting up Firebase in your Android Project:
- Add the Firebase SDK to your build.gradle file. (Consult the Firebase documentation for the latest versions – things change faster than my coffee order in the morning! ☕)
```
dependencies {
    implementation platform('com.google.firebase:firebase-bom:LATEST_VERSION')
    implementation 'com.google.firebase:firebase-messaging'
}
```
- Add the Google Services plugin to your build.gradle (project level):
```
plugins {
    id 'com.google.gms.google-services' version 'LATEST_VERSION' apply false
}
```
- Apply the plugin in your build.gradle (app level)
```
plugins {
    id 'com.google.gms.google-services'
}
```
- Download the google-services.json file from your Firebase project and place it in the app directory of your Android project. This file configures your app to use Firebase.

Creating a Firebase Messaging Service:

Extend FirebaseMessagingService to handle incoming messages. This is where the magic happens! ✨

import com.google.firebase.messaging.FirebaseMessagingService;
import com.google.firebase.messaging.RemoteMessage;

public class MyFirebaseMessagingService extends FirebaseMessagingService {

    private static final String TAG = "MyFirebaseMsgService";

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        // Handle FCM messages here.
        // Not getting messages here? See why this may be: https://goo.gl/39BvDC
        Log.d(TAG, "From: " + remoteMessage.getFrom());

        // Check if message contains a data payload.
        if (remoteMessage.getData().size() > 0) {
            Log.d(TAG, "Message data payload: " + remoteMessage.getData());
            // Handle data payload here (e.g., launch an activity, update UI)
            handleDataPayload(remoteMessage.getData());
        }

        // Check if message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            Log.d(TAG, "Message Notification Body: " + remoteMessage.getNotification().getBody());
            // Handle notification payload here (e.g., display notification)
            sendNotification(remoteMessage.getNotification().getTitle(), remoteMessage.getNotification().getBody());
        }

    }

    @Override
    public void onNewToken(String token) {
        Log.d(TAG, "Refreshed token: " + token);

        // If you want to send messages to this application instance or
        // manage this apps subscriptions on the server side, send the
        // FCM registration token to your app server.
        sendRegistrationToServer(token);
    }

    private void sendRegistrationToServer(String token) {
        // TODO: Implement this method to send token to your app server.
        //  (e.g., using Retrofit, Volley, etc.)
        Log.d(TAG, "Sending registration token to server: " + token);
    }

    private void handleDataPayload(Map<String, String> data) {
        // TODO: Handle data payload here.  This could involve updating the UI,
        // launching an activity, or performing other tasks.
        String customData = data.get("custom_data");
        Log.d(TAG, "Custom Data: " + customData);
    }

    private void sendNotification(String title, String messageBody) {
        Intent intent = new Intent(this, MainActivity.class); // Replace MainActivity with your desired activity
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
                PendingIntent.FLAG_IMMUTABLE);

        String channelId = getString(R.string.default_notification_channel_id);
        Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder notificationBuilder =
                new NotificationCompat.Builder(this, channelId)
                        .setSmallIcon(R.drawable.ic_stat_ic_notification) // Replace with your notification icon
                        .setContentTitle(title)
                        .setContentText(messageBody)
                        .setAutoCancel(true)
                        .setSound(defaultSoundUri)
                        .setContentIntent(pendingIntent);

        NotificationManager notificationManager =
                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

        // Since android Oreo notification channel is needed.
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(channelId,
                    "Channel human readable title",
                    NotificationManager.IMPORTANCE_DEFAULT);
            notificationManager.createNotificationChannel(channel);
        }

        notificationManager.notify(0 /* ID of notification */, notificationBuilder.build());
    }
}

Registering the Service in the Manifest:

Declare your service in your AndroidManifest.xml file:

<service
    android:name=".MyFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

Requesting Notification Permissions (Android 13 and Above):

Android 13 introduced runtime permission requests for sending notifications. You’ll need to explicitly ask the user for permission. Failure to do so will result in your notifications being silently blocked.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
   if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
       ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.POST_NOTIFICATIONS}, PERMISSION_REQUEST_CODE);
   }
}

Obtaining the Registration Token:

Use FirebaseMessaging.getInstance().getToken() to retrieve the registration token. Send this token to your server so you can target notifications to specific devices.

FirebaseMessaging.getInstance().getToken()
        .addOnCompleteListener(new OnCompleteListener<String>() {
            @Override
            public void onComplete(@NonNull Task<String> task) {
                if (!task.isSuccessful()) {
                    Log.w(TAG, "Fetching FCM registration token failed", task.getException());
                    return;
                }

                // Get new FCM registration token
                String token = task.getResult();

                // Log and toast
                String msg = "FCM Token: " + token;
                Log.d(TAG, msg);
                Toast.makeText(MainActivity.this, msg, Toast.LENGTH_SHORT).show();
            }
        });

B. iOS: Embracing Apple’s Orchard of Notifications 🍎

Setting up Firebase in your iOS Project:
- Add the Firebase SDK to your project using CocoaPods or Swift Package Manager. Again, refer to the official Firebase documentation for the most up-to-date instructions.
```
pod 'Firebase/Messaging'
```
Enabling Push Notifications Capability:
- In Xcode, enable the "Push Notifications" capability for your target. This is essential! 🔑
Configuring APNs (Apple Push Notification Service):
- Obtain an APNs certificate or key from your Apple Developer account. This certificate authorizes Firebase to send notifications on your behalf. This process can be a bit… involved. Think of it as proving to Apple that you’re worthy of sending their precious notifications. 👑

Registering for Remote Notifications:

In your AppDelegate, register for remote notifications:

import UIKit
import FirebaseCore
import FirebaseMessaging

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, MessagingDelegate, UNUserNotificationCenterDelegate {

    var window: UIWindow?

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

        Messaging.serviceDelegate = self

        UNUserNotificationCenter.current().delegate = self

        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        UNUserNotificationCenter.current().requestAuthorization(
            options: authOptions,
            completionHandler: { _, _ in }
        )

        application.registerForRemoteNotifications()

        return true
    }

    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        Messaging.messaging().apnsToken = deviceToken
    }

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

    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
        print("Firebase registration token: (fcmToken)")

        let dataDict: [String: String] = ["token": fcmToken ?? ""]
        NotificationCenter.default.post(
            name: Notification.Name("FCMToken"),
            object: nil,
            userInfo: dataDict
        )
        // TODO: If necessary send token to application server.
        // Note: This callback is fired at each app startup and whenever a new token is generated.
    }

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

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print message ID.
      if let messageID = userInfo["gcm.message_id"] {
        print("Message ID: (messageID)")
      }

      // Print full message.
      print(userInfo)

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

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

      // Print message ID.
      if let messageID = userInfo["gcm.message_id"] {
        print("Message ID: (messageID)")
      }

      // With swizzling disabled you must let Messaging know about the message, for Analytics
      // Messaging.messaging().appDidReceiveMessage(userInfo)

      // Print full message.
      print(userInfo)

      completionHandler()
    }

}

Handling Incoming Messages:
- Implement the MessagingDelegate and UNUserNotificationCenterDelegate protocols to handle incoming messages and user interactions with notifications.

III. Decoding the Matrix: Handling the Payload 🕵️‍♀️

Okay, we’re receiving messages! Now, what do we do with them? This is where things get interesting. You’ll need to parse the notification payload and take appropriate action.

A. Parsing the Payload:

Accessing Data: The payload is typically a JSON object. In both Android and iOS, you’ll need to extract the relevant data using the appropriate JSON parsing techniques.
Handling Different Message Types: Remember the difference between notification and data messages? Your code should handle each type accordingly. Notification messages will automatically display in the system tray, while data messages require you to handle the display and behavior.

B. Taking Action Based on the Payload:

Displaying a Notification: (If you’re handling a data message) Use the platform-specific APIs to create and display a notification.
Launching an Activity/ViewController: You can configure the notification to launch a specific activity or view controller when the user taps on it. This is great for directing users to relevant content within your app.
Updating UI: Update the user interface with new data received in the notification. Imagine a live score app updating the score in real-time thanks to a push notification! ⚽
Performing Background Tasks: Depending on the platform and the configuration of your notification, you may be able to perform background tasks in response to a push notification. This could involve syncing data, pre-fetching content, or performing other operations.

Example: Handling a Data Message (Android)

private void handleDataPayload(Map<String, String> data) {
    String newsArticleId = data.get("article_id");
    String newsArticleTitle = data.get("article_title");

    if (newsArticleId != null && newsArticleTitle != null) {
        // Create an intent to launch the NewsArticleActivity
        Intent intent = new Intent(this, NewsArticleActivity.class);
        intent.putExtra("article_id", newsArticleId);
        intent.putExtra("article_title", newsArticleTitle);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
                PendingIntent.FLAG_IMMUTABLE);

        String channelId = getString(R.string.default_notification_channel_id);
        Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        NotificationCompat.Builder notificationBuilder =
                new NotificationCompat.Builder(this, channelId)
                        .setSmallIcon(R.drawable.ic_stat_ic_notification)
                        .setContentTitle("New Article: " + newsArticleTitle)
                        .setContentText("Tap to read the full article!")
                        .setAutoCancel(true)
                        .setSound(defaultSoundUri)
                        .setContentIntent(pendingIntent);

        NotificationManager notificationManager =
                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel channel = new NotificationChannel(channelId,
                    "News Channel",
                    NotificationManager.IMPORTANCE_DEFAULT);
            notificationManager.createNotificationChannel(channel);
        }

        notificationManager.notify(Integer.parseInt(newsArticleId) /* ID of notification */, notificationBuilder.build());
    }
}

IV. Common Pitfalls and Troubleshooting 🚧

Push notifications can be tricky! Here are some common problems and how to tackle them:

Problem	Solution	Humorous Analogy
Notifications not arriving	Double-check your Firebase setup, APNs configuration (iOS), registration token, and server-side code. Make sure you’re sending the correct payload.	You forgot to put a stamp on the letter! 📮
Registration token not being generated	Ensure Firebase is properly initialized in your app. Check your internet connection.	Your app is wandering around in the digital wilderness, searching for a signal! 📡
Incorrect notification display	Review your notification handling code. Make sure you’re parsing the payload correctly and using the appropriate platform-specific APIs.	You accidentally used Comic Sans for a formal announcement! 🤦‍♀️
User not receiving notifications	Check if the user has disabled notifications for your app. Request notification permissions correctly (especially on Android 13+). Ensure the user is logged in and the token is associated with the correct user.	The user put your app on mute! 🔇
Notifications arriving too frequently	Implement rate limiting on your server-side code to prevent overwhelming users. Consider allowing users to customize their notification preferences.	You’re spamming your users with notifications, like a telemarketer on overdrive! 📞

V. Best Practices: Notification Nirvana 🙏

To truly master push notifications, follow these best practices:

Be Relevant: Only send notifications that are valuable and relevant to the user. Don’t bombard them with irrelevant messages!
Be Timely: Deliver notifications at the right time. Consider the user’s time zone and activity patterns.
Be Personalized: Tailor notifications to individual users based on their preferences and behavior.
Be Actionable: Make it easy for users to take action in response to the notification.
Test, Test, Test! Thoroughly test your push notification implementation on different devices and platforms.
Respect User Preferences: Allow users to customize their notification settings. Provide options to disable certain types of notifications or adjust the frequency.

VI. Conclusion: You’ve Got This! 💪

Congratulations! You’ve now embarked on your journey to becoming a Push Notification Master! 🧙‍♂️ Remember, it takes practice and patience, but with the knowledge and tools we’ve covered today, you’ll be well on your way to creating engaging and effective push notification experiences for your users.

Now go forth and notify! Just, you know, don’t be annoying about it. 😉

Implementing Push Notifications: Receiving and Handling Push Messages from Services like Firebase Cloud Messaging.

Lecture: Taming the Push Notification Beast 🦁 – Receiving and Handling Push Messages from Firebase Cloud Messaging (FCM)

Comments

Leave a Reply Cancel reply