Abonnement à un Sujet dans les Notifications Push — Définition, Fonctionnement et Configuration

Qu'est-ce que l'abonnement à un sujet dans FCM

L'abonnement à un sujet est un mécanisme de livraison groupée de notifications push où les appareils s'abonnent à des canaux nommés (sujets) et reçoivent les messages envoyés à ces canaux. Chaque sujet est identifié par un nom de chaîne, comme news_sports ou weather_alerts.

Principe de fonctionnement des sujets

Lorsqu'un appareil s'abonne à un sujet, FCM ajoute son Registration Token à la liste des destinataires de ce sujet. Lors de l'envoi d'un message au sujet, FCM achemine automatiquement une copie à chaque appareil abonné. Firebase ne limite pas le nombre d'abonnements par appareil — une application peut abonner un utilisateur à des dizaines de sujets simultanément.

Sujets vs envoi individuel

Le principal avantage des sujets est l'évolutivité. Pour envoyer une notification à un million d'utilisateurs, une seule requête HTTP à FCM avec le nom du sujet suffit. Avec l'envoi individuel, il faudrait un million de requêtes ou un envoi par lot de jusqu'à 500 jetons à la fois. Les sujets simplifient également la logique serveur — il n'est pas nécessaire de stocker des listes de jetons pour chaque catégorie.

Exemples d'utilisation des sujets

L'abonnement à un sujet est largement utilisé dans les applications d'actualités pour la catégorisation du contenu — s'abonner aux sujets « Sports », « Politique », « Technologie » permet de délivrer des notifications pertinentes. Dans l'e-commerce, les sujets sont utilisés pour les notifications concernant les remises dans des catégories de produits spécifiques. Dans les messageries et les réseaux sociaux, les sujets sont utilisés pour les notifications d'événements dans les groupes.

Limitations et quotas FCM

Firebase impose des restrictions sur le travail avec les sujets. Une seule application peut avoir jusqu'à 2000 sujets. Chaque appareil peut s'abonner à 2000 sujets maximum. La fréquence des opérations d'abonnement/résiliation est également limitée — 3000 opérations maximum par minute par projet. Le dépassement de ces limites entraîne un blocage temporaire. Pour les projets avec un grand nombre de sujets, il est recommandé d'utiliser des conditions plutôt que des sujets — FCM prend en charge les expressions logiques pour le ciblage.

Comment fonctionne l'abonnement à un sujet

Le processus d'abonnement à un sujet comprend trois étapes : initialisation de l'abonnement sur le client, inscription dans l'infrastructure FCM et confirmation de l'opération. Après un abonnement réussi, l'appareil commence à recevoir les messages envoyés à ce sujet.

Cycle de vie de l'abonnement

Lorsque le client appelle la méthode subscribeToTopic(), le SDK Firebase envoie une requête aux serveurs FCM. Le serveur valide l'opération et ajoute le jeton de l'appareil à la liste des abonnés du sujet. FCM renvoie au client une confirmation d'abonnement réussi. À partir de ce moment, tous les messages envoyés à ce sujet seront livrés à l'appareil.

Création automatique du sujet

Il n'est pas nécessaire de créer un sujet à l'avance dans la console Firebase. Lorsque le premier appareil s'abonne à un sujet nommé news_promo, FCM le crée automatiquement. Si le dernier appareil se désabonne, le sujet reste dans le système mais inactif, et reprend son fonctionnement lorsqu'un nouvel abonnement se produit.

Abonnement à un sujet sur Android

Sur Android, l'abonnement et la résiliation aux sujets s'effectuent via le SDK FirebaseMessaging. Les méthodes subscribeToTopic() et unsubscribeFromTopic() acceptent le nom du sujet comme paramètre. Les opérations sont asynchrones et nécessitent un traitement du résultat.

Abonnement de base à un sujet

Pour s'abonner, il suffit d'appeler subscribeToTopic() avec le nom du sujet cible. Le SDK Firebase gère automatiquement les requêtes réseau et les tentatives en cas d'échec. Il est recommandé de s'abonner aux sujets après avoir obtenu avec succès un Registration Token.

class TopicSubscriber(private val context: Context) {

    fun subscribeToNewsTopic() {
        FirebaseMessaging.getInstance()
            .subscribeToTopic("news_latest")
            .addOnCompleteListener { task ->
                val msg = if (task.isSuccessful) {
                    "Subscribed to news topic"
                } else {
                    "Subscription failed"
                }
                Log.d("FCM", msg)
            }
    }

    fun unsubscribeFromNewsTopic() {
        FirebaseMessaging.getInstance()
            .unsubscribeFromTopic("news_latest")
            .addOnCompleteListener { task ->
                Log.d("FCM", "Désabonné : ${task.isSuccessful}")
            }
    }
}

Gestion des abonnements multiples

Dans les applications réelles, un utilisateur peut s'abonner à plusieurs catégories. Pour une gestion pratique, créez une classe gestionnaire qui synchronise l'état des abonnements avec le serveur. Lorsqu'un utilisateur se connecte, restaurez ses abonnements à partir de son profil.

class SubscriptionManager(private val context: Context) {

    private val fcm = FirebaseMessaging.getInstance()

    suspend fun syncSubscriptions(topics: List<String>) {
        topics.forEach { topic ->
            fcm.subscribeToTopic(topic).await()
        }
    }

    suspend fun removeAllSubscriptions() {
        val savedTopics = getSavedTopics()
        savedTopics.forEach { topic ->
            fcm.unsubscribeFromTopic(topic).await()
        }
    }

    private fun getSavedTopics(): List<String> {
        return listOf("news_latest", "promotions", "updates")
    }
}

Abonnement à un sujet sur iOS

Sur iOS, le processus d'abonnement à un sujet est identique à celui d'Android dans sa logique, mais utilise l'API Swift Firebase Messaging. Les méthodes subscribe et unsubscribe sont appelées sur l'instance de Messaging et sont également asynchrones.

Implémentation de l'abonnement sur iOS

Pour s'abonner à un sujet dans une application iOS, utilisez la méthode Messaging.subscribe(). Il est important d'appeler l'abonnement après l'initialisation de Firebase et l'obtention du Registration Token. Apple recommande de demander l'autorisation de notification avant de s'abonner à des sujets.

import FirebaseMessaging

class PushTopicManager {

    func subscribeToTopic(topic: String) {
        Messaging.messaging().subscribe(toTopic: topic) { error in
            if let error = error {
                Log.e("FCM", "Erreur d'abonnement : \(error)")
            } else {
                Log.d("FCM", "Abonné à \(topic)")
            }
        }
    }

    func unsubscribeFromTopic(topic: String) {
        Messaging.messaging().unsubscribe(fromTopic: topic) { error in
            if let error = error {
                Log.e("FCM", "Erreur de désabonnement : \(error)")
            }
        }
    }
}

Particularités des abonnements iOS

Sur iOS, l'abonnement à un sujet est également lié au Registration Token que Firebase reçoit d'APNs. Si le jeton APNs change (par exemple, après une restauration de l'appareil), Firebase transfère automatiquement les abonnements vers le nouveau jeton. Cependant, dans de rares cas, un réabonnement peut être nécessaire après une mise à jour du Registration Token.

Gestion des abonnements depuis le serveur

La gestion côté serveur des abonnements permet d'abonner et de désabonner des appareils sans impliquer l'application cliente. C'est utile pour l'administration, les tests A/B et la gestion des abonnements côté backend.

API HTTP FCM pour la gestion des abonnements

Firebase fournit une API REST pour la gestion de masse des abonnements. Le point de terminaison /v1/projects/{project_id}/subscriptions permet d'abonner jusqu'à 1000 appareils en une seule requête. L'API utilise les Registration Tokens des appareils pour l'identification.

const admin = require("firebase-admin")

async function subscribeUsersToTopic(tokens, topic) {
    try {
        const response = await admin
            .messaging()
            .subscribeToTopic(tokens, topic)
        Log.info(`Success: ${response.successCount}`)
        Log.info(`Failures: ${response.failureCount}`)
    } catch (error) {
        Log.error("Erreur d'abonnement", error)
    }
}

Scénarios d'utilisation de la gestion serveur

La gestion des abonnements côté serveur est utilisée dans plusieurs scénarios. Lors de l'inscription d'un utilisateur, le serveur l'abonne automatiquement aux sujets de base. Lorsque les préférences changent dans la version web, le serveur synchronise les abonnements sur l'appareil mobile. Les administrateurs peuvent abonner des appareils de test à des sujets internes pour le débogage. Pour les opérations de masse, FCM fournit la méthode Instance Group, qui permet de gérer les abonnements d'un groupe d'appareils via un seul identifiant de groupe.

Surveillance de l'état des abonnements

Firebase ne fournit pas d'API intégrée pour vérifier les abonnements actuels d'un appareil. Il est recommandé aux développeurs de maintenir leur propre base de données d'abonnements côté serveur. À chaque lancement de l'application, le client synchronise ses abonnements avec le serveur en envoyant la liste des sujets actifs. Cela permet d'identifier la désynchronisation et de restaurer les abonnements si nécessaire. Pour l'audit, utilisez les logs Firebase Cloud Functions — chaque opération d'abonnement/résiliation peut être journalisée.