Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Créer des demandes 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 à ces types de cibles:

  • Nom du sujet
  • État
  • Jeton d'enregistrement de l'appareil
  • Nom du groupe de périphériques (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 plateforme pour en savoir plus sur les jetons d'enregistrement.

Node.js

 // This registration token comes from the client FCM SDKs.
var registrationToken = 'YOUR_REGISTRATION_TOKEN';

var 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) 

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

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 d'administration Firebase renvoie la chaîne d'ID au format projects/{project_id}/messages/{message_id} . La réponse du protocole HTTP est une seule clé JSON:

     {
      "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'à 100 jetons d'enregistrement de périphérique (500 pour Java et Node.js) 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 100 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 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 100 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 requête 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)) 

Aller

 // 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 de sous-envoi renvoie une réponse. Les réponses sont séparées par une chaîne de délimitation 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 à des sujets

Une fois que vous avez créé une rubrique, soit en abonnant des instances d'application cliente à la rubrique côté client, soit via l' API serveur , vous pouvez envoyer des messages à la rubrique. Si c'est la première fois que vous créez des demandes d'envoi pour FCM, consultez le guide de votre environnement de serveur et FCM pour obtenir des informations importantes sur le contexte et la configuration.

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

Node.js

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

var 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) 

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

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é à une seule rubrique 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 sujets 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.
var condition = "'stock-GOOG' in topics || 'industry-tech' in topics";

// See documentation on defining a message payload.
var message = {
  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.
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(new Notification(
        "$GOOG up 1.43% on the day",
        "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day."))
    .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);
 

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
 

Envoyez 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 rubriques ou des jetons d'enregistrement d'appareils spécifiques. Utilisez cette fonction 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(new Notification("Price drop", "5% off all electronics"))
        .setToken(registrationToken)
        .build(),
    // ...
    Message.builder()
        .setNotification(new Notification("Price drop", "2% off all books"))
        .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 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 100 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 par lots 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 le BatchResponse renvoyé pour vérifier combien de messages ont été transmis à FCM avec succès. Il expose également une liste de réponses qui peuvent être utilisées pour vérifier l'état des messages individuels. L'ordre des réponses correspond à l'ordre des messages dans la liste d'entrée.

Envoyer des messages activés pour le démarrage direct (Android uniquement)

Vous pouvez envoyer des messages aux appareils en mode de démarrage direct à l'aide de HTTP v1 ou des API HTTP héritées. Avant d'envoyer aux périphériques en mode de démarrage direct, assurez-vous que vous avez terminé les étapes permettant 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_book_ok" : true dans les options AndroidConfig du corps de la demande. Par exemple:

 https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send
Content-Type:application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

{
  "Message":{
    "token" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
    "data": {
      "score": "5x1",
      "time": "15:10"
    },
    "android": {
      "direct_boot_ok": true,
    },
}
 

Envoyer à l'aide de l'ancienne API HTTP FCM

La demande de message doit inclure la clé "direct_book_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_book_ok" : true
}
 

Les messages envoyés avec cette clé dans le corps de la demande peuvent être gérés par les applications sur les appareils actuellement en mode de démarrage direct (et également lorsqu'ils ne sont pas dans ce mode).

Personnalisez les messages sur toutes les plateformes

Le SDK Firebase Admin et le protocole HTTP FCM v1 permettent à 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.
  • ensembles de champs spécifiques à la plate-forme, tels que AndroidConfig et WebpushConfig , interprétés uniquement par des instances d'application exécutées sur la plate-forme spécifiée.

Les blocs spécifiques à la plate-forme vous offrent la flexibilité de personnaliser les messages pour différentes plates-formes afin de vous assurer qu'ils sont correctement traités lors de leur réception. Le backend FCM prendra en compte tous les paramètres spécifiés et personnalisera le message pour chaque plateforme.

Quand utiliser les champs communs

Utilisez des champs communs lorsque vous:

  • Ciblage des instances d'application sur toutes les plates-formes - iOS, Android et Web
  • Envoi de messages à 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 plate-forme lorsque vous souhaitez:

  • Envoyer les champs uniquement à des plates-formes particulières
  • Envoyer des champs spécifiques à la plateforme en plus des champs communs

Chaque fois que vous souhaitez envoyer des valeurs uniquement à des plates-formes particulières, n'utilisez pas de champs communs; utiliser des champs spécifiques à la plateforme. 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 remise 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 si 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 une heure d'expiration en secondes, tandis que sur iOS, elle est définie comme une date d' expiration.

Exemple: message de notification avec options de livraison spécifiques à la plateforme

La demande d'envoi suivante envoie un titre et un contenu de notification communs à toutes les plates-formes, mais elle envoie également des remplacements spécifiques à la plate-forme. Plus précisément, la demande:

  • Définit une longue durée de vie pour Android, ainsi qu'une icône et une couleur spéciales à afficher sur les appareils Android.
  • Définit le champ de badge uniquement iOS dans la charge utile APN, pour la livraison aux appareils iOS.

Node.js

 var message = {
  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: {
    ttl: 3600 * 1000,
    notification: {
      icon: 'stock_ticker_update',
      color: '#f45342',
    },
  },
  apns: {
    payload: {
      aps: {
        badge: 42,
      },
    },
  },
  topic: 'industry-tech'
};
 

Java

 Message message = Message.builder()
    .setNotification(new Notification(
        "$GOOG up 1.43% on the day",
        "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day."))
    .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",
}; 

