Check out what’s new from Firebase@ Google I/O 2021, and join our alpha program for early access to the new Remote Config personalization feature. Learn more

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

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

  • Nom du sujet
  • État
  • Jeton d'enregistrement de l'appareil
  • Nom du groupe d'appareils (protocoles hérités et SDK Firebase Admin pour Node.js 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 protocoles HTTP et XMPP hérités .

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.
admin.messaging().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)

Va

// 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);

DU 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

L'API REST et 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 de périphérique 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,
};

admin.messaging().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))

Va

// Create a list containing up to 100 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.SendMulticastAsync(message);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

DU REPOS

Construisez une requête HTTP batch :

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

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!"
     }
  }
}

...

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

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!"
     }
  }
}
--subrequest_boundary--

Enregistrez la demande dans un fichier (dans cet exemple batch_request.txt). Ensuite, utilisez la commande cURL :

curl --data-binary @batch_request.txt -H 'Content-Type: multipart/mixed; boundary="subrequest_boundary"' https://fcm.googleapis.com/batch

Pour les SDK Firebase Admin, cette opération utilise l'API sendAll() sous le capot, comme indiqué dans les exemples. La valeur de retour est un BatchResponse dont la liste de réponses 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,
};

admin.messaging().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))

Va

// Create a list containing up to 100 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.SendMulticastAsync(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}");
}

DU REPOS

Chaque envoi secondaire renvoie une réponse. Les réponses sont séparées par une chaîne de limite de réponse commençant par --batch_ .

--batch_nDhMX4IzFTDLsCJ3kHH7v_44ua-aJT6q
Content-Type: application/http
Content-ID: response-

HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Vary: Origin
Vary: X-Origin
Vary: Referer

{
  "name": "projects/35006771263/messages/0:1570471792141125%43c11b7043c11b70"
}

...

--batch_nDhMX4IzFTDLsCJ3kHH7v_44ua-aJT6q
Content-Type: application/http
Content-ID: response-

HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Vary: Origin
Vary: X-Origin
Vary: Referer

{
  "name": "projects/35006771263/messages/0:1570471792141696%43c11b7043c11b70"
}

--batch_nDhMX4IzFTDLsCJ3kHH7v_44ua-aJT6q--

Envoyer des messages aux sujets

Après avoir créé un sujet, soit en souscrivant des 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 demandes d'envoi pour FCM, consultez le guide de votre environnement de serveur et de 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.
admin.messaging().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)

Va

// 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);

DU 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 sujet unique ne reçoit pas le message. De même, un utilisateur qui ne s'abonne pas à TopicA ne reçoit pas le message. Ces combinaisons le reçoivent :

  • TopicA et TopicB
  • TopicA et TopicC

Vous pouvez inclure jusqu'à cinq 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.
admin.messaging().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)

Va

// 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);

DU 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 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 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 de périphérique 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',
});

admin.messaging().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))

Va

// Create a list containing up to 100 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.SendAllAsync(messages);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

DU REPOS

Construisez une requête HTTP batch en combinant une liste de sous-requêtes :

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

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
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

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
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

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 la BatchResponse renvoyée 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 directs activés pour le démarrage (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 effectué 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 demande de message doit inclure la clé "direct_boot_ok" : true dans les options AndroidConfig du corps de la demande. Par example:

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 example:

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 demande 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 de 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 et WebpushConfig , interprétés uniquement par les instances d'application s'exécutant 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 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 êtes :

  • Cibler les instances d'application sur toutes les plateformes — iOS, 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 des 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 à iOS et au Web mais pas à Android, vous devez utiliser deux ensembles de champs distincts, un pour iOS 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 iOS, 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 demande 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,
};

admin.messaging().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',
)

Va

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",
};

DU 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 :

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,
};

admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

DU 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 plateformes, mais il envoie également une action à exécuter par l'application 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,
};

admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

DU 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 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,
};

admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

DU 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 de l'administrateur

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 de DataMessagePayload pour les clés restreintes.
messaging/payload-size-limit-exceeded La charge utile du message fourni dépasse les limites de taille du FCM. La limite est de 4096 octets pour la plupart des messages. Pour les messages envoyés aux rubriques, la limite est de 2048 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 non valide fourni. Assurez-vous qu'il correspond au jeton d'enregistrement que l'application cliente reçoit en s'enregistrant auprès de FCM. Ne pas tronquer ni ajouter 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 cliente s'est désinscrite de FCM.
  • L'application cliente a été automatiquement désinscrite. Cela peut se produire si l'utilisateur désinstalle l'application ou, sur iOS, si le service de commentaires APNs a signalé le jeton APNs comme non valide.
  • 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 iOS.
  • L'application cliente a été mise à jour, mais la nouvelle version n'est pas configurée pour recevoir des messages.
