Messagerie thématique sur Android

Basé sur le modèle de publication/abonnement, la messagerie de sujets FCM vous permet d'envoyer un message à plusieurs appareils qui ont activé un sujet particulier. Vous composez des messages de sujet selon vos besoins, et FCM gère le routage et la diffusion fiable du message aux bons appareils.

Par exemple, les utilisateurs d'une application de prévision des marées locales peuvent activer un sujet "Alertes de courants de marée" et recevoir des notifications sur les conditions optimales de pêche en eau salée dans des zones spécifiées. Les utilisateurs d'une application de sport peuvent s'abonner à des mises à jour automatiques des scores des matchs en direct pour leurs équipes préférées.

Voici quelques points à retenir concernant les sujets:

  • Les messages de type "Thème" sont particulièrement adaptés aux contenus tels que la météo ou d'autres informations disponibles publiquement.
  • Les messages de discussion sont optimisés pour le débit plutôt que pour la latence. Pour une diffusion rapide et sécurisée sur des appareils uniques ou de petits groupes d'appareils, ciblez les messages sur les jetons d'enregistrement, et non sur les sujets.
  • Si vous devez envoyer des messages à plusieurs appareils par utilisateur, envisagez d'utiliser la messagerie de groupe d'appareils pour ces cas d'utilisation.
  • La messagerie par sujet accepte un nombre illimité d'abonnements pour chaque sujet. Toutefois, FCM applique des limites dans les domaines suivants :
    • Une instance d'application ne peut pas être abonnée à plus de 2 000 thèmes.
    • Si vous utilisez l'importation par lot pour abonner des instances d'application, chaque requête est limitée à 1 000 instances d'application.
    • La fréquence des nouveaux abonnements est limitée par projet. Si vous envoyez trop de requêtes d'abonnement en peu de temps, les serveurs FCM renvoient une réponse 429 RESOURCE_EXHAUSTED ("quota dépassé"). Réessayez avec un intervalle exponentiel entre les tentatives.

Abonner l'application cliente à un sujet

Les applications clientes peuvent s'abonner à n'importe quel sujet existant ou en créer un. Lorsqu'une application cliente s'abonne à un nouveau nom de topic (qui n'existe pas encore pour votre projet Firebase), un nouveau topic de ce nom est créé dans FCM et tout client peut ensuite s'y abonner.

Pour s'abonner à un sujet, l'application cliente appelle Firebase Cloud Messaging subscribeToTopic() avec le nom du sujet FCM. Cette méthode renvoie un Task, qui peut être utilisé par un écouteur de fin pour déterminer si l'abonnement a réussi:

Kotlin

Firebase.messaging.subscribeToTopic("weather")
    .addOnCompleteListener { task ->
        var msg = "Subscribed"
        if (!task.isSuccessful) {
            msg = "Subscribe failed"
        }
        Log.d(TAG, msg)
        Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
    }

Java

FirebaseMessaging.getInstance().subscribeToTopic("weather")
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                String msg = "Subscribed";
                if (!task.isSuccessful()) {
                    msg = "Subscribe failed";
                }
                Log.d(TAG, msg);
                Toast.makeText(MainActivity.this, msg, Toast.LENGTH_SHORT).show();
            }
        });

Pour se désabonner, l'application cliente appelle Firebase Cloud Messaging unsubscribeFromTopic() avec le nom du sujet.

Gérer les abonnements aux sujets sur le serveur

Firebase Admin SDK vous permet d'effectuer des tâches de gestion de base des sujets côté serveur. Vous pouvez vous abonner et vous désabonner de manière groupée aux instances d'application cliente à l'aide de la logique de serveur en fonction de leur ou de leurs jetons d'enregistrement.

Vous pouvez abonner des instances d'application cliente à n'importe quel sujet existant ou en créer un. Lorsque vous utilisez l'API pour abonner une application cliente à un nouveau thème (qui n'existe pas encore pour votre projet Firebase), un nouveau thème de ce nom est créé dans FCM et tout client peut ensuite s'y abonner.