DU REPOS

 {
  "message":{
     "topic":"industry-tech",
     "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":{
       "ttl":"3600s",
       "notification":{
         "icon":"stock_ticker_update",
         "color":"#f45342"
       }
     },
     "apns":{
       "payload":{
         "aps":{
           "badge":"42"
         }
       }
     },
     "webpush":{
       "headers":{
         "TTL":"86400"
       }
     }
   }
 }
 

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 de 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'inscription non valide fourni. Assurez-vous qu'il correspond au jeton d'inscription que l'application cliente reçoit lors de son inscription auprès de FCM. Ne 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 rétroaction 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.
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'inscription dont le nom de package ne correspond pas à l'option restrictedPackageName fournie.
messaging/message-rate-exceeded Le taux de messages adressés à une cible particulière est trop élevé. Réduisez le nombre de messages envoyés à ce périphérique ou à cette rubrique et ne réessayez pas immédiatement d'envoyer à cette cible.
messaging/device-message-rate-exceeded Le taux de messages vers un appareil particulier est trop élevé. Réduisez le nombre de messages envoyés à cet appareil et ne réessayez pas immédiatement d'envoyer à cet appareil.
messaging/topics-message-rate-exceeded Le taux de messages aux abonnés 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 à 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 ciblant un appareil iOS n'a pas pu être envoyé car le certificat SSL APN 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 ne sont pas autorisées à envoyer des messages à l'appareil correspondant au jeton d'enregistrement fourni. Assurez-vous que les informations d'identification et le jeton d'enregistrement appartiennent tous deux au même projet Firebase. Consultez Ajouter Firebase à votre application pour obtenir de la documentation sur l'authentification des SDK 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 un identifiant disposant des autorisations appropriées pour envoyer des messages FCM. Consultez Ajouter Firebase à votre application pour obtenir de la documentation sur l'authentification des SDK 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 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 d'eux 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 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 de messaging/server-unavailable ci messaging/server-unavailable dessus. Si l'erreur persiste, veuillez signaler le problème à notre canal de support de rapport de bogue .
messaging/unknown-error Une erreur de serveur inconnue a été renvoyée. Consultez la réponse du serveur brut dans le message d'erreur pour plus de détails. Si vous recevez cette erreur, veuillez signaler le message d'erreur complet à notre canal de support de rapport de bogue .

Envoyer des messages à l'aide des protocoles de serveur d'applications hérités

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 à 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 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 pour les réponses. Voir Format de réponse du serveur .

Pour obtenir la liste complète des options de message disponibles lors de l'envoi de messages en aval aux applications clientes, consultez les informations de référence pour le protocole de serveur de connexion choisi, HTTP ou XMPP .

Envoyer des messages à des 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é à une seule rubrique 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 sujets dans votre expression conditionnelle et les parenthèses sont prises en charge. Opérateurs pris en charge: && , || , ! . Notez l'utilisation pour ! :

!('TopicA' in topics)

Avec cette expression, toutes les instances d'application qui ne sont pas abonnées à TopicA, y compris les instances d'application qui ne sont abonnées à aucun sujet, reçoivent le message.

Pour plus de détails sur les clés du serveur d'applications, consultez les informations de référence du protocole de serveur de connexion choisi, HTTP ou XMPP . Les exemples de cette page montrent comment envoyer des messages à des sujets en HTTP et XMPP.

Sujet Demande HTTP POST

Envoyer à un seul sujet:

https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA


Envoyer aux appareils abonnés aux sujets "chiens" ou "chats":