Pour tous ces cas, supprimez ce jeton d'enregistrement et arrêtez de l'utiliser pour envoyer des messages.
messaging/invalid-package-name Le message était 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'en 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 cette rubrique et ne réessayez pas immédiatement d'envoyer à cette rubrique.
messaging/too-many-topics Un jeton d'inscription a été souscrit au nombre maximum de sujets et ne peut plus être souscrit.
messaging/invalid-apns-credentials Un message destiné à un appareil iOS 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 identifiants 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 Firebase Admin.
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 des informations d'identification 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 Firebase Admin.
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 :
  • Retry-After tête Retry-After s'il est inclus dans la réponse du serveur de connexion FCM.
  • Implémentez une temporisation 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 causent des problèmes 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 messaging/server-unavailable dessus. Si l'erreur persiste, veuillez signaler le problème à notre canal d'assistance de rapport de bogue .
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 de rapport de bogue .

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

Si vous préférez utiliser 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 simplifier vos demandes de messages.

Envoyer des messages à des appareils spécifiques

Pour envoyer des messages à des appareils spécifiques, réglez le to clé de l'enregistrement jeton 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 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 pour le 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 qui correspond à l'expression régulière : "/topics/[a-zA-Z0-9-_.~%]+" .

Pour envoyer à des combinaisons de plusieurs sujets, le serveur d'application doit définir l' condition clé ( au lieu de to clé) à une condition booléenne indiquant les sujets des 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 sujet unique ne reçoit pas le message. De même, un utilisateur qui ne s'abonne pas à TopicA ne reçoit pas le message. Ces combinaisons le reçoivent :

  • Sujet A et Sujet B
  • 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 : && , || .

Pour plus de détails sur les clés de serveur d'applications, consultez les informations de référence pour le protocole de serveur de connexion que vous avez choisi, HTTP ou XMPP . Les exemples de cette page montrent comment envoyer des messages à des rubriques à la fois HTTP et XMPP.

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 rubriques « 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"
}

Sujet Message XMPP

Envoyer à un seul sujet :

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


  </gcm>
</message>

Envoyer aux appareils abonnés aux rubriques « chiens » ou « chats » :

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


  </gcm>
</message>

Sujet Réponse XMPP

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

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

Attendez jusqu'à 30 secondes de délai avant que le serveur FCM renvoie une réponse de réussite ou d'échec aux requêtes 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.

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 .

Envoyer des messages à des groupes d'appareils

L'envoi de messages à un groupe d'appareils est très similaire à l'envoi de messages à un appareil individuel. Réglez le to paramètre à la clé de notification unique pour le groupe de périphériques. Voir Types de messages pour plus de détails sur la prise en charge de la charge utile. Les exemples de cette page montrent comment envoyer des messages de données à des groupes de périphériques dans les protocoles HTTP et XMPP.

Requête HTTP POST de 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 a 2 tokens d'enregistrement qui lui sont associés 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 a 3 jetons d'enregistrement qui lui sont associés. 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 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 des jetons d'enregistrement associés à une notification_key , le serveur d'applications 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 pas de membres, 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 a 3 jetons d'enregistrement qui lui sont associés. 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 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 à livrer à 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 Admin 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 FCM hérité . Ces méthodes acceptent des arguments différents par rapport à la méthode send() . Vous devez utiliser la méthode send() 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.
admin.messaging().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 passant 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.
admin.messaging().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 du 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 une 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 messagerie de groupe d'appareils vous permet d'ajouter plusieurs appareils à un seul groupe. Ceci est similaire à la messagerie thématique, mais inclut l'authentification pour garantir que l'appartenance au groupe est gérée uniquement par vos serveurs. Par exemple, si vous souhaitez envoyer différents messages à différents modèles de téléphone, vos serveurs peuvent ajouter/supprimer des enregistrements aux groupes appropriés et envoyer le message approprié à chaque groupe. La messagerie de groupe d'appareils diffère de la messagerie thématique en ce sens qu'elle implique la gestion des groupes d'appareils à partir de vos serveurs plutôt que directement dans votre application.

Vous pouvez utiliser la messagerie de groupe d'appareils via les anciens protocoles XMPP ou HTTP sur votre serveur d'applications. Le SDK Firebase Admin pour Node.js basé sur les protocoles hérités fournit également des fonctionnalités de messagerie de groupe d'appareils. Le nombre maximum de membres autorisés pour une clé de notification est de 20.

Vous pouvez créer des groupes d'appareils et générer des clés de notification via un serveur d'applications ou un client Android. Voir Gestion des groupes d'appareils pour plus de détails.

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.
admin.messaging().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 MessagingDeviceGroupResponse contenant la réponse de FCM.

Certains cas, tels qu'une erreur d'authentification ou une limitation du 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 une 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 message en créant un objet avec les clés de data et/ou de 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 les documents de référence pour DataMessagePayload pour une liste complète des restrictions.

Définir les 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 au bout de 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.
admin.messaging().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.