Chat / Android
Chat Android v4
Chat Android
Chat
Android
Home
/
Chat
/
Android
/
Notifications
This is the new Docs for Chat SDK v4 for Android. To see the previous Docs, click here.

Set up push notifications for FCM

There are two types of FCM messages: notification messages and data messages. Sendbird uses data messages, which are handled by the client app. They allow users to customize the message payload, which consists of key-value items.

The following is a set of step-by-step instructions on how to set up push notifications for FCM.

Note: See Push notifications for HMS if you want to see the instructions for HMS push notifications.


Step 1 Generate server key for FCM

The Sendbird server requires your server key to send notification requests to FCM on behalf of your server. This is required for FCM to authorize HTTP requests.

Note: If you already have your server key, skip this step and go directly to Step 2: Register server key to Sendbird Dashboard.

  1. Go to the Firebase console. If you don't have a Firebase project for a client app, create a new project.

  1. Select your project card to move to the Project Overview.

  2. Click the gear icon at the upper left corner and select Project settings.

  1. Go to Cloud Messaging > Project credentials and copy your server key.

Note: If a server key wasn't generated because the Cloud Messaging API is disabled by default, see how to enable the legacy API.

  1. Go to the General tab and select your Android app to add Firebase to. During the registration process, enter your package name, download the google-services.json file, and place it in your Android app module root directory.


Step 2 Register server key to Sendbird Dashboard

Register your server key to the Sendbird server through the dashboard as follows.

  1. Sign in to your dashboard and go to Settings > Application > Notifications.

  2. Turn on Notifications and select Send when all devices are offline.

  3. Click Add credentials and register the app ID and app secret acquired at Step 1.

Note: Your server key can also be registered using our add an FCM push configuration API.


Step 3 Set up an FCM client app on your Android project

Add the following dependency for the Cloud Messaging Android library to your build.gradle file.

Note: The firebase-messaging version should be 19.0.1 or higher.

dependencies {
    // ...
​
    implementation 'com.google.firebase:firebase-messaging:23.0.1'
}

Note: To learn more about this step, refer to Firebase's Set Up a Firebase Cloud Messaging client app on Android guide. The Google FCM sample project is another helpful reference.


Step 4 Register a registration token to the Sendbird server

In order to send notification messages to a specific client app on an Android device, FCM requires an app instance's registration token which has been issued by the client app. Therefore, the Sendbird server also needs every registration token of client app instances to send notification requests to FCM on behalf of your server.

A user can have up to 20 FCM registration tokens. If a user who already has the maximum number of tokens attempts to add another one, the newest token replaces the oldest.

Upon the initialization of your app, the FCM SDK generates a unique, app-specific registration token for the client app instance on your user's device. FCM uses this registration token to determine which device to send notification messages to. After the FCM SDK has successfully generated the registration token, it is passed to the onNewToken() callback. Registration tokens must be registered to the Sendbird server by passing it as an argument to the parameter in the registerPushToken() method as in the following code.

override fun onNewToken(token: String) {
    SendbirdChat.registerPushToken(token) { status ,e ->
        if (e != null) {
            // Handle error.
        }

        if (status == PushTokenRegistrationStatus.PENDING) {
            // A token registration is pending.
            // Try registering again after a connection has been successfully established.
        }
    }
}

Note: If PushTokenRegistrationStatus.PENDING is returned through the handler, this means that your user isn't being connected to the Sendbird server when registerPushToken() is called. In this case, you must first get a pending registration token using getInstanceId(), and then register the token by calling the registerPushToken() method in the onSuccess() callback when your user has been connected to the server.

SendbirdChat.connect(USER_ID) { user, e ->
    if (e != null) {
        // Handle error.
    }

    FirebaseInstanceId.getInstance().instanceId.addOnSuccessListener(MyActivity.this) { result ->
        SendbirdChat.registerPushToken(result.token) { status, e ->
            if (e != null) {
                // Handle error.
            }

            // ...
        }
    }
}

Step 5 Handle an FCM message payload

The Sendbird server sends push notification payloads as FCM data messages, which contain notification-related data in the form of key-value pairs. Unlike notification messages, the client app needs to parse and process these data messages in order to display them as local notifications.