https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA


Réponse HTTP au 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 sujets "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 retard avant que le serveur FCM renvoie une réponse de succès ou d'échec aux demandes d'envoi de rubrique. Assurez-vous de définir la valeur de délai d'expiration du serveur d'application dans la demande en conséquence.

Pour obtenir la liste complète des options de message, consultez les informations de référence du protocole de serveur de connexion 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 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 a 2 jetons 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 à l'un des jetons d'enregistrement uniquement. Le message de réponse répertorie les jetons d'enregistrement qui n'ont pas pu 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'inscription associés à une notification_key , le serveur d'application doit réessayer avec 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 périphériques du groupe, le serveur de connexion XMPP répond par un ACK. Si tous les messages envoyés à tous les périphériques du groupe échouent, le serveur de connexion XMPP répond avec un NACK.

Voici un exemple de "succès" - la notification_key a 3 jetons d'enregistrement qui lui sont associés et le message a été envoyé avec succès à tous:

{
  "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 à l'un des jetons d'enregistrement uniquement. Le message de réponse répertorie les jetons d'enregistrement qui n'ont pas pu 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 périphériques du groupe. Le serveur d'applications recevra une réponse nack.

Pour obtenir la liste complète des options de message, consultez les informations de référence du protocole de serveur de connexion choisi, HTTP ou XMPP .

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

Le SDK Firebase Admin Node.js prend en charge les méthodes d'envoi de messages (FCM) basées sur l' 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() 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 vers 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.
var registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';

// See the "Defining the message payload" section below for details
// on how to define a message payload.
var 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(function(response) {
    // See the MessagingDevicesResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch(function(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.
var registrationTokens = [
  'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...',
  // ...
  'ecupwIfBy1w:APA91bFtuMY7MktgxA3Au_Qx7cKqnf...'
];

// See the "Defining the message payload" section below for details
// on how to define a message payload.
var 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(function(response) {
    // See the MessagingDevicesResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch(function(error) {
    console.log('Error sending message:', error);
  });
 

La méthode sendToDevice() renvoie une promesse qui est résolue avec un objet MessagingDevicesResponse contenant la réponse de FCM. Le type de retour a le même format lors de la transmission d'un seul jeton d'enregistrement ou d'un tableau de jetons d'enregistrement.

Certains cas tels qu'une erreur d'authentification ou une limitation de débit entraînent l'échec du traitement de l'intégralité du message. Dans ces cas, la promesse retourné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 messagerie de groupe d'appareils vous permet d'ajouter plusieurs appareils à un seul groupe. Ceci est similaire à la messagerie de rubrique, mais inclut une 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 inscriptions aux groupes appropriés et envoyer le message approprié à chaque groupe. La messagerie de groupe de périphériques diffère de la messagerie de rubrique en ce qu'elle implique la gestion des groupes de périphériques à 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 de périphériques. 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 Gérer les 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.
var notificationKey = 'some-notification-key';

// See the "Defining the message payload" section below for details
// on how to define a message payload.
var 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(function(response) {
    // See the MessagingDeviceGroupResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch(function(error) {
    console.log('Error sending message:', error);
  });
 

La méthode sendToDeviceGroup() retourne 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 de débit entraînent l'échec du traitement de l'intégralité du message. Dans ces cas, la promesse retourné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éfinition de 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

 var payload = {
  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.'
  }
};
 

Message de données

 var payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};
 

Message combiné

 var payload = {
  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.'
  },
  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 la documentation de référence pour NotificationMessagePayload pour une liste complète.

Les charges utiles des messages de données sont composées de paires clé-valeur personnalisées avec quelques restrictions, notamment le fait que toutes les valeurs doivent être des chaînes. Consultez la documentation de référence de DataMessagePayload pour une liste complète des restrictions.

Définition des options de message

Les méthodes ci-dessus basées sur les protocoles hérités FCM acceptent un troisième argument facultatif spécifiant certaines options pour le message. Par exemple, l'exemple suivant envoie un message de haute priorité à un appareil qui expire après 24 heures:

Node.js

 // This registration token comes from the client FCM SDKs.
var registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';

// See the "Defining the message payload" section above for details
// on how to define a message payload.
var 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.
var 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(function(response) {
    console.log('Successfully sent message:', response);
  })
  .catch(function(error) {
    console.log('Error sending message:', error);
  });
 

Consultez la documentation de référence de MessagingOptions pour une liste complète des options disponibles.