Créer des requêtes d'envoi du serveur d'applications

À l'aide des protocoles du Firebase Admin SDK ou du serveur d'applications FCM, vous pouvez créer des demandes de messages et les envoyer à ces types de cibles :

  • 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 du 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 vers un seul appareil spécifique, transmettez le jeton d’enregistrement de l’appareil comme indiqué. Consultez les informations de configuration client pour votre plateforme pour en savoir plus sur les jetons d'enregistrement.

Noeud.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 d'administration Firebase renvoie la chaîne d'ID au 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 vers une liste de jetons d'enregistrement d'appareil. Vous pouvez spécifier jusqu'à 500 jetons d'enregistrement d'appareil par appel.

Noeud.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.

Noeud.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 les instances d'application client 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 requêtes d'envoi pour FCM, consultez le guide de votre environnement de serveur et de FCM pour obtenir des informations de base et de configuration importantes.

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

Noeud.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 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 non abonné à TopicA ne reçoit pas le message. Ces combinaisons le reçoivent :

  • TopicA et TopicB
  • TopicA et TopicC

Vous pouvez inclure jusqu'à cinq sujets dans votre expression conditionnelle.

Pour envoyer à une condition :

Noeud.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 à des groupes d'appareils, utilisez l'API HTTP v1. Si vous envoyez actuellement à 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 fortement de migrer vers HTTP v1. API dans les plus brefs délais. 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

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 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 sujets ou des jetons d'enregistrement d'appareil 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.

Noeud.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");

Envoyer des messages de 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 des messages à des appareils en mode de démarrage direct, assurez-vous d'avoir effectué les étapes permettant aux appareils 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'API HTTP héritée de 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 traités par les applications sur les appareils actuellement en mode de démarrage direct (et également lorsqu'ils ne sont pas dans ce mode).

Personnaliser 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.
  • ensembles de champs spécifiques à la plate-forme, tels que AndroidConfig et WebpushConfig , 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 offrent la possibilité de personnaliser les messages pour différentes plates-formes afin de garantir qu'ils sont traités correctement une fois reçus. Le backend FCM prendra en compte tous les paramètres spécifiés et personnalisera le message pour chaque plateforme.

Quand utiliser les champs communs

Utilisez les champs communs lorsque vous :

  • Ciblage des instances d'application sur toutes les plateformes : Apple, Android et Web
  • Envoi de messages vers des sujets

Toutes les instances d'application, quelle que soit la plate-forme, peuvent interpréter les champs communs suivants :

Quand utiliser les champs spécifiques à la plateforme

Utilisez des champs spécifiques à la plateforme lorsque vous souhaitez :

  • Envoyer des champs uniquement à des plateformes 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 ; utilisez des champs spécifiques à la plateforme. Par exemple, pour envoyer une notification uniquement aux plateformes 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 les champs spécifiques à la plateforme pour les définir. Vous pouvez spécifier différentes valeurs par plateforme si vous le souhaitez. Cependant, même si vous souhaitez définir essentiellement la même valeur sur toutes les plateformes, vous devez utiliser des champs spécifiques à la plateforme. 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 pour l'application Android.

Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :

Dessin simple de deux appareils, l'un affichant une icône et une couleur personnalisées

Noeud.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 obtenir des détails complets 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 plateformes, mais il envoie également une image. Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :

Dessin simple d'une image dans une notification d'affichage

Noeud.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 obtenir des détails complets 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 effectuer en réponse à l'utilisateur interagissant avec la notification. Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :

Dessin simple d'un utilisateur appuyant sur l'ouverture d'une page Web

Noeud.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 obtenir des détails complets 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 de demande d'envoi suivant envoie des options de localisation pour que le client affiche les messages localisés. Voici une approximation de l'effet visuel sur l'appareil d'un utilisateur :

Dessin simple de deux appareils affichant du texte en anglais et en espagnol

Noeud.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 obtenir des détails complets 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 Étapes de description et 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 4 096 octets pour la plupart des messages. Pour les messages envoyés aux sujets, la limite est de 2 048 octets. La taille totale de la charge utile comprend à 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 fourni non valide. Assurez-vous qu'il correspond au jeton d'enregistrement que l'application client reçoit lors de son inscription auprès de FCM. Ne le tronquez pas et n’y 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 :
  • L'application client s'est désinscrite de FCM.
  • L'application client a été automatiquement désinscrite. Cela peut se produire si l'utilisateur désinstalle l'application ou, sur les plateformes Apple, si le service de commentaires APNs a signalé le jeton APNs comme invalide.
  • Le jeton d'enregistrement a expiré. Par exemple, Google peut décider d'actualiser les jetons d'enregistrement ou le jeton APNs peut avoir expiré pour les appareils Apple.
  • L'application client a été mise à jour, mais la nouvelle version n'est pas configurée pour recevoir des messages.
Dans tous ces cas, supprimez ce jeton d'enregistrement et arrêtez de l'utiliser pour envoyer des messages.
messaging/invalid-package-name Le message a été adressé à un jeton d'enregistrement dont le nom du package ne correspond pas à l'option restrictedPackageName fournie.
messaging/message-rate-exceeded Le débit 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 de les envoyer à cette cible.
messaging/device-message-rate-exceeded Le débit 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 de les envoyer à cet appareil.
messaging/topics-message-rate-exceeded Le taux de messages aux abonnés sur 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 vers 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 la façon d'authentifier les 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 d'administration Firebase avec un identifiant disposant des autorisations appropriées pour envoyer des messages FCM. Consultez Ajouter Firebase à votre application pour obtenir de la documentation sur la façon d'authentifier les 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 demande, mais vous devez :
  • Respectez l'en-tête Retry-After s'il est inclus dans la réponse du serveur de connexion FCM.
  • Implémentez une interruption exponentielle dans votre mécanisme de nouvelle tentative. Par exemple, si vous avez attendu une seconde avant la première tentative, attendez au moins deux secondes avant la suivante, puis quatre secondes, et ainsi de suite. Si vous envoyez plusieurs messages, retardez chacun indépendamment d'un montant aléatoire supplémentaire pour éviter d'émettre une nouvelle demande pour tous les messages en même temps.
Les expéditeurs qui posent problème risquent d’être mis sur liste noire.
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. Consultez 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 de rapport de bug .

Envoyer des messages à l'aide des anciens protocoles du serveur d'applications

Si vous utilisez actuellement les protocoles existants, créez des demandes de message comme indiqué dans cette section. Gardez à l’esprit que si vous envoyez vers plusieurs plateformes 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 la clé to le jeton d'enregistrement pour l'instance d'application spécifique. Consultez les informations de configuration client pour votre plateforme 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 de 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 relatives au 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'applications définit la clé to avec une valeur telle que /topics/yourTopic . Les développeurs peuvent choisir n'importe quel nom de sujet correspondant à l'expression régulière : "/topics/[a-zA-Z0-9-_.~%]+" .

Pour envoyer vers des combinaisons de plusieurs sujets, le serveur d'applications doit définir la clé condition (au lieu de la clé to ) sur une condition booléenne qui spécifie les sujets 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 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 non abonné à TopicA ne reçoit pas le message. Ces combinaisons le reçoivent :

  • Sujet A et Sujet B
  • SujetA et SujetC

Vous pouvez inclure jusqu'à cinq sujets dans votre expression conditionnelle et les parenthèses sont prises en charge. Opérateurs pris en charge : && , || .

Sujet 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 thèmes "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 thèmes "chiens" ou "chats" :

<message id="">
  <gcm xmlns="google:mobile:data">


  </gcm>
</message>

Réponse XMPP au sujet

// Success example:
{
  "message_id": "1023456"
}

// failure example:
{
  "error": "TopicsMessageRateExceeded"
}

Attendez-vous à un délai allant jusqu'à 30 secondes avant que le serveur FCM renvoie une réponse de réussite ou d'échec aux demandes d'envoi de rubrique. Assurez-vous de définir la valeur du délai d'expiration du serveur d'applications dans la requête 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 anciens protocoles 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 seul des jetons d'enregistrement. Le message de réponse répertorie les jetons d'enregistrement ( registration_ids ) qui n'ont pas réussi à recevoir le message :

{
  "success":1,
  "failure":2,
  "failed_registration_ids":[
     "regId1",
     "regId2"
  ]
}

Lorsqu'un message ne parvient pas à être remis à un ou plusieurs jetons d'enregistrement associés à une notification_key , le serveur d'application doit réessayer avec un intervalle 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'entre 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 seul des jetons d'enregistrement. Le message de réponse répertorie les jetons d'enregistrement qui n'ont pas réussi à recevoir 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 à transmettre à tous les appareils du groupe. Le serveur d'applications recevra une réponse nack.

Pour la liste complète des options de message, consultez les informations de référence pour le protocole de serveur de connexion que vous avez choisi, HTTP ou XMPP .

Méthodes d'envoi héritées du SDK d'administration Firebase

Le SDK Firebase Admin Node.js prend en charge les méthodes d'envoi de messages (FCM) basées sur l' API du serveur Legacy FCM . Ces méthodes acceptent des arguments différents par rapport à la méthode send() . Vous devez utiliser la méthode send() autant que possible et utiliser uniquement les méthodes décrites dans cette page lors de l'envoi de messages à des appareils individuels ou à des groupes d'appareils.

Envoyer vers des appareils individuels

Vous pouvez transmettre un jeton d'enregistrement à la méthode sendToDevice() pour envoyer un message à cet appareil :

Noeud.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 :

Noeud.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 du passage 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 Erreurs de l'API Admin FCM .

Envoyer à un groupe d'appareils

La méthode sendToDeviceGroup() vous permet d'envoyer un message à un groupe de périphériques en spécifiant la clé de notification pour ce groupe de périphériques :

Noeud.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 Erreurs de l'API Admin FCM .

Définir la charge utile du message

Les méthodes ci-dessus, basées sur les protocoles hérités 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 messages 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. Consultez 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 les documents de référence pour DataMessagePayload pour une liste complète des restrictions.

Définir les options des messages

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 hautement prioritaire à un appareil qui expire après 24 heures :

Noeud.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.