The following code shows how to receive a push notification payload and parse it as a local notification. The payload consists of two properties: message and sendbird. The message property is a string generated according to a notification template you set on the Sendbird Dashboard. The sendbird property is a JSON object which contains all the information about the message a user has sent. Within MyFirebaseMessagingService.kt, you can show the parsed messages to users as a notification using your custom sendNotification() method.

Note: See Firebase’s Receive messages in an Android app guide to learn more about how to implement code to receive and parse a FCM notification message, how notification messages are handled depending on the state of the receiving app, how to edit the app manifest, or how to override the onMessageReceived method.

override fun onMessageReceived(remoteMessage: RemoteMessage) {
    try {
        if (remoteMessage.getData().containsKey("sendbird")) {
            val sendbird = JSONObject(remoteMessage.getData().get("sendbird"))
            val channel = sendbird.get("channel") as JSONObject
            val channelUrl = channel["channel_url"] as String
            val messageTitle = sendbird.get("push_title") as String
            val messageBody = sendbird.get("message") as String
            // If you want to customize a notification with the received FCM message,
            // write your method like sendNotification() below.
            sendNotification(context, messageTitle, messageBody, channelUrl)
        }
    } catch (e: JSONException) {
            e.printStackTrace()
    }
}
// ...

fun sendNotification(
    context: Context,
    messageTitle: String,
    messageBody: String,
    channelUrl: String
) {
    // Implement your own way to create and show a notification containing the received FCM message.
    val notificationBuilder = NotificationCompat.Builder(context, channelUrl)
        .setSmallIcon(R.drawable.img_notification)
        .setColor(Color.parseColor("#7469C4")) // small icon background color
        .setLargeIcon(BitmapFactory.decodeResource(context.resources, R.drawable.logo_sendbird))
        .setContentTitle(messageTitle)
        .setContentText(messageBody)
        .setAutoCancel(true)
        .setSound(defaultSoundUri)
        .setPriority(Notification.PRIORITY_MAX)
        .setDefaults(Notification.DEFAULT_ALL)
        .setContentIntent(pendingIntent)
}

The following is a complete payload format of the sendbird property, which contains a set of provided key-value items. Some fields in the push notification payload can be customized in Settings > Application > Notifications on the Sendbird Dashboard. For example, push_title and push_alert are created based on the Title and Body text you set in Push notification content templates, respectively, in the Notifications menu. In order to display them in a local notification, pass push_title and push_alert of the push notification payload into the setContentTitle and setContentText methods of the NotificationCompat.Builder class, respectively. Also, the channel_unread_count field can be added into or removed from the payload in the same menu on the Sendbird Dashboard.

{
    "category": "messaging:offline_notification",
    "type": string,                         // Message type: MESG, FILE, or ADMM
    "message": string,                          // User input message
    "custom_type": string,                  // Custom message type
    "message_id": long,                      // Message ID
    "created_at": long,                      // The time that the message was created, in a 13-digit Unix milliseconds format
    "app_id": string,                            // Application's unique ID
    "unread_message_count": int,        // Total number of new messages unread by the user
    "channel": {
        "channel_url": string,          // Group channel URL
        "name": string,                      // Group channel name
        "custom_type": string,           // Custom Group channel type
        "channel_unread_count": int // Total number of unread new messages from the specific channel
    },
    "channel_type": string,             // A value of channel_type is set by the system. The value of messaging indicates a distinct group channel while group_messaging indicates a private group channel and chat indicates all other cases.
    "sender": {
        "id": string,                            // Sender's unique ID
        "name": string,                      // Sender's nickname
        "profile_url": string,           // Sender's profile image URL
        "require_auth_for_profile_image": false,
        "metadata": {}
    },
    "recipient": {
        "id": string,                            // Recipient's unique ID
        "name": string                          // Recipient's nickname
    },
    "files": [],                            // An array of data regarding the file message, such as filename
    "translations": {},                      // The items of locale:translation.
    "push_title": string,           // Title of a notification message that can be customized in the Sendbird Dashboard with or without variables
    "push_sound": string,           // The location of a sound file for notifications
    "audience_type": string,                // The type of audiences for notifications
    "mentioned_users": {
        "user_id": string,              // The ID of a mentioned user
        "nickname": string,         // The nickname of a mentioned user
        "profile_url": string,      // Mentioned user's profile image URL
        "require_auth_for_profile_image": false
    },
}