À l'aide des protocoles de serveur d'applications Firebase SDK ou FCM, vous pouvez créer des demandes de message et les envoyer aux types de cibles suivants :
- Nom du sujet
- Condition
- Jeton d'enregistrement de l'appareil
- Nom du groupe de périphériques (protocole uniquement)
Vous pouvez envoyer des messages avec une charge utile de notification composée de champs prédéfinis, une charge utile de données de vos propres champs définis par l'utilisateur ou un message contenant les deux types de charge utile. Voir Types de messages pour plus d'informations.
Les exemples de cette page montrent comment envoyer des messages de notification à l'aide du SDK Firebase Admin (qui prend en charge Node , Java , Python , C# et Go ) et le protocole HTTP v1 . Il existe également des conseils pour l'envoi de messages via les anciens protocoles HTTP et XMPP obsolètes .
Envoyer des messages à des appareils spécifiques
Pour envoyer à un seul appareil spécifique, transmettez le jeton d'enregistrement de l'appareil comme indiqué. Consultez les informations de configuration du client pour votre plate-forme pour en savoir plus sur les jetons d'enregistrement.
Node.js
// This registration token comes from the client FCM SDKs.
const registrationToken = 'YOUR_REGISTRATION_TOKEN';
const message = {
data: {
score: '850',
time: '2:45'
},
token: registrationToken
};
// Send a message to the device corresponding to the provided
// registration token.
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
// This registration token comes from the client FCM SDKs.
String registrationToken = "YOUR_REGISTRATION_TOKEN";
// See documentation on defining a message payload.
Message message = Message.builder()
.putData("score", "850")
.putData("time", "2:45")
.setToken(registrationToken)
.build();
// Send a message to the device corresponding to the provided
// registration token.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);
Python
# This registration token comes from the client FCM SDKs.
registration_token = 'YOUR_REGISTRATION_TOKEN'
# See documentation on defining a message payload.
message = messaging.Message(
data={
'score': '850',
'time': '2:45',
},
token=registration_token,
)
# Send a message to the device corresponding to the provided
# registration token.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)
Aller
// Obtain a messaging.Client from the App.
ctx := context.Background()
client, err := app.Messaging(ctx)
if err != nil {
log.Fatalf("error getting Messaging client: %v\n", err)
}
// This registration token comes from the client FCM SDKs.
registrationToken := "YOUR_REGISTRATION_TOKEN"
// See documentation on defining a message payload.
message := &messaging.Message{
Data: map[string]string{
"score": "850",
"time": "2:45",
},
Token: registrationToken,
}
// Send a message to the device corresponding to the provided
// registration token.
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#
// This registration token comes from the client FCM SDKs.
var registrationToken = "YOUR_REGISTRATION_TOKEN";
// See documentation on defining a message payload.
var message = new Message()
{
Data = new Dictionary<string, string>()
{
{ "score", "850" },
{ "time", "2:45" },
},
Token = registrationToken,
};
// Send a message to the device corresponding to the provided
// registration token.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);
REPOS
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":{
"token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...",
"notification":{
"body":"This is an FCM notification message!",
"title":"FCM Message"
}
}
}
Commande cURL :
curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
"notification":{
"title":"FCM Message",
"body":"This is an FCM Message"
},
"token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send
En cas de succès, chaque méthode d'envoi renvoie un ID de message. Le SDK Firebase Admin renvoie la chaîne d'ID au format projects/{project_id}/messages/{message_id}
. La réponse du protocole HTTP est une clé JSON unique :
{
"name":"projects/myproject-b5ae1/messages/0:1500415314455276%31bd1c9631bd1c96"
}
Envoyer des messages à plusieurs appareils
Les API Admin FCM vous permettent de multidiffuser un message à une liste de jetons d'enregistrement d'appareils. Vous pouvez spécifier jusqu'à 500 jetons d'enregistrement d'appareil par appel.
Node.js
// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
'YOUR_REGISTRATION_TOKEN_1',
// …
'YOUR_REGISTRATION_TOKEN_N',
];
const message = {
data: {score: '850', time: '2:45'},
tokens: registrationTokens,
};
getMessaging().sendMulticast(message)
.then((response) => {
console.log(response.successCount + ' messages were sent successfully');
});
Java
// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
"YOUR_REGISTRATION_TOKEN_1",
// ...
"YOUR_REGISTRATION_TOKEN_n"
);
MulticastMessage message = MulticastMessage.builder()
.putData("score", "850")
.putData("time", "2:45")
.addAllTokens(registrationTokens)
.build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");
Python
# Create a list containing up to 500 registration tokens.
# These registration tokens come from the client FCM SDKs.
registration_tokens = [
'YOUR_REGISTRATION_TOKEN_1',
# ...
'YOUR_REGISTRATION_TOKEN_N',
]
message = messaging.MulticastMessage(
data={'score': '850', 'time': '2:45'},
tokens=registration_tokens,
)
response = messaging.send_multicast(message)
# See the BatchResponse reference documentation
# for the contents of response.
print('{0} messages were sent successfully'.format(response.success_count))
Aller
// Create a list containing up to 500 registration tokens.
// This registration tokens come from the client FCM SDKs.
registrationTokens := []string{
"YOUR_REGISTRATION_TOKEN_1",
// ...
"YOUR_REGISTRATION_TOKEN_n",
}
message := &messaging.MulticastMessage{
Data: map[string]string{
"score": "850",
"time": "2:45",
},
Tokens: registrationTokens,
}
br, err := client.SendMulticast(context.Background(), message)
if err != nil {
log.Fatalln(err)
}
// See the BatchResponse reference documentation
// for the contents of response.
fmt.Printf("%d messages were sent successfully\n", br.SuccessCount)
C#
// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
"YOUR_REGISTRATION_TOKEN_1",
// ...
"YOUR_REGISTRATION_TOKEN_n",
};
var message = new MulticastMessage()
{
Tokens = registrationTokens,
Data = new Dictionary<string, string>()
{
{ "score", "850" },
{ "time", "2:45" },
},
};
var response = await FirebaseMessaging.DefaultInstance.SendEachForMulticastAsync(message);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");
La valeur de retour est une liste de jetons qui correspond à l'ordre des jetons d'entrée. Ceci est utile lorsque vous souhaitez vérifier quels jetons ont généré des erreurs.
Node.js
// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
'YOUR_REGISTRATION_TOKEN_1',
// …
'YOUR_REGISTRATION_TOKEN_N',
];
const message = {
data: {score: '850', time: '2:45'},
tokens: registrationTokens,
};
getMessaging().sendMulticast(message)
.then((response) => {
if (response.failureCount > 0) {
const failedTokens = [];
response.responses.forEach((resp, idx) => {
if (!resp.success) {
failedTokens.push(registrationTokens[idx]);
}
});
console.log('List of tokens that caused failures: ' + failedTokens);
}
});
Java
// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
"YOUR_REGISTRATION_TOKEN_1",
// ...
"YOUR_REGISTRATION_TOKEN_n"
);
MulticastMessage message = MulticastMessage.builder()
.putData("score", "850")
.putData("time", "2:45")
.addAllTokens(registrationTokens)
.build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
if (response.getFailureCount() > 0) {
List<SendResponse> responses = response.getResponses();
List<String> failedTokens = new ArrayList<>();
for (int i = 0; i < responses.size(); i++) {
if (!responses.get(i).isSuccessful()) {
// The order of responses corresponds to the order of the registration tokens.
failedTokens.add(registrationTokens.get(i));
}
}
System.out.println("List of tokens that caused failures: " + failedTokens);
}
Python
# These registration tokens come from the client FCM SDKs.
registration_tokens = [
'YOUR_REGISTRATION_TOKEN_1',
# ...
'YOUR_REGISTRATION_TOKEN_N',
]
message = messaging.MulticastMessage(
data={'score': '850', 'time': '2:45'},
tokens=registration_tokens,
)
response = messaging.send_multicast(message)
if response.failure_count > 0:
responses = response.responses
failed_tokens = []
for idx, resp in enumerate(responses):
if not resp.success:
# The order of responses corresponds to the order of the registration tokens.
failed_tokens.append(registration_tokens[idx])
print('List of tokens that caused failures: {0}'.format(failed_tokens))
Aller
// Create a list containing up to 500 registration tokens.
// This registration tokens come from the client FCM SDKs.
registrationTokens := []string{
"YOUR_REGISTRATION_TOKEN_1",
// ...
"YOUR_REGISTRATION_TOKEN_n",
}
message := &messaging.MulticastMessage{
Data: map[string]string{
"score": "850",
"time": "2:45",
},
Tokens: registrationTokens,
}
br, err := client.SendMulticast(context.Background(), message)
if err != nil {
log.Fatalln(err)
}
if br.FailureCount > 0 {
var failedTokens []string
for idx, resp := range br.Responses {
if !resp.Success {
// The order of responses corresponds to the order of the registration tokens.
failedTokens = append(failedTokens, registrationTokens[idx])
}
}
fmt.Printf("List of tokens that caused failures: %v\n", failedTokens)
}
C#
// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
"YOUR_REGISTRATION_TOKEN_1",
// ...
"YOUR_REGISTRATION_TOKEN_n",
};
var message = new MulticastMessage()
{
Tokens = registrationTokens,
Data = new Dictionary<string, string>()
{
{ "score", "850" },
{ "time", "2:45" },
},
};
var response = await FirebaseMessaging.DefaultInstance.SendEachForMulticastAsync(message);
if (response.FailureCount > 0)
{
var failedTokens = new List<string>();
for (var i = 0; i < response.Responses.Count; i++)
{
if (!response.Responses[i].IsSuccess)
{
// The order of responses corresponds to the order of the registration tokens.
failedTokens.Add(registrationTokens[i]);
}
}
Console.WriteLine($"List of tokens that caused failures: {failedTokens}");
}
Envoyer des messages aux sujets
Après avoir 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 c'est la première fois que vous créez des demandes d'envoi pour FCM, consultez le guide de votre environnement de 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 du 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)
Aller
// 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);
REPOS
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 rubriques, spécifiez une condition , qui est une expression booléenne qui spécifie les rubriques cibles. Par exemple, la condition suivante enverra des messages aux appareils abonnés à TopicA
et TopicB
ou TopicC
:
"'TopicA' in topics && ('TopicB' in topics || 'TopicC' in topics)"
FCM évalue d'abord toutes les conditions entre parenthèses, puis évalue 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 n'est pas abonné à TopicA
ne reçoit pas le message. Ces combinaisons le reçoivent :
-
TopicA
etTopicB
-
TopicA
etTopicC
Vous pouvez inclure jusqu'à cinq rubriques dans votre expression conditionnelle.
Pour envoyer à 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)
Aller
// 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);
REPOS
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
Envoyer des messages aux groupes d'appareils
Pour envoyer des messages aux groupes d'appareils, utilisez l'API HTTP v1. Si vous effectuez actuellement des envois vers des groupes d'appareils à l'aide des anciennes API d'envoi obsolètes pour HTTP ou XMPP, ou de l'une des anciennes versions du SDK d'administration Firebase pour Node.js basées sur les anciens protocoles, nous vous recommandons vivement de migrer vers HTTP v1 API à la première occasion. Les anciennes API d'envoi seront désactivées et supprimées en juin 2024.
L'envoi de messages à un groupe d'appareils est très similaire à l'envoi de messages à un appareil individuel, en utilisant la même méthode pour autoriser les demandes d'envoi . Définissez le champ token
sur la clé de notification de groupe :
REPOS
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":{
"token":"APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ",
"data":{
"hello": "This is a Firebase Cloud Messaging device group message!"
}
}
}
commande cURL
curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
"data":{
"hello": "This is a Firebase Cloud Messaging device group message!"
},
"token":"APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ"
}}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send
Envoyer un lot de messages
L'API REST et les SDK d'administration prennent en charge l'envoi de messages par lots. Vous pouvez regrouper jusqu'à 500 messages en un seul lot et les envoyer tous en un seul appel d'API, avec une amélioration significative des performances par rapport à l'envoi de requêtes HTTP distinctes pour chaque message.
Cette fonctionnalité peut être utilisée pour créer un ensemble personnalisé de messages et les envoyer à différents destinataires, y compris des rubriques ou des jetons d'enregistrement d'appareils spécifiques. Utilisez cette fonctionnalité lorsque, par exemple, vous devez envoyer simultanément des messages à différents publics avec des détails légèrement différents dans le corps du message.
Node.js
// Create a list containing up to 500 messages.
const messages = [];
messages.push({
notification: { title: 'Price drop', body: '5% off all electronics' },
token: registrationToken,
});
messages.push({
notification: { title: 'Price drop', body: '2% off all books' },
topic: 'readers-club',
});
getMessaging().sendAll(messages)
.then((response) => {
console.log(response.successCount + ' messages were sent successfully');
});
Java
// Create a list containing up to 500 messages.
List<Message> messages = Arrays.asList(
Message.builder()
.setNotification(Notification.builder()
.setTitle("Price drop")
.setBody("5% off all electronics")
.build())
.setToken(registrationToken)
.build(),
// ...
Message.builder()
.setNotification(Notification.builder()
.setTitle("Price drop")
.setBody("2% off all books")
.build())
.setTopic("readers-club")
.build()
);
BatchResponse response = FirebaseMessaging.getInstance().sendAll(messages);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");
Python
# Create a list containing up to 500 messages.
messages = [
messaging.Message(
notification=messaging.Notification('Price drop', '5% off all electronics'),
token=registration_token,
),
# ...
messaging.Message(
notification=messaging.Notification('Price drop', '2% off all books'),
topic='readers-club',
),
]
response = messaging.send_all(messages)
# See the BatchResponse reference documentation
# for the contents of response.
print('{0} messages were sent successfully'.format(response.success_count))
Aller
// Create a list containing up to 500 messages.
messages := []*messaging.Message{
{
Notification: &messaging.Notification{
Title: "Price drop",
Body: "5% off all electronics",
},
Token: registrationToken,
},
{
Notification: &messaging.Notification{
Title: "Price drop",
Body: "2% off all books",
},
Topic: "readers-club",
},
}
br, err := client.SendAll(context.Background(), messages)
if err != nil {
log.Fatalln(err)
}
// See the BatchResponse reference documentation
// for the contents of response.
fmt.Printf("%d messages were sent successfully\n", br.SuccessCount)
C#
// Create a list containing up to 500 messages.
var messages = new List<Message>()
{
new Message()
{
Notification = new Notification()
{
Title = "Price drop",
Body = "5% off all electronics",
},
Token = registrationToken,
},
new Message()
{
Notification = new Notification()
{
Title = "Price drop",
Body = "2% off all books",
},
Topic = "readers-club",
},
};
var response = await FirebaseMessaging.DefaultInstance.SendEachAsync(messages);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");
REPOS
Construisez une requête HTTP par lot en combinant une liste de sous-requêtes :
--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary
POST /v1/projects/myproject-b5ae1/messages:send
Content-Type: application/json
accept: application/json
{
"message":{
"token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...",
"notification":{
"title":"FCM Message",
"body":"This is an FCM notification message to device 0!"
}
}
}
--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary
POST /v1/projects/myproject-b5ae1/messages:send
Content-Type: application/json
accept: application/json
{
"message":{
"topic":"readers-club",
"notification":{
"title":"Price drop",
"body":"2% off all books"
}
}
}
...
--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary
POST /v1/projects/myproject-b5ae1/messages:send
Content-Type: application/json
accept: application/json
{
"message":{
"token":"cR1rjyj4_Kc:APA91bGusqbypSuMdsh7jSNrW4nzsM...",
"notification":{
"title":"FCM Message",
"body":"This is an FCM notification message to device N!"
}
}
}
--subrequest_boundary--
Vous pouvez interroger le BatchResponse
renvoyé pour vérifier combien de messages ont été transmis avec succès à FCM. Il expose également une liste de réponses qui peuvent être utilisées pour vérifier l'état des messages individuels. L'ordre des réponses correspond à l'ordre des messages dans la liste d'entrée.
Envoyer des messages activés pour le démarrage direct (Android uniquement)
Vous pouvez envoyer des messages aux appareils en mode de démarrage direct à l'aide des API HTTP v1 ou HTTP héritées. Avant d'envoyer aux périphériques en mode de démarrage direct, assurez-vous d'avoir terminé les étapes pour permettre aux périphériques clients de recevoir des messages FCM en mode de démarrage direct .
Envoyer à l'aide de l'API HTTP FCM v1
La requête de message doit inclure la clé "direct_boot_ok" : true
dans les options AndroidConfig
du corps de la requête. Par exemple:
https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send
Content-Type:application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
"message":{
"token" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
"data": {
"score": "5x1",
"time": "15:10"
},
"android": {
"direct_boot_ok": true,
},
}
Envoyer à l'aide de l'ancienne API HTTP FCM
La demande de message doit inclure la clé "direct_boot_ok" : true
au niveau supérieur du corps de la demande. Par exemple:
https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA
{ "data": {
"score": "5x1",
"time": "15:10"
},
"to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
"direct_boot_ok" : true
}
Les messages envoyés avec cette clé dans le corps de la requête peuvent être gérés par les applications sur les appareils actuellement en mode de démarrage direct (et également lorsqu'ils ne sont pas dans ce mode).
Personnalisez les messages sur toutes les plateformes
Le SDK Firebase Admin et le protocole HTTP FCM v1 permettent tous deux à vos demandes de message de définir tous les champs disponibles dans l'objet message
. Ceci comprend:
- un ensemble commun de champs à interpréter par toutes les instances d'application qui reçoivent le message.
- des ensembles de champs spécifiques à la plate-forme, tels que
AndroidConfig
etWebpushConfig
, interprétés uniquement par les instances d'application exécutées sur la plate-forme spécifiée.
Les blocs spécifiques à la plate-forme vous permettent de personnaliser les messages pour différentes plates-formes afin de vous assurer qu'ils sont correctement traités lors de leur réception. Le backend FCM prendra en compte tous les paramètres spécifiés et personnalisera le message pour chaque plate-forme.
Quand utiliser les champs communs
Utilisez des champs communs lorsque vous :
- Ciblage des instances d'application sur toutes les plates-formes : Apple, Android et Web
- Envoi de messages aux sujets
Toutes les instances d'application, quelle que soit la plate-forme, peuvent interpréter les champs communs suivants :
Quand utiliser des champs spécifiques à la plate-forme
Utilisez des champs spécifiques à la plate-forme lorsque vous souhaitez :
- Envoyer les champs uniquement à des plates-formes particulières
- Envoyer des champs spécifiques à la plateforme en plus des champs communs
Chaque fois que vous souhaitez envoyer des valeurs uniquement à des plates-formes particulières, n'utilisez pas de champs communs ; utiliser des champs spécifiques à la plate-forme. Par exemple, pour envoyer une notification uniquement aux plates-formes Apple et au Web, mais pas à Android, vous devez utiliser deux ensembles de champs distincts, un pour Apple et un pour le Web.
Lorsque vous envoyez des messages avec des options de livraison spécifiques , utilisez des champs spécifiques à la plate-forme pour les définir. Vous pouvez spécifier différentes valeurs par plate-forme si vous le souhaitez. Cependant, même lorsque vous souhaitez définir essentiellement la même valeur sur toutes les plates-formes, vous devez utiliser des champs spécifiques à la plate-forme. En effet, chaque plate-forme peut interpréter la valeur légèrement différemment. Par exemple, la durée de vie est définie sur Android comme un délai d'expiration en secondes, tandis que sur Apple, elle est définie comme une date d'expiration .
Exemple : message de notification avec options de couleur et d'icône
Cet exemple de demande d'envoi envoie un titre et un contenu de notification communs à toutes les plates-formes, mais il envoie également des remplacements spécifiques à la plate-forme aux appareils Android.
Pour Android, la requête définit une icône et une couleur spéciales à afficher sur les appareils Android. Comme indiqué dans la référence pour AndroidNotification , la couleur est spécifiée au format #rrggbb et l'image doit être une ressource d'icône dessinable locale à l'application Android.
Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :
Node.js
const topicName = 'industry-tech';
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.'
},
android: {
notification: {
icon: 'stock_ticker_update',
color: '#7e55c3'
}
},
topic: topicName,
};
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
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())
.setAndroidConfig(AndroidConfig.builder()
.setTtl(3600 * 1000)
.setNotification(AndroidNotification.builder()
.setIcon("stock_ticker_update")
.setColor("#f45342")
.build())
.build())
.setApnsConfig(ApnsConfig.builder()
.setAps(Aps.builder()
.setBadge(42)
.build())
.build())
.setTopic("industry-tech")
.build();
Python
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.',
),
android=messaging.AndroidConfig(
ttl=datetime.timedelta(seconds=3600),
priority='normal',
notification=messaging.AndroidNotification(
icon='stock_ticker_update',
color='#f45342'
),
),
apns=messaging.APNSConfig(
payload=messaging.APNSPayload(
aps=messaging.Aps(badge=42),
),
),
topic='industry-tech',
)
Aller
oneHour := time.Duration(1) * time.Hour
badge := 42
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.",
},
Android: &messaging.AndroidConfig{
TTL: &oneHour,
Notification: &messaging.AndroidNotification{
Icon: "stock_ticker_update",
Color: "#f45342",
},
},
APNS: &messaging.APNSConfig{
Payload: &messaging.APNSPayload{
Aps: &messaging.Aps{
Badge: &badge,
},
},
},
Topic: "industry-tech",
}
C#
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.",
},
Android = new AndroidConfig()
{
TimeToLive = TimeSpan.FromHours(1),
Notification = new AndroidNotification()
{
Icon = "stock_ticker_update",
Color = "#f45342",
},
},
Apns = new ApnsConfig()
{
Aps = new Aps()
{
Badge = 42,
},
},
Topic = "industry-tech",
};
REPOS
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":"industry-tech",
"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."
},
"android":{
"notification":{
"icon":"stock_ticker_update",
"color":"#7e55c3"
}
}
}
}
Consultez la documentation de référence HTTP v1 pour plus de détails sur les clés disponibles dans les blocs spécifiques à la plate-forme dans le corps du message.
Exemple : message de notification avec une image personnalisée
L'exemple de demande d'envoi suivant envoie un titre de notification commun à toutes les plates-formes, mais il envoie également une image. Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :
Node.js
const topicName = 'industry-tech';
const message = {
notification: {
title: 'Sparky says hello!'
},
android: {
notification: {
imageUrl: 'https://foo.bar.pizza-monster.png'
}
},
apns: {
payload: {
aps: {
'mutable-content': 1
}
},
fcm_options: {
image: 'https://foo.bar.pizza-monster.png'
}
},
webpush: {
headers: {
image: 'https://foo.bar.pizza-monster.png'
}
},
topic: topicName,
};
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);
});
REPOS
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":"industry-tech",
"notification":{
"title":"Sparky says hello!",
},
"android":{
"notification":{
"image":"https://foo.bar/pizza-monster.png"
}
},
"apns":{
"payload":{
"aps":{
"mutable-content":1
}
},
"fcm_options": {
"image":"https://foo.bar/pizza-monster.png"
}
},
"webpush":{
"headers":{
"image":"https://foo.bar/pizza-monster.png"
}
}
}
}
Consultez la documentation de référence HTTP v1 pour plus de détails sur les clés disponibles dans les blocs spécifiques à la plate-forme dans le corps du message.
Exemple : message de notification avec une action de clic associée
L'exemple de demande d'envoi suivant envoie un titre de notification commun à toutes les plates-formes, mais il envoie également une action que l'application doit exécuter en réponse à l'interaction de l'utilisateur avec la notification. Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :
Node.js
const topicName = 'industry-tech';
const message = {
notification: {
title: 'Breaking News....'
},
android: {
notification: {
clickAction: 'news_intent'
}
},
apns: {
payload: {
aps: {
'category': 'INVITE_CATEGORY'
}
}
},
webpush: {
fcmOptions: {
link: 'breakingnews.html'
}
},
topic: topicName,
};
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);
});
REPOS
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":"industry-tech",
"notification":{
"title":"Breaking News...",
},
"android":{
"notification":{
"click_action":"news_intent"
}
},
"apns":{
"payload":{
"aps":{
"category" : "INVITE_CATEGORY"
}
},
},
"webpush":{
"fcm_options":{
"link":"breakingnews.html"
}
}
}
}
Consultez la documentation de référence HTTP v1 pour plus de détails sur les clés disponibles dans les blocs spécifiques à la plate-forme dans le corps du message.
Exemple : message de notification avec options de localisation
L'exemple suivant de demande d'envoi envoie des options de localisation pour que le client affiche des messages localisés. Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :
Node.js
var topicName = 'industry-tech';
var message = {
android: {
ttl: 3600000,
notification: {
bodyLocKey: 'STOCK_NOTIFICATION_BODY',
bodyLocArgs: ['FooCorp', '11.80', '835.67', '1.43']
}
},
apns: {
payload: {
aps: {
alert: {
locKey: 'STOCK_NOTIFICATION_BODY',
locArgs: ['FooCorp', '11.80', '835.67', '1.43']
}
}
}
},
topic: topicName,
};
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);
});
REPOS
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":"Tech",
"android":{
"ttl":"3600s",
"notification":{
"body_loc_key": "STOCK_NOTIFICATION_BODY",
"body_loc_args": ["FooCorp", "11.80", "835.67", "1.43"],
},
},
"apns":{
"payload":{
"aps":{
"alert" : {
"loc-key": "STOCK_NOTIFICATION_BODY",
"loc-args": ["FooCorp", "11.80", "835.67", "1.43"],
},
},
},
},
},
}'
Consultez la documentation de référence HTTP v1 pour plus de détails sur les clés disponibles dans les blocs spécifiques à la plate-forme dans le corps du message.
Codes d'erreur d'administration
Le tableau suivant répertorie les codes d'erreur de l'API Firebase Admin FCM et leurs descriptions, y compris les étapes de résolution recommandées.
Code d'erreur | Description et étapes de résolution |
---|---|
messaging/invalid-argument | Un argument non valide a été fourni à une méthode FCM. Le message d'erreur doit contenir des informations supplémentaires. |
messaging/invalid-recipient | Le destinataire du message prévu n'est pas valide. Le message d'erreur doit contenir des informations supplémentaires. |
messaging/invalid-payload | Un objet de charge utile de message non valide a été fourni. Le message d'erreur doit contenir des informations supplémentaires. |
messaging/invalid-data-payload-key | La charge utile du message de données contient une clé non valide. Consultez la documentation de référence pour DataMessagePayload pour les clés restreintes. |
messaging/payload-size-limit-exceeded | La charge utile du message fournie dépasse les limites de taille FCM. La limite est de 4096 octets pour la plupart des messages. Pour les messages envoyés aux sujets, la limite est de 2048 octets. La taille totale de la charge utile inclut à la fois les clés et les valeurs. |
messaging/invalid-options | Un objet d'options de message non valide a été fourni. Le message d'erreur doit contenir des informations supplémentaires. |
messaging/invalid-registration-token | Jeton d'enregistrement non valide fourni. Assurez-vous qu'il correspond au jeton d'inscription que l'application cliente reçoit lors de son inscription auprès de FCM. Ne le tronquez pas et ne lui ajoutez pas de caractères supplémentaires. |
messaging/registration-token-not-registered | Le jeton d'enregistrement fourni n'est pas enregistré. Un jeton d'enregistrement précédemment valide peut être désenregistré pour diverses raisons, notamment :
|
messaging/invalid-package-name | Le message a été adressé à un jeton d'enregistrement dont le nom de package ne correspond pas à l'option restrictedPackageName fournie. |
messaging/message-rate-exceeded | Le taux de messages vers une cible particulière est trop élevé. Réduisez le nombre de messages envoyés à cet appareil ou à ce sujet et ne réessayez pas immédiatement d'envoyer à cette cible. |
messaging/device-message-rate-exceeded | Le taux de messages vers un appareil particulier est trop élevé. Réduisez le nombre de messages envoyés à cet appareil et ne réessayez pas immédiatement d'envoyer à cet appareil. |
messaging/topics-message-rate-exceeded | Le taux de messages aux abonnés à un sujet particulier est trop élevé. Réduisez le nombre de messages envoyés pour ce sujet et ne réessayez pas immédiatement d'envoyer à ce sujet. |
messaging/too-many-topics | Un jeton d'inscription a été abonné au nombre maximum de sujets et ne peut plus être abonné. |
messaging/invalid-apns-credentials | Un message destiné à un appareil Apple n'a pas pu être envoyé car le certificat SSL APNs requis n'a pas été téléchargé ou a expiré. Vérifiez la validité de vos certificats de développement et de production. |
messaging/mismatched-credential | Les informations d'identification utilisées pour authentifier ce SDK n'ont pas l'autorisation d'envoyer des messages à l'appareil correspondant au jeton d'enregistrement fourni. Assurez-vous que les informations d'identification et le jeton d'enregistrement appartiennent tous deux au même projet Firebase. Consultez Ajouter Firebase à votre application pour obtenir de la documentation sur l'authentification des SDK d'administration Firebase. |
messaging/authentication-error | Le SDK n'a pas pu s'authentifier auprès des serveurs FCM. Assurez-vous d'authentifier le SDK Firebase Admin avec un identifiant disposant des autorisations appropriées pour envoyer des messages FCM. Consultez Ajouter Firebase à votre application pour obtenir de la documentation sur l'authentification des SDK d'administration Firebase. |
messaging/server-unavailable | Le serveur FCM n'a pas pu traiter la demande à temps. Vous devez réessayer la même requête, mais vous devez :
|
messaging/internal-error | Le serveur FCM a rencontré une erreur lors de la tentative de traitement de la demande. Vous pouvez réessayer la même demande en suivant les exigences répertoriées dans la ligne messaging/server-unavailable ci-dessus. Si l'erreur persiste, veuillez signaler le problème à notre canal d'assistance Bug Report . |
messaging/unknown-error | Une erreur de serveur inconnue a été renvoyée. Voir la réponse brute du serveur dans le message d'erreur pour plus de détails. Si vous recevez cette erreur, veuillez signaler le message d'erreur complet à notre canal d'assistance pour les rapports de bogues . |
Envoyer des messages à l'aide des anciens protocoles de serveur d'applications
Si vous utilisez actuellement les protocoles hérités, créez des demandes de message comme indiqué dans cette section. Gardez à l'esprit que, si vous envoyez vers plusieurs plates-formes via HTTP, le protocole v1 peut grandement simplifier vos demandes de messages.
Envoyer des messages à des appareils spécifiques
Pour envoyer des messages à des appareils spécifiques, définissez to
clé sur le jeton d'enregistrement pour l'instance d'application spécifique. Consultez les informations de configuration du client pour votre plate-forme pour en savoir plus sur les jetons d'enregistrement.
Requête HTTP POST
https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA
{ "data": {
"score": "5x1",
"time": "15:10"
},
"to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}
Réponse HTTP
{ "multicast_id": 108, "success": 1, "failure": 0, "results": [ { "message_id": "1:08" } ] }
Message XMPP
<message id="">
<gcm xmlns="google:mobile:data">
{ "data": {
"score": "5x1",
"time": "15:10"
},
"to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}
</gcm>
</message>
Réponse XMPP
<message id=""> <gcm xmlns="google:mobile:data"> { "from":"REGID", "message_id":"m-1366082849205" "message_type":"ack" } </gcm> </message>
Le serveur de connexion XMPP fournit d'autres options pour les réponses. Voir Format de réponse du serveur .
Pour obtenir la liste complète des options de message disponibles lors de l'envoi de messages en aval aux applications clientes, consultez les informations de référence du protocole de serveur de connexion que vous avez choisi, HTTP ou XMPP .
Envoyer des messages aux sujets
L'envoi de messages à un sujet Firebase Cloud Messaging est très similaire à l'envoi de messages à un appareil individuel ou à un groupe d'utilisateurs. Le serveur d'application définit la clé to
avec une valeur telle que /topics/yourTopic
. Les développeurs peuvent choisir n'importe quel nom de rubrique correspondant à l'expression régulière : "/topics/[a-zA-Z0-9-_.~%]+"
.
Pour envoyer à des combinaisons de plusieurs rubriques, le serveur d'application doit définir la clé condition
(au lieu de la clé to
) sur une condition booléenne qui spécifie les rubriques cibles. Par exemple, pour envoyer des messages aux appareils abonnés à TopicA
et TopicB
ou TopicC
:
'TopicA' in topics && ('TopicB' in topics || 'TopicC' in topics)
FCM évalue d'abord toutes les conditions entre parenthèses, puis évalue 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 n'est pas abonné à TopicA ne reçoit pas le message. Ces combinaisons le reçoivent :
- SujetA et SujetB
- SujetA et SujetC
Vous pouvez inclure jusqu'à cinq rubriques dans votre expression conditionnelle et les parenthèses sont prises en charge. Opérateurs pris en charge : &&
, ||
.
Requête HTTP POST
Envoyer à un seul sujet :
https://fcm.googleapis.com/fcm/send Content-Type:application/json Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA
Envoyer aux appareils abonnés aux sujets "chiens" ou "chats" :
https://fcm.googleapis.com/fcm/send Content-Type:application/json Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA
Réponse HTTP du sujet
//Success example: { "message_id": "1023456" } //failure example: { "error": "TopicsMessageRateExceeded" }
Message XMPP du sujet
Envoyer à un seul sujet :
<message id="">
<gcm xmlns="google:mobile:data">
</gcm>
</message>
Envoyer aux appareils abonnés aux sujets "chiens" ou "chats" :
<message id=""> <gcm xmlns="google:mobile:data"> </gcm> </message>
Réponse XMPP de sujet
//Success example: { "message_id": "1023456" } //failure example: { "error": "TopicsMessageRateExceeded" }
Attendez-vous à un délai pouvant atteindre 30 secondes avant que le serveur FCM ne renvoie une réponse de réussite ou d'échec aux demandes d'envoi de rubrique. Assurez-vous de définir la valeur de délai d'attente du serveur d'application dans la demande en conséquence.
Envoyer des messages aux groupes d'appareils
L'envoi de messages à un groupe d'appareils à l'aide des anciennes API obsolètes est très similaire à l'envoi de messages à un appareil individuel. Définissez le paramètre to
sur la clé de notification unique pour le groupe de périphériques. Les exemples de cette section montrent comment envoyer des messages de données à des groupes de périphériques dans les protocoles hérités HTTP et XMPP.
Requête HTTP POST du groupe de périphériques
https://fcm.googleapis.com/fcm/send Content-Type:application/json Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA { "to": "aUniqueKey", "data": { "hello": "This is a Firebase Cloud Messaging Device Group Message!", } }
Réponse HTTP du groupe de périphériques
Voici un exemple de « succès » : la notification_key
est associée à 2 jetons d'enregistrement, et le message a été envoyé avec succès aux deux :
{ "success": 2, "failure": 0 }
Voici un exemple de "succès partiel" - la notification_key
est associée à 3 jetons d'enregistrement. Le message a été envoyé avec succès à 1 des jetons d'enregistrement uniquement. Le message de réponse répertorie les jetons d'enregistrement ( registration_ids
) qui n'ont pas reçu le message :
{ "success":1, "failure":2, "failed_registration_ids":[ "regId1", "regId2" ] }
Lorsqu'un message ne parvient pas à être remis à un ou plusieurs des jetons d'enregistrement associés à une notification_key
, le serveur d'application doit réessayer avec une interruption entre les tentatives.
Si le serveur tente d'envoyer un message à un groupe de périphériques qui n'a aucun membre, la réponse ressemble à ce qui suit, avec 0 succès et 0 échec :
{ "success": 0, "failure": 0 }
Message XMPP du groupe de périphériques
<message id=""> <gcm xmlns="google:mobile:data"> { "to": "aUniqueKey", "message_id": "m-1366082849205" , "data": { "hello":"This is a Firebase Cloud Messaging Device Group Message!" } } </gcm> </message>
Réponse XMPP du groupe de périphériques
Lorsque le message est envoyé avec succès à l'un des appareils du groupe, le serveur de connexion XMPP répond par un ACK. Si tous les messages envoyés à tous les appareils du groupe échouent, le serveur de connexion XMPP répond par un NACK.
Voici un exemple de "succès" — la notification_key
est associée à 3 jetons d'enregistrement, et le message a été envoyé avec succès à chacun d'eux :
{ "from": "aUniqueKey", "message_type": "ack", "success": 3, "failure": 0, "message_id": "m-1366082849205" }
Voici un exemple de "succès partiel" - la notification_key
est associée à 3 jetons d'enregistrement. Le message a été envoyé avec succès à 1 des jetons d'enregistrement uniquement. Le message de réponse répertorie les jetons d'enregistrement qui n'ont pas reçu le message :
{ "from": "aUniqueKey", "message_type": "ack", "success":1, "failure":2, "failed_registration_ids":[ "regId1", "regId2" ] }
Lorsque le serveur de connexion FCM ne parvient pas à livrer à tous les périphériques du groupe. Le serveur d'application recevra une réponse nack.
Pour la liste complète des options de message, consultez les informations de référence du protocole de serveur de connexion que vous avez choisi, HTTP ou XMPP .
Méthodes d'envoi héritées du SDK Firebase Admin
Le SDK Firebase Admin Node.js prend en charge les méthodes d'envoi de messages (FCM) basées sur l' ancienne API du serveur FCM . Ces méthodes acceptent des arguments différents par rapport à la méthode send()
. Vous devez utiliser la méthode send()
dans la mesure du possible et n'utiliser que les méthodes décrites dans cette page lors de l'envoi de messages à des appareils individuels ou à des groupes d'appareils.
Envoyer à des appareils individuels
Vous pouvez transmettre un jeton d'enregistrement à la méthode sendToDevice()
pour envoyer un message à cet appareil :
Node.js
// This registration token comes from the client FCM SDKs.
const registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';
// See the "Defining the message payload" section below for details
// on how to define a message payload.
const payload = {
data: {
score: '850',
time: '2:45'
}
};
// Send a message to the device corresponding to the provided
// registration token.
getMessaging().sendToDevice(registrationToken, payload)
.then((response) => {
// See the MessagingDevicesResponse reference documentation for
// the contents of response.
console.log('Successfully sent message:', response);
})
.catch((error) => {
console.log('Error sending message:', error);
});
La méthode sendToDevice()
peut également envoyer un message multicast (c'est-à-dire un message à plusieurs appareils) en transmettant un tableau de jetons d'enregistrement au lieu d'un seul jeton d'enregistrement :
Node.js
// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...',
// ...
'ecupwIfBy1w:APA91bFtuMY7MktgxA3Au_Qx7cKqnf...'
];
// See the "Defining the message payload" section below for details
// on how to define a message payload.
const payload = {
data: {
score: '850',
time: '2:45'
}
};
// Send a message to the devices corresponding to the provided
// registration tokens.
getMessaging().sendToDevice(registrationTokens, payload)
.then((response) => {
// See the MessagingDevicesResponse reference documentation for
// the contents of response.
console.log('Successfully sent message:', response);
})
.catch((error) => {
console.log('Error sending message:', error);
});
La méthode sendToDevice()
renvoie une promesse qui est résolue avec un objet MessagingDevicesResponse
contenant la réponse de FCM. Le type de retour a le même format lors de la transmission d'un seul jeton d'enregistrement ou d'un tableau de jetons d'enregistrement.
Certains cas, tels qu'une erreur d'authentification ou une limitation de débit, entraînent l'échec du traitement de l'intégralité du message. Dans ces cas, la promesse renvoyée par sendToDevice()
est rejetée avec une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Admin FCM API Errors .
Envoyer à un groupe d'appareils
La méthode sendToDeviceGroup()
vous permet d'envoyer un message à un groupe d'appareils en spécifiant la clé de notification pour ce groupe d'appareils :
Node.js
// See the "Managing device groups" link above on how to generate a
// notification key.
const notificationKey = 'some-notification-key';
// See the "Defining the message payload" section below for details
// on how to define a message payload.
const payload = {
data: {
score: '850',
time: '2:45'
}
};
// Send a message to the device group corresponding to the provided
// notification key.
getMessaging().sendToDeviceGroup(notificationKey, payload)
.then((response) => {
// See the MessagingDeviceGroupResponse reference documentation for
// the contents of response.
console.log('Successfully sent message:', response);
})
.catch((error) => {
console.log('Error sending message:', error);
});
La méthode sendToDeviceGroup()
renvoie une promesse qui est résolue avec un objet MessagingDevicesResponse
contenant la réponse de FCM.
Certains cas, tels qu'une erreur d'authentification ou une limitation de débit, entraînent l'échec du traitement de l'intégralité du message. Dans ces cas, la promesse renvoyée par sendToDeviceGroup()
est rejetée avec une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Admin FCM API Errors .
Définition de la charge utile du message
Les méthodes ci-dessus basées sur les anciens protocoles FCM acceptent une charge utile de message comme deuxième argument et prennent en charge à la fois les messages de notification et de données . Vous pouvez spécifier un ou les deux types de message en créant un objet avec les clés data
et/ou notification
. Par exemple, voici comment définir différents types de charges utiles de message :
Message de notification
const payload = {
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.'
}
};
Message de données
const payload = {
data: {
score: '850',
time: '2:45'
}
};
Message combiné
const payload = {
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.'
},
data: {
stock: 'GOOG',
open: '829.62',
close: '635.67'
}
};
Les charges utiles des messages de notification ont un sous-ensemble prédéfini de propriétés valides et diffèrent légèrement selon le système d'exploitation mobile que vous ciblez. Voir les documents de référence pour NotificationMessagePayload
pour une liste complète.
Les charges utiles des messages de données sont composées de paires clé-valeur personnalisées avec quelques restrictions, notamment le fait que toutes les valeurs doivent être des chaînes. Consultez la documentation de référence pour DataMessagePayload
pour une liste complète des restrictions.
Définition des options de message
Les méthodes ci-dessus basées sur les protocoles hérités FCM acceptent un troisième argument facultatif spécifiant certaines options pour le message. Par exemple, l'exemple suivant envoie un message de haute priorité à un appareil qui expire après 24 heures :
Node.js
// This registration token comes from the client FCM SDKs.
const registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';
// See the "Defining the message payload" section above for details
// on how to define a message payload.
const payload = {
notification: {
title: 'Urgent action needed!',
body: 'Urgent action is needed to prevent your account from being disabled!'
}
};
// Set the message as high priority and have it expire after 24 hours.
const options = {
priority: 'high',
timeToLive: 60 * 60 * 24
};
// Send a message to the device corresponding to the provided
// registration token with the provided options.
getMessaging().sendToDevice(registrationToken, payload, options)
.then((response) => {
console.log('Successfully sent message:', response);
})
.catch((error) => {
console.log('Error sending message:', error);
});
Consultez les documents de référence pour MessagingOptions
pour une liste complète des options disponibles.