Implementing Push Notifications with Firebase Messaging

Push notifications are a crucial component of modern mobile applications, enabling developers to engage users with timely updates, promotions, and important information. Firebase Cloud Messaging (FCM) is a comprehensive solution provided by Google that simplifies the implementation of push notifications across various platforms. In this technical blog post, we’ll explore how to implement push notifications using Firebase Messaging in an Android application.

What is Firebase Cloud Messaging (FCM)?

Firebase Cloud Messaging (FCM) is a cross-platform messaging solution that enables you to reliably send messages at no cost. FCM allows you to notify a client app that new email or other data is available to sync. You can send notifications to drive user re-engagement and retention. For use cases such as instant messaging, FCM can transfer up to 4KB of payload to a client app to reduce network overhead.

Why Use FCM for Push Notifications?

• Reliability: Ensures messages are delivered reliably.
• Scalability: Supports sending notifications to millions of devices.
• Cost-Effective: Offers a generous free tier.
• Cross-Platform: Works seamlessly across Android, iOS, and web.

Step-by-Step Implementation Guide

Let’s walk through the process of implementing push notifications with Firebase Messaging in an Android app.

Step 1: Set Up Firebase Project

1. Go to the Firebase Console.
2. Click on “Add project” and follow the instructions to create a new Firebase project.
3. Give your project a name and click “Continue”.
4. Optionally enable Google Analytics for the project (recommended), and then click “Continue”.
5. Configure your Google Analytics settings, and then click “Create project”.

Step 2: Add Firebase to Your Android App

1. In your Firebase project, click on the Android icon to add Firebase to your Android app.
2. Enter your app’s package name (e.g., com.example.myapp).
3. Optionally add a nickname for your app.
4. Click “Register app”.
5. Download the google-services.json file and add it to the app directory of your Android project.
6. Click “Next”.

Step 3: Add Firebase SDK to Your Project

1. Open your project-level build.gradle file (build.gradle (Project: YourAppName)).
2. Add the Google Services plugin as a dependency:

dependencies {
    classpath("com.google.gms:google-services:4.4.0") // Use the latest version
}

1. Open your app-level build.gradle file (build.gradle (Module: YourAppName.app)).
2. Add the Google Services plugin and the Firebase Messaging dependency:

plugins {
    id("com.google.gms.google-services")
}

dependencies {
    implementation("com.google.firebase:firebase-messaging-ktx:23.3.1") // Use the latest version
}

1. Click “Sync Now” to sync your project with the Gradle files.

Step 4: Create a Firebase Messaging Service

Create a class that extends FirebaseMessagingService. This service will handle incoming push notifications.

import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build
import androidx.core.app.NotificationCompat
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage
import com.example.myapp.R // Replace with your app's R class

class MyFirebaseMessagingService : FirebaseMessagingService() {

    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        // Handle incoming message
        remoteMessage.notification?.let {
            showNotification(it.title, it.body)
        }
    }

    override fun onNewToken(token: String) {
        // Handle token refresh
        sendRegistrationToServer(token)
    }

    private fun showNotification(title: String?, message: String?) {
        val channelId = getString(R.string.default_notification_channel_id)
        val notificationBuilder = NotificationCompat.Builder(this, channelId)
            .setSmallIcon(R.drawable.ic_notification) // Replace with your notification icon
            .setContentTitle(title ?: "Notification")
            .setContentText(message ?: "")
            .setPriority(NotificationCompat.PRIORITY_DEFAULT)

        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        // Since Android Oreo, notification channels are needed
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(channelId,
                "Channel human readable title",
                NotificationManager.IMPORTANCE_DEFAULT)
            notificationManager.createNotificationChannel(channel)
        }

        notificationManager.notify(0, notificationBuilder.build())
    }

    private fun sendRegistrationToServer(token: String?) {
        // Send the token to your server to associate with the user
        // Implement your server-side logic here
    }
}

In this service:

• onMessageReceived: Called when the app receives a notification.
• onNewToken: Called when a new token is generated for the device.
• showNotification: Builds and displays the notification.
• sendRegistrationToServer: Sends the registration token to your server.

Step 5: Declare the Service in AndroidManifest.xml

Add the following declaration to your AndroidManifest.xml file within the <application> tag:

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

Step 6: Get the Registration Token

To send push notifications to a specific device, you need its registration token. You can retrieve the token using the following code:

import com.google.firebase.messaging.FirebaseMessaging

FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
    if (!task.isSuccessful) {
        // Handle error
        return@addOnCompleteListener
    }

    // Get new FCM registration token
    val token = task.result

    // Log and use the token
    println("FCM Registration Token: $token")
}

Step 7: Send Push Notifications

You can send push notifications using the Firebase Console or programmatically through the Firebase Admin SDK. Let’s look at both methods.

Method 1: Firebase Console

1. Go to the Firebase Console, select your project, and click on “Cloud Messaging”.
2. Click on “Send your first message”.
3. Enter the notification title and text.
4. Select your target (user segment, topic, or registration token).
5. Click “Send message”.

Method 2: Firebase Admin SDK (Server-Side)

To send notifications programmatically, you’ll need to set up the Firebase Admin SDK on your server. Here’s an example using Node.js:

const admin = require('firebase-admin');

// Initialize Firebase Admin SDK
const serviceAccount = require('./path/to/your/serviceAccountKey.json'); // Replace with your service account key

admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
});

// Send a message to the device corresponding to the provided registration token.
const message = {
  notification: {
    title: 'Hello Firebase!',
    body: 'This is a test notification from Firebase Admin SDK.',
  },
  token: 'YOUR_REGISTRATION_TOKEN', // Replace with the recipient's registration token
};

// Send the message
admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

This example:

• Initializes the Firebase Admin SDK with your service account key.
• Defines a message with a notification title and body.
• Specifies the registration token of the device to which the notification will be sent.
• Sends the message and logs the result.

Advanced Configuration

To further enhance your push notification implementation, consider the following:

• Notification Channels: For Android Oreo and above, use notification channels to categorize your notifications and allow users to customize the notification settings for each category.
• Data Messages: Use data messages to send additional data to your app. Data messages are handled in the onMessageReceived method and can be used to trigger specific actions in your app.
• Topic Messaging: Use topic messaging to send notifications to devices that have subscribed to a specific topic. This is useful for sending notifications to a group of users based on their interests.
• Conditional Logic: Implement conditional logic to handle different types of notifications based on the data received in the message payload.

Conclusion

Implementing push notifications with Firebase Cloud Messaging (FCM) is a powerful way to engage your users and deliver timely information. By following this step-by-step guide, you can seamlessly integrate FCM into your Android application. Remember to handle tokens securely and consider advanced features such as notification channels and topic messaging for a more robust implementation. Properly implemented push notifications can significantly improve user engagement and retention.