Vous pouvez transmettre une liste de jetons d'enregistrement à la méthode d'abonnement Firebase Admin SDK pour abonner les appareils correspondants à un sujet:

Node.js

// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'YOUR_REGISTRATION_TOKEN_1',
  // ...
  'YOUR_REGISTRATION_TOKEN_n'
];

// Subscribe the devices corresponding to the registration tokens to the
// topic.
getMessaging().subscribeToTopic(registrationTokens, topic)
  .then((response) => {
    // See the MessagingTopicManagementResponse reference documentation
    // for the contents of response.
    console.log('Successfully subscribed to topic:', response);
  })
  .catch((error) => {
    console.log('Error subscribing to topic:', error);
  });

Java

// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n"
);

// Subscribe the devices corresponding to the registration tokens to the
// topic.
TopicManagementResponse response = FirebaseMessaging.getInstance().subscribeToTopic(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " tokens were subscribed successfully");

Python

# These registration tokens come from the client FCM SDKs.
registration_tokens = [
    'YOUR_REGISTRATION_TOKEN_1',
    # ...
    'YOUR_REGISTRATION_TOKEN_n',
]

# Subscribe the devices corresponding to the registration tokens to the
# topic.
response = messaging.subscribe_to_topic(registration_tokens, topic)
# See the TopicManagementResponse reference documentation
# for the contents of response.
print(response.success_count, 'tokens were subscribed successfully')

Go

// These registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}

// Subscribe the devices corresponding to the registration tokens to the
// topic.
response, err := client.SubscribeToTopic(ctx, registrationTokens, topic)
if err != nil {
	log.Fatalln(err)
}
// See the TopicManagementResponse reference documentation
// for the contents of response.
fmt.Println(response.SuccessCount, "tokens were subscribed successfully")

C#

// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};

// Subscribe the devices corresponding to the registration tokens to the
// topic
var response = await FirebaseMessaging.DefaultInstance.SubscribeToTopicAsync(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} tokens were subscribed successfully");

L'API FCM Admin vous permet également de désabonner des appareils d'un sujet en transmettant des jetons d'enregistrement à la méthode appropriée:

Node.js

// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'YOUR_REGISTRATION_TOKEN_1',
  // ...
  'YOUR_REGISTRATION_TOKEN_n'
];

// Unsubscribe the devices corresponding to the registration tokens from
// the topic.
getMessaging().unsubscribeFromTopic(registrationTokens, topic)
  .then((response) => {
    // See the MessagingTopicManagementResponse reference documentation
    // for the contents of response.
    console.log('Successfully unsubscribed from topic:', response);
  })
  .catch((error) => {
    console.log('Error unsubscribing from topic:', error);
  });

Java

// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n"
);

// Unsubscribe the devices corresponding to the registration tokens from
// the topic.
TopicManagementResponse response = FirebaseMessaging.getInstance().unsubscribeFromTopic(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " tokens were unsubscribed successfully");

Python

# These registration tokens come from the client FCM SDKs.
registration_tokens = [
    'YOUR_REGISTRATION_TOKEN_1',
    # ...
    'YOUR_REGISTRATION_TOKEN_n',
]

# Unubscribe the devices corresponding to the registration tokens from the
# topic.
response = messaging.unsubscribe_from_topic(registration_tokens, topic)
# See the TopicManagementResponse reference documentation
# for the contents of response.
print(response.success_count, 'tokens were unsubscribed successfully')

Go

// These registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}

// Unsubscribe the devices corresponding to the registration tokens from
// the topic.
response, err := client.UnsubscribeFromTopic(ctx, registrationTokens, topic)
if err != nil {
	log.Fatalln(err)
}
// See the TopicManagementResponse reference documentation
// for the contents of response.
fmt.Println(response.SuccessCount, "tokens were unsubscribed successfully")

C#

// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};

// Unsubscribe the devices corresponding to the registration tokens from the
// topic
var response = await FirebaseMessaging.DefaultInstance.UnsubscribeFromTopicAsync(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} tokens were unsubscribed successfully");

Les méthodes subscribeToTopic() et unsubscribeFromTopic() génèrent un objet contenant la réponse de FCM. Le type de retour a le même format, quel que soit le nombre de jetons d'enregistrement spécifiés dans la requête.

En cas d'erreur (échec de l'authentification, jeton ou sujet non valide, etc.), ces méthodes génèrent une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez la section Erreurs de l'API FCM pour les administrateurs.

Recevoir et gérer les messages de discussion

FCM distribue les messages de sujet de la même manière que les autres messages en aval.

Pour recevoir des messages, utilisez un service qui étend FirebaseMessagingService. Votre service doit remplacer les rappels onMessageReceived et onDeletedMessages.

La période de traitement d'un message peut être inférieure à 20 secondes en fonction des retards subis avant l'appel de onMessageReceived, y compris les retards de l'OS, le temps de démarrage de l'application, le thread principal bloqué par d'autres opérations ou les appels onMessageReceived précédents prenant trop de temps. Passé ce délai, divers comportements de l'OS, tels que l'arrêt du processus d'Android ou les limites d'exécution en arrière-plan d'Android O, peuvent vous empêcher de terminer votre travail.

onMessageReceived est fourni pour la plupart des types de messages, à quelques exceptions près:

  • Messages de notification envoyés lorsque votre application est en arrière-plan Dans ce cas, la notification est envoyée à la barre d'état système de l'appareil. Lorsqu'un utilisateur appuie sur une notification, le lanceur d'applications s'ouvre par défaut.

  • Messages contenant à la fois une notification et une charge utile de données, lorsqu'ils sont reçus en arrière-plan Dans ce cas, la notification est envoyée dans la barre d'état système de l'appareil, et la charge utile de données est envoyée dans les extras de l'intent de votre activité de lanceur.

En résumé :

État de l'application Notification Données Les deux
Premier plan onMessageReceived onMessageReceived onMessageReceived
Contexte Barre d'état système onMessageReceived Notification: barre d'état du système
Données: dans les extras de l'intent.
Pour en savoir plus sur les types de messages, consultez la section Notifications et messages de données.

Modifier le fichier manifeste de l'application

Pour utiliser FirebaseMessagingService, vous devez ajouter ce qui suit dans le fichier manifeste de votre application:

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

Nous vous recommandons également de définir des valeurs par défaut pour personnaliser l'apparence des notifications. Vous pouvez spécifier une icône et une couleur par défaut personnalisées qui sont appliquées chaque fois que des valeurs équivalentes ne sont pas définies dans la charge utile de la notification.

Ajoutez les lignes suivantes dans la balise application pour définir l'icône et la couleur par défaut personnalisées:

<!-- Set custom default icon. This is used when no icon is set for incoming notification messages.
     See README(https://goo.gl/l4GJaQ) for more. -->
<meta-data
    android:name="com.google.firebase.messaging.default_notification_icon"
    android:resource="@drawable/ic_stat_ic_notification" />
<!-- Set color used with incoming notification messages. This is used when no color is set for the incoming
     notification message. See README(https://goo.gl/6BKBk7) for more. -->
<meta-data
    android:name="com.google.firebase.messaging.default_notification_color"
    android:resource="@color/colorAccent" />

Android affiche l'icône par défaut personnalisée pour

  • Tous les messages de notification envoyés depuis l' éditeur de notifications.
  • Tout message de notification qui ne définit pas explicitement l'icône dans la charge utile de la notification.

Android utilise la couleur par défaut personnalisée pour

  • Tous les messages de notification envoyés depuis l' éditeur de notifications.
  • Tout message de notification qui ne définit pas explicitement la couleur dans la charge utile de la notification.

Si aucune icône par défaut personnalisée n'est définie et qu'aucune icône n'est définie dans la charge utile de la notification, Android affiche l'icône de l'application en blanc.

Ignorer onMessageReceived

En remplaçant la méthode FirebaseMessagingService.onMessageReceived, vous pouvez effectuer des actions en fonction de l'objet RemoteMessage reçu et obtenir les données du message:

Kotlin

override fun onMessageReceived(remoteMessage: RemoteMessage) {
    // TODO(developer): Handle FCM messages here.
    // Not getting messages here? See why this may be: https://goo.gl/39bRNJ
    Log.d(TAG, "From: ${remoteMessage.from}")

    // Check if message contains a data payload.
    if (remoteMessage.data.isNotEmpty()) {
        Log.d(TAG, "Message data payload: ${remoteMessage.data}")

        // Check if data needs to be processed by long running job
        if (needsToBeScheduled()) {
            // For long-running tasks (10 seconds or more) use WorkManager.
            scheduleJob()
        } else {
            // Handle message within 10 seconds
            handleNow()
        }
    }

    // Check if message contains a notification payload.
    remoteMessage.notification?.let {
        Log.d(TAG, "Message Notification Body: ${it.body}")
    }

    // Also if you intend on generating your own notifications as a result of a received FCM
    // message, here is where that should be initiated. See sendNotification method below.
}

Java

@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
    // TODO(developer): Handle FCM messages here.
    // Not getting messages here? See why this may be: https://goo.gl/39bRNJ
    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());

        if (/* Check if data needs to be processed by long running job */ true) {
            // For long-running tasks (10 seconds or more) use WorkManager.
            scheduleJob();
        } else {
            // Handle message within 10 seconds
            handleNow();
        }

    }

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

    // Also if you intend on generating your own notifications as a result of a received FCM
    // message, here is where that should be initiated. See sendNotification method below.
}

Ignorer onDeletedMessages

Dans certains cas, FCM peut ne pas envoyer de message. Cela se produit lorsqu'il y a trop de messages (plus de 100) en attente pour votre application sur un appareil particulier au moment de la connexion ou si l'appareil ne s'est pas connecté à FCM depuis plus d'un mois. Dans ce cas, vous pouvez recevoir un rappel vers FirebaseMessagingService.onDeletedMessages(). Lorsque l'instance de l'application reçoit ce rappel, elle doit effectuer une synchronisation complète avec votre serveur d'application. Si vous n'avez pas envoyé de message à l'application sur cet appareil au cours des quatre dernières semaines, FCM n'appellera pas onDeletedMessages().

Gérer les messages de notification dans une application en arrière-plan

Lorsque votre application est en arrière-plan, Android dirige les messages de notification vers la barre d'état système. Lorsque l'utilisateur appuie sur la notification, le lanceur d'applications s'ouvre par défaut.

Cela inclut les messages contenant à la fois une charge utile de notification et de données (et tous les messages envoyés depuis la console Notifications). Dans ce cas, la notification est envoyée dans la barre d'état système de l'appareil, et la charge utile de données est envoyée dans les extras de l'intent de votre activité de lanceur.

Pour en savoir plus sur la distribution des messages dans votre application, consultez le tableau de bord de reporting FCM, qui enregistre le nombre de messages envoyés et ouverts sur des appareils Apple et Android, ainsi que les données sur les "impressions" (notifications vues par les utilisateurs) pour les applications Android.

Créer des requêtes d'envoi

Une fois que vous avez créé un sujet, soit en abonnant des instances d'application cliente au sujet côté client, soit via l'API du serveur, vous pouvez envoyer des messages au sujet. Si vous créez des requêtes d'envoi pour FCM pour la première fois, consultez le guide sur votre environnement serveur et FCM pour obtenir des informations importantes sur le contexte et la configuration.

Dans votre logique d'envoi sur le backend, spécifiez le nom de sujet souhaité comme indiqué:

Node.js

// The topic name can be optionally prefixed with "/topics/".
const topic = 'highScores';

const message = {
  data: {
    score: '850',
    time: '2:45'
  },
  topic: topic
};

// Send a message to devices subscribed to the provided topic.
getMessaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Java

// The topic name can be optionally prefixed with "/topics/".
String topic = "highScores";

// See documentation on defining a message payload.
Message message = Message.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .setTopic(topic)
    .build();

// Send a message to the devices subscribed to the provided topic.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Python

# The topic name can be optionally prefixed with "/topics/".
topic = 'highScores'

# See documentation on defining a message payload.
message = messaging.Message(
    data={
        'score': '850',
        'time': '2:45',
    },
    topic=topic,
)

# Send a message to the devices subscribed to the provided topic.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Go

// The topic name can be optionally prefixed with "/topics/".
topic := "highScores"

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Topic: topic,
}

// Send a message to the devices subscribed to the provided topic.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

// The topic name can be optionally prefixed with "/topics/".
var topic = "highScores";

// See documentation on defining a message payload.
var message = new Message()
{
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
    Topic = topic,
};

// Send a message to the devices subscribed to the provided topic.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

REST

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
  "message":{
    "topic" : "foo-bar",
    "notification" : {
      "body" : "This is a Firebase Cloud Messaging Topic Message!",
      "title" : "FCM Message"
      }
   }
}

Commande cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
  "message": {
    "topic" : "foo-bar",
    "notification": {
      "body": "This is a Firebase Cloud Messaging Topic Message!",
      "title": "FCM Message"
    }
  }
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Pour envoyer un message à une combinaison de sujets, spécifiez une condition, qui est une expression booléenne qui spécifie les sujets cibles. Par exemple, la condition suivante envoie des messages aux appareils abonnés à TopicA et à TopicB ou TopicC:

"'TopicA' in topics && ('TopicB' in topics || 'TopicC' in topics)"

FCM évalue d'abord les conditions entre parenthèses, puis l'expression de gauche à droite. Dans l'expression ci-dessus, un utilisateur abonné à un seul sujet ne reçoit pas le message. De même, un utilisateur qui ne s'abonne pas à TopicA ne reçoit pas le message. Ces combinaisons le reçoivent:

  • TopicA et TopicB
  • TopicA et TopicC

Vous pouvez inclure jusqu'à cinq thèmes dans votre expression conditionnelle.

Pour envoyer un message à une condition:

Node.js

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
const condition = '\'stock-GOOG\' in topics || \'industry-tech\' in topics';

// See documentation on defining a message payload.
const message = {
  notification: {
    title: '$FooCorp up 1.43% on the day',
    body: '$FooCorp gained 11.80 points to close at 835.67, up 1.43% on the day.'
  },
  condition: condition
};

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
getMessaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Java

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
String condition = "'stock-GOOG' in topics || 'industry-tech' in topics";

// See documentation on defining a message payload.
Message message = Message.builder()
    .setNotification(Notification.builder()
        .setTitle("$GOOG up 1.43% on the day")
        .setBody("$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.")
        .build())
    .setCondition(condition)
    .build();

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Python

# Define a condition which will send to devices which are subscribed
# to either the Google stock or the tech industry topics.
condition = "'stock-GOOG' in topics || 'industry-tech' in topics"

# See documentation on defining a message payload.
message = messaging.Message(
    notification=messaging.Notification(
        title='$GOOG up 1.43% on the day',
        body='$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
    ),
    condition=condition,
)

# Send a message to devices subscribed to the combination of topics
# specified by the provided condition.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Go

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
condition := "'stock-GOOG' in topics || 'industry-tech' in topics"

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Condition: condition,
}

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
var condition = "'stock-GOOG' in topics || 'industry-tech' in topics";

// See documentation on defining a message payload.
var message = new Message()
{
    Notification = new Notification()
    {
        Title = "$GOOG up 1.43% on the day",
        Body = "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.",
    },
    Condition = condition,
};

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

REST

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
   "message":{
    "condition": "'dogs' in topics || 'cats' in topics",
    "notification" : {
      "body" : "This is a Firebase Cloud Messaging Topic Message!",
      "title" : "FCM Message",
    }
  }
}

Commande cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
  "notification": {
    "title": "FCM Message",
    "body": "This is a Firebase Cloud Messaging Topic Message!",
  },
  "condition": "'dogs' in topics || 'cats' in topics"
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Étapes suivantes