Set up push notifications for FCM

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

class MyFirebaseMessagingService : SendbirdPushHandler() {
    // This is invoked when a notification message has been delivered to the current user's client app.
    override fun onMessageReceived(context: Context, remoteMessage: RemoteMessage) {
        try {
            val pushTitle = remoteMessage.data["push_title"]
            val message = remoteMessage.data["message"]
            val payload = remoteMessage.data["sendbird"] ?: return
            val sendbirdJson = JSONObject(payload)
            val channelJson = sendbirdJson.getJSONObject("channel")
            val channelUrl = channelJson.getString("channel_url")

            // If you want to customize a notification with the received FCM message,
            // write your method like sendNotification() below.
            sendNotification(context, pushTitle, message, channelUrl)
        } catch (e: JSONException) {
            e.printStackTrace()
        }
    }

    override fun onNewToken(newToken: String?) {
        pushToken = newToken
    }

    override val isUniquePushToken: Boolean
        get() = false

    // The alwaysReceiveMessage() method determines whether push notifications for new messages
    // are delivered even when the app is in foreground.
    // The default is false, meaning push notifications are delivered
    // only when the app is in the background.
    override fun alwaysReceiveMessage(): Boolean {
        return false
    }

    fun sendNotification(context: Context, messageTitle: String?, messageBody: String?, channelUrl: String) {
        // Customize your notification containing the received FCM message.
    }

    companion object {
        var pushToken: String? = null
        fun getPushToken(callback: ((pushToken: String?, e: SendbirdException?) -> Unit)) {
            if (!pushToken.isNullOrEmpty()) {
                callback(pushToken, null)
                return
            }

            SendbirdPushHelper.getPushToken { token, e ->
                if (token != null) {
                    pushToken = token
                }
                callback(pushToken, e)
            }
        }
    }
}

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        SendbirdChat.init(
            InitParams(APP_ID, applicationContext, true),
            object : InitResultHandler {
                override fun onMigrationStarted() {}
                override fun onInitFailed(e: SendbirdException) {}
                override fun onInitSucceed() {}
            }
        )
        // Not dependent on SendbirdChat.init(). Must be called in Application.
        SendbirdPushHelper.registerPushHandler(MyFirebaseMessagingService())
    }
}

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

    SendbirdPushHelper.registerPushHandler(MyFirebaseMessagingService())
}

SendbirdPushHelper.unregisterPushHandler(
    IS_UNREGISTER_ALL,
    object : SendbirdPushHelper.OnPushRequestCompleteListener {
        override fun onComplete(isRegistered: Boolean, token: String?) {
            SendbirdChat.disconnect {
                // Clear user-related data.
            }
        }

        override fun onError(e: SendbirdException) {
            // Handle error.
        }
    }
)

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)
}

{
    "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 the value of 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 on the Sendbird Dashboard with or without variables
    "push_alert": string,           // Body text of a notification message that can be customized on 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
    }
}