Crear solicitudes de envío del servidor de aplicaciones

Con el SDK de Firebase Admin o los protocolos del servidor de aplicaciones FCM, puedes crear solicitudes de mensajes y enviarlas a estos tipos de destinos:

  • Nombre del tema
  • Condición
  • Token de registro del dispositivo
  • Nombre del grupo de dispositivos (solo protocolo)

Puede enviar mensajes con una carga útil de notificación compuesta por campos predefinidos, una carga útil de datos de sus propios campos definidos por el usuario o un mensaje que contenga ambos tipos de carga útil. Consulte Tipos de mensajes para obtener más información.

Los ejemplos en esta página muestran cómo enviar mensajes de notificación usando el SDK de Firebase Admin (que es compatible con Node , Java , Python , C# y Go ) y el protocolo HTTP v1 . También hay instrucciones para enviar mensajes a través de los protocolos HTTP y XMPP heredados y obsoletos.

Enviar mensajes a dispositivos específicos

Para enviar a un dispositivo único y específico, pase el token de registro del dispositivo como se muestra. Consulte la información de configuración del cliente para su plataforma para obtener más información sobre los tokens de registro.

Nodo.js

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

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

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

Java

// This registration token comes from the client FCM SDKs.
String registrationToken = "YOUR_REGISTRATION_TOKEN";

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

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

Pitón

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

Ir

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

DESCANSAR

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

comando de curvatura:

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 caso de éxito, cada método de envío devuelve un ID de mensaje. El SDK de Firebase Admin devuelve la cadena de ID en el formato projects/{project_id}/messages/{message_id} . La respuesta del protocolo HTTP es una única clave JSON:

    {
      "name":"projects/myproject-b5ae1/messages/0:1500415314455276%31bd1c9631bd1c96"
    }

Enviar mensajes a múltiples dispositivos

Las API de Admin FCM le permiten multidifundir un mensaje a una lista de tokens de registro de dispositivos. Puede especificar hasta 500 tokens de registro de dispositivo por invocación.

Nodo.js

// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'YOUR_REGISTRATION_TOKEN_1',
  // …
  'YOUR_REGISTRATION_TOKEN_N',
];

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

getMessaging().sendMulticast(message)
  .then((response) => {
    console.log(response.successCount + ' messages were sent successfully');
  });

Java

// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n"
);

MulticastMessage message = MulticastMessage.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .addAllTokens(registrationTokens)
    .build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");

Pitón

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

Ir

// Create a list containing up to 500 registration tokens.
// This registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}
message := &messaging.MulticastMessage{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Tokens: registrationTokens,
}

br, err := client.SendMulticast(context.Background(), message)
if err != nil {
	log.Fatalln(err)
}

// See the BatchResponse reference documentation
// for the contents of response.
fmt.Printf("%d messages were sent successfully\n", br.SuccessCount)

C#

// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};
var message = new MulticastMessage()
{
    Tokens = registrationTokens,
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
};

var response = await FirebaseMessaging.DefaultInstance.SendEachForMulticastAsync(message);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

El valor de retorno es una lista de tokens que corresponde al orden de los tokens de entrada. Esto es útil cuando desea verificar qué tokens generaron errores.

Nodo.js

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

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

getMessaging().sendMulticast(message)
  .then((response) => {
    if (response.failureCount > 0) {
      const failedTokens = [];
      response.responses.forEach((resp, idx) => {
        if (!resp.success) {
          failedTokens.push(registrationTokens[idx]);
        }
      });
      console.log('List of tokens that caused failures: ' + failedTokens);
    }
  });

Java

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

MulticastMessage message = MulticastMessage.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .addAllTokens(registrationTokens)
    .build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
if (response.getFailureCount() > 0) {
  List<SendResponse> responses = response.getResponses();
  List<String> failedTokens = new ArrayList<>();
  for (int i = 0; i < responses.size(); i++) {
    if (!responses.get(i).isSuccessful()) {
      // The order of responses corresponds to the order of the registration tokens.
      failedTokens.add(registrationTokens.get(i));
    }
  }

  System.out.println("List of tokens that caused failures: " + failedTokens);
}

Pitón

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

Ir

// Create a list containing up to 500 registration tokens.
// This registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}
message := &messaging.MulticastMessage{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Tokens: registrationTokens,
}

br, err := client.SendMulticast(context.Background(), message)
if err != nil {
	log.Fatalln(err)
}

if br.FailureCount > 0 {
	var failedTokens []string
	for idx, resp := range br.Responses {
		if !resp.Success {
			// The order of responses corresponds to the order of the registration tokens.
			failedTokens = append(failedTokens, registrationTokens[idx])
		}
	}

	fmt.Printf("List of tokens that caused failures: %v\n", failedTokens)
}

C#

// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};
var message = new MulticastMessage()
{
    Tokens = registrationTokens,
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
};

var response = await FirebaseMessaging.DefaultInstance.SendEachForMulticastAsync(message);
if (response.FailureCount > 0)
{
    var failedTokens = new List<string>();
    for (var i = 0; i < response.Responses.Count; i++)
    {
        if (!response.Responses[i].IsSuccess)
        {
            // The order of responses corresponds to the order of the registration tokens.
            failedTokens.Add(registrationTokens[i]);
        }
    }

    Console.WriteLine($"List of tokens that caused failures: {failedTokens}");
}

Enviar mensajes a temas

Después de haber creado un tema, ya sea suscribiendo instancias de la aplicación cliente al tema en el lado del cliente o mediante la API del servidor , puede enviar mensajes al tema. Si es la primera vez que crea solicitudes de envío para FCM, consulte la guía de su entorno de servidor y FCM para obtener información importante sobre antecedentes y configuración.

En su lógica de envío en el backend, especifique el nombre del tema deseado como se muestra:

Nodo.js

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

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

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

Java

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

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

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

Pitón

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

Ir

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

DESCANSAR

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

comando de curvatura:

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

Para enviar un mensaje a una combinación de temas, especifique una condición , que es una expresión booleana que especifica los temas de destino. Por ejemplo, la siguiente condición enviará mensajes a dispositivos que estén suscritos a TopicA y a TopicB o TopicC :

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

FCM primero evalúa las condiciones entre paréntesis y luego evalúa la expresión de izquierda a derecha. En la expresión anterior, un usuario suscrito a un solo tema no recibe el mensaje. Asimismo, un usuario que no está suscrito a TopicA no recibe el mensaje. Estas combinaciones sí lo reciben:

  • TopicA y TopicB
  • TopicA y TopicC

Puede incluir hasta cinco temas en su expresión condicional.

Para enviar a una condición:

Nodo.js

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

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

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

Java

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

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

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

Pitón

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

Ir

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

DESCANSAR

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

comando de curvatura:

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

Enviar mensajes a grupos de dispositivos

Para enviar mensajes a grupos de dispositivos, utilice la API HTTP v1. Si actualmente estás enviando a grupos de dispositivos usando las API de envío heredadas obsoletas para HTTP o XMPP, o cualquiera de las versiones anteriores del SDK de Firebase Admin para Node.js basadas en los protocolos heredados, te recomendamos encarecidamente que migres a HTTP v1. API lo antes posible. Las API de envío heredadas se desactivarán y eliminarán en junio de 2024.

Enviar mensajes a un grupo de dispositivos es muy similar a enviar mensajes a un dispositivo individual, utilizando el mismo método para autorizar solicitudes de envío . Establezca el campo token en la clave de notificación del grupo:

DESCANSAR

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

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

{
   "message":{
      "token":"APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ",
      "data":{
        "hello": "This is a Firebase Cloud Messaging device group message!"
      }
   }
}

comando de curvatura

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
   "data":{
     "hello": "This is a Firebase Cloud Messaging device group message!"
   },
   "token":"APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ"
}}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send

Enviar un lote de mensajes

Los SDK de administración admiten el envío de mensajes en lotes. Puede agrupar hasta 500 mensajes en un solo lote y enviarlos todos en una sola llamada API, con una mejora significativa del rendimiento con respecto al envío de solicitudes HTTP separadas para cada mensaje.

Esta función se puede utilizar para crear un conjunto personalizado de mensajes y enviarlos a diferentes destinatarios, incluidos temas o tokens de registro de dispositivos específicos. Utilice esta función cuando, por ejemplo, necesite enviar mensajes simultáneamente a diferentes audiencias con detalles ligeramente diferentes en el cuerpo del mensaje.

Nodo.js

// Create a list containing up to 500 messages.
const messages = [];
messages.push({
  notification: { title: 'Price drop', body: '5% off all electronics' },
  token: registrationToken,
});
messages.push({
  notification: { title: 'Price drop', body: '2% off all books' },
  topic: 'readers-club',
});

getMessaging().sendAll(messages)
  .then((response) => {
    console.log(response.successCount + ' messages were sent successfully');
  });

Java

// Create a list containing up to 500 messages.
List<Message> messages = Arrays.asList(
    Message.builder()
        .setNotification(Notification.builder()
            .setTitle("Price drop")
            .setBody("5% off all electronics")
            .build())
        .setToken(registrationToken)
        .build(),
    // ...
    Message.builder()
        .setNotification(Notification.builder()
            .setTitle("Price drop")
            .setBody("2% off all books")
            .build())
        .setTopic("readers-club")
        .build()
);

BatchResponse response = FirebaseMessaging.getInstance().sendAll(messages);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");

Pitón

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

Ir

// Create a list containing up to 500 messages.
messages := []*messaging.Message{
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "5% off all electronics",
		},
		Token: registrationToken,
	},
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "2% off all books",
		},
		Topic: "readers-club",
	},
}

br, err := client.SendAll(context.Background(), messages)
if err != nil {
	log.Fatalln(err)
}

// See the BatchResponse reference documentation
// for the contents of response.
fmt.Printf("%d messages were sent successfully\n", br.SuccessCount)

C#

// Create a list containing up to 500 messages.
var messages = new List<Message>()
{
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "5% off all electronics",
        },
        Token = registrationToken,
    },
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "2% off all books",
        },
        Topic = "readers-club",
    },
};

var response = await FirebaseMessaging.DefaultInstance.SendEachAsync(messages);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

Enviar mensajes habilitados para arranque directo (solo Android)

Puede enviar mensajes a dispositivos en modo de inicio directo utilizando HTTP v1 o las API HTTP heredadas. Antes de enviar a dispositivos en modo de inicio directo, asegúrese de haber completado los pasos para permitir que los dispositivos cliente reciban mensajes FCM en modo de inicio directo .

Enviar utilizando la API HTTP de FCM v1

La solicitud de mensaje debe incluir la clave "direct_boot_ok" : true en las opciones de AndroidConfig del cuerpo de la solicitud. Por ejemplo:

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

Enviar utilizando la API HTTP heredada de FCM

La solicitud de mensaje debe incluir la clave "direct_boot_ok" : true en el nivel superior del cuerpo de la solicitud. Por ejemplo:

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
}

Los mensajes enviados con esta clave en el cuerpo de la solicitud pueden ser manejados por aplicaciones en dispositivos actualmente en modo de inicio directo (y también cuando no están en ese modo).

Personaliza mensajes en todas las plataformas

El SDK de Firebase Admin y el protocolo HTTP FCM v1 permiten que sus solicitudes de mensajes establezcan todos los campos disponibles en el objeto message . Esto incluye:

  • un conjunto común de campos que serán interpretados por todas las instancias de la aplicación que reciben el mensaje.
  • conjuntos de campos específicos de la plataforma, como AndroidConfig y WebpushConfig , interpretados solo por instancias de aplicaciones que se ejecutan en la plataforma especificada.

Los bloques específicos de la plataforma le brindan flexibilidad para personalizar mensajes para diferentes plataformas para garantizar que se manejen correctamente cuando se reciban. El backend de FCM tendrá en cuenta todos los parámetros especificados y personalizará el mensaje para cada plataforma.

Cuándo utilizar campos comunes

Utilice campos comunes cuando esté:

  • Orientación a instancias de aplicaciones en todas las plataformas: Apple, Android y web
  • Enviar mensajes a temas

Todas las instancias de aplicaciones, independientemente de la plataforma, pueden interpretar los siguientes campos comunes:

Cuándo utilizar campos específicos de la plataforma

Utilice campos específicos de la plataforma cuando desee:

  • Enviar campos solo a plataformas particulares
  • Enviar campos específicos de la plataforma además de los campos comunes

Siempre que desee enviar valores sólo a plataformas particulares, no utilice campos comunes; Utilice campos específicos de la plataforma. Por ejemplo, para enviar una notificación solo a las plataformas web y de Apple, pero no a Android, debe utilizar dos conjuntos de campos separados, uno para Apple y otro para la web.

Cuando envíe mensajes con opciones de entrega específicas, utilice campos específicos de la plataforma para configurarlas. Puede especificar diferentes valores por plataforma si lo desea. Sin embargo, incluso cuando desee establecer esencialmente el mismo valor en todas las plataformas, debe utilizar campos específicos de la plataforma. Esto se debe a que cada plataforma puede interpretar el valor de manera ligeramente diferente; por ejemplo, el tiempo de vida se establece en Android como un tiempo de vencimiento en segundos, mientras que en Apple se establece como una fecha de vencimiento.

Ejemplo: mensaje de notificación con opciones de color e ícono

Esta solicitud de envío de ejemplo envía un título y contenido de notificación común a todas las plataformas, pero también envía algunas anulaciones específicas de la plataforma a dispositivos Android.

Para Android, la solicitud establece un icono y un color especiales para mostrar en los dispositivos Android. Como se indica en la referencia de AndroidNotification , el color se especifica en formato #rrggbb y la imagen debe ser un recurso de ícono dibujable local para la aplicación de Android.

A continuación se muestra una aproximación del efecto visual en el dispositivo de un usuario:

Dibujo simple de dos dispositivos, uno de los cuales muestra un icono y un color personalizados

Nodo.js

const topicName = 'industry-tech';

const message = {
  notification: {
    title: '`$FooCorp` up 1.43% on the day',
    body: 'FooCorp gained 11.80 points to close at 835.67, up 1.43% on the day.'
  },
  android: {
    notification: {
      icon: 'stock_ticker_update',
      color: '#7e55c3'
    }
  },
  topic: topicName,
};

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

Java

Message message = Message.builder()
    .setNotification(Notification.builder()
        .setTitle("$GOOG up 1.43% on the day")
        .setBody("$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.")
        .build())
    .setAndroidConfig(AndroidConfig.builder()
        .setTtl(3600 * 1000)
        .setNotification(AndroidNotification.builder()
            .setIcon("stock_ticker_update")
            .setColor("#f45342")
            .build())
        .build())
    .setApnsConfig(ApnsConfig.builder()
        .setAps(Aps.builder()
            .setBadge(42)
            .build())
        .build())
    .setTopic("industry-tech")
    .build();

Pitón

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',
)

Ir

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

DESCANSAR

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

Consulte la documentación de referencia de HTTP v1 para obtener detalles completos sobre las claves disponibles en bloques específicos de la plataforma en el cuerpo del mensaje.

Ejemplo: mensaje de notificación con una imagen personalizada

El siguiente ejemplo de solicitud de envío envía un título de notificación común a todas las plataformas, pero también envía una imagen. A continuación se muestra una aproximación del efecto visual en el dispositivo de un usuario:

Dibujo simple de una imagen en una notificación en pantalla.

Nodo.js

const topicName = 'industry-tech';

const message = {
  notification: {
    title: 'Sparky says hello!'
  },
  android: {
    notification: {
      imageUrl: 'https://foo.bar.pizza-monster.png'
    }
  },
  apns: {
    payload: {
      aps: {
        'mutable-content': 1
      }
    },
    fcm_options: {
      image: 'https://foo.bar.pizza-monster.png'
    }
  },
  webpush: {
    headers: {
      image: 'https://foo.bar.pizza-monster.png'
    }
  },
  topic: topicName,
};

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

DESCANSAR

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

Consulte la documentación de referencia de HTTP v1 para obtener detalles completos sobre las claves disponibles en bloques específicos de la plataforma en el cuerpo del mensaje.

Ejemplo: mensaje de notificación con una acción de clic asociada

El siguiente ejemplo de solicitud de envío envía un título de notificación común a todas las plataformas, pero también envía una acción para que la aplicación la realice en respuesta a la interacción del usuario con la notificación. A continuación se muestra una aproximación del efecto visual en el dispositivo de un usuario:

Dibujo simple de un usuario tocando abriendo una página web

Nodo.js

const topicName = 'industry-tech';

const message = {
  notification: {
    title: 'Breaking News....'
  },
  android: {
    notification: {
      clickAction: 'news_intent'
    }
  },
  apns: {
    payload: {
      aps: {
        'category': 'INVITE_CATEGORY'
      }
    }
  },
  webpush: {
    fcmOptions: {
      link: 'breakingnews.html'
    }
  },
  topic: topicName,
};

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

DESCANSAR

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

Consulte la documentación de referencia de HTTP v1 para obtener detalles completos sobre las claves disponibles en bloques específicos de la plataforma en el cuerpo del mensaje.

Ejemplo: mensaje de notificación con opciones de localización

El siguiente ejemplo de solicitud de envío envía opciones de localización para que el cliente muestre mensajes localizados. A continuación se muestra una aproximación del efecto visual en el dispositivo de un usuario:

Dibujo simple de dos dispositivos que muestran texto en inglés y español.

Nodo.js

var topicName = 'industry-tech';

var message = {
  android: {
    ttl: 3600000,
    notification: {
      bodyLocKey: 'STOCK_NOTIFICATION_BODY',
      bodyLocArgs: ['FooCorp', '11.80', '835.67', '1.43']
    }
  },
  apns: {
    payload: {
      aps: {
        alert: {
          locKey: 'STOCK_NOTIFICATION_BODY',
          locArgs: ['FooCorp', '11.80', '835.67', '1.43']
        }
      }
    }
  },
  topic: topicName,
};

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

DESCANSAR

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"],
                    },
                 },
               },
             },
  },
}'

Consulte la documentación de referencia de HTTP v1 para obtener detalles completos sobre las claves disponibles en bloques específicos de la plataforma en el cuerpo del mensaje.

Códigos de error de administrador

La siguiente tabla enumera los códigos de error de la API FCM de Firebase Admin y sus descripciones, incluidos los pasos de resolución recomendados.

Código de error Descripción y pasos de resolución
messaging/invalid-argument Se proporcionó un argumento no válido para un método FCM. El mensaje de error debe contener información adicional.
messaging/invalid-recipient El destinatario del mensaje previsto no es válido. El mensaje de error debe contener información adicional.
messaging/invalid-payload Se proporcionó un objeto de carga útil de mensaje no válido. El mensaje de error debe contener información adicional.
messaging/invalid-data-payload-key La carga útil del mensaje de datos contiene una clave no válida. Consulte la documentación de referencia de DataMessagePayload para obtener claves restringidas.
messaging/payload-size-limit-exceeded La carga útil del mensaje proporcionada supera los límites de tamaño de FCM. El límite es 4096 bytes para la mayoría de los mensajes. Para mensajes enviados a temas, el límite es 2048 bytes. El tamaño total de la carga útil incluye claves y valores.
messaging/invalid-options Se proporcionó un objeto de opciones de mensaje no válido. El mensaje de error debe contener información adicional.
messaging/invalid-registration-token Se proporcionó un token de registro no válido. Asegúrese de que coincida con el token de registro que recibe la aplicación cliente al registrarse en FCM. No lo trunques ni le agregues caracteres adicionales.
messaging/registration-token-not-registered El token de registro proporcionado no está registrado. Se puede cancelar el registro de un token de registro previamente válido por diversos motivos, entre los que se incluyen:
  • La aplicación cliente se dio de baja de FCM.
  • La aplicación cliente se canceló automáticamente. Esto puede suceder si el usuario desinstala la aplicación o, en las plataformas Apple, si el servicio de comentarios de APN informa que el token de APN no es válido.
  • El token de registro expiró. Por ejemplo, Google podría decidir actualizar los tokens de registro o es posible que el token APN haya caducado para los dispositivos Apple.
  • La aplicación cliente se actualizó, pero la nueva versión no está configurada para recibir mensajes.
Para todos estos casos, elimina este token de registro y deja de usarlo para enviar mensajes.
messaging/invalid-package-name El mensaje se dirigió a un token de registro cuyo nombre de paquete no coincide con la opción de restrictedPackageName proporcionada.
messaging/message-rate-exceeded La tasa de mensajes a un objetivo particular es demasiado alta. Reduzca la cantidad de mensajes enviados a este dispositivo o tema y no vuelva a intentar enviarlos inmediatamente a este destino.
messaging/device-message-rate-exceeded La tasa de mensajes a un dispositivo en particular es demasiado alta. Reduzca la cantidad de mensajes enviados a este dispositivo y no vuelva a intentar enviarlos inmediatamente.
messaging/topics-message-rate-exceeded La tasa de mensajes a suscriptores de un tema en particular es demasiado alta. Reduzca la cantidad de mensajes enviados para este tema y no vuelva a intentar enviarlos inmediatamente.
messaging/too-many-topics Se ha suscrito un token de registro al número máximo de temas y ya no se puede suscribir.
messaging/invalid-apns-credentials No se pudo enviar un mensaje dirigido a un dispositivo Apple porque el certificado SSL de APN requerido no se cargó o expiró. Consulta la validez de tus certificados de desarrollo y producción.
messaging/mismatched-credential La credencial utilizada para autenticar este SDK no tiene permiso para enviar mensajes al dispositivo correspondiente al token de registro proporcionado. Asegúrese de que la credencial y el token de registro pertenezcan al mismo proyecto de Firebase. Consulta Agregar Firebase a tu aplicación para obtener documentación sobre cómo autenticar los SDK de Firebase Admin.
messaging/authentication-error El SDK no pudo autenticarse en los servidores FCM. Asegúrese de autenticar el SDK de administrador de Firebase con una credencial que tenga los permisos adecuados para enviar mensajes FCM. Consulta Agregar Firebase a tu aplicación para obtener documentación sobre cómo autenticar los SDK de Firebase Admin.
messaging/server-unavailable El servidor FCM no pudo procesar la solicitud a tiempo. Debe volver a intentar la misma solicitud, pero debe:
  • Respete el encabezado Retry-After si está incluido en la respuesta del servidor de conexión FCM.
  • Implemente un retroceso exponencial en su mecanismo de reintento. Por ejemplo, si esperó un segundo antes del primer reintento, espere al menos dos segundos antes del siguiente, luego cuatro segundos, y así sucesivamente. Si envía varios mensajes, retrase cada uno de ellos de forma independiente una cantidad aleatoria adicional para evitar emitir una nueva solicitud para todos los mensajes al mismo tiempo.
Los remitentes que causan problemas corren el riesgo de ser incluidos en la lista negra.
messaging/internal-error El servidor FCM encontró un error al intentar procesar la solicitud. Puede volver a intentar la misma solicitud siguiendo los requisitos enumerados en la fila messaging/server-unavailable anterior. Si el error persiste, informe el problema a nuestro canal de soporte de Informe de errores .
messaging/unknown-error Se devolvió un error de servidor desconocido. Consulte la respuesta sin formato del servidor en el mensaje de error para obtener más detalles. Si recibe este error, informe el mensaje de error completo a nuestro canal de soporte de Informe de errores .

Enviar mensajes utilizando los protocolos del servidor de aplicaciones heredados

Si actualmente utiliza protocolos heredados, cree solicitudes de mensajes como se muestra en esta sección. Tenga en cuenta que, si envía a varias plataformas a través de HTTP, el protocolo v1 puede simplificar enormemente sus solicitudes de mensajes.

Enviar mensajes a dispositivos específicos

Para enviar mensajes a dispositivos específicos, configure la clave to en el token de registro para la instancia de aplicación específica. Consulte la información de configuración del cliente para su plataforma para obtener más información sobre los tokens de registro.

Solicitud de publicación HTTP

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

respuesta HTTP

{ "multicast_id": 108,
  "success": 1,
  "failure": 0,
  "results": [
    { "message_id": "1:08" }
  ]
}

mensaje XMPP

<message id="">
  <gcm xmlns="google:mobile:data">
    { "data": {
      "score": "5x1",
      "time": "15:10"
    },
    "to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
  }
  </gcm>
</message>

respuesta XMPP

<message id="">
  <gcm xmlns="google:mobile:data">
  {
      "from":"REGID",
      "message_id":"m-1366082849205"
      "message_type":"ack"
  }
  </gcm>
</message>

El servidor de conexión XMPP proporciona algunas otras opciones de respuesta. Consulte Formato de respuesta del servidor .

Para obtener la lista completa de opciones de mensajes disponibles al enviar mensajes descendentes a aplicaciones cliente, consulte la información de referencia para el protocolo de servidor de conexión elegido, HTTP o XMPP .

Enviar mensajes a temas

Enviar mensajes a un tema de Firebase Cloud Messaging es muy similar a enviar mensajes a un dispositivo individual o a un grupo de usuarios. El servidor de aplicaciones establece la clave to con un valor como /topics/yourTopic . Los desarrolladores pueden elegir cualquier nombre de tema que coincida con la expresión regular: "/topics/[a-zA-Z0-9-_.~%]+" .

Para enviar combinaciones de varios temas, el servidor de aplicaciones debe establecer la clave condition (en lugar de la clave to ) en una condición booleana que especifique los temas de destino. Por ejemplo, para enviar mensajes a dispositivos que se suscribieron a TopicA y a TopicB o TopicC :

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

FCM primero evalúa las condiciones entre paréntesis y luego evalúa la expresión de izquierda a derecha. En la expresión anterior, un usuario suscrito a un solo tema no recibe el mensaje. Asimismo, un usuario que no está suscrito a TopicA no recibe el mensaje. Estas combinaciones sí lo reciben:

  • TemaA y TemaB
  • TemaA y TemaC

Puede incluir hasta cinco temas en su expresión condicional y se admiten paréntesis. Operadores admitidos: && , || .

Tema Solicitud POST HTTP

Enviar a un solo tema:

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


Enviar a dispositivos suscritos a los temas "perros" o "gatos":

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


Respuesta HTTP del tema

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

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

Tema mensaje XMPP

Enviar a un solo tema:

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


  </gcm>
</message>

Enviar a dispositivos suscritos a los temas "perros" o "gatos":

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


  </gcm>
</message>

Tema Respuesta XMPP

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

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

Espere hasta 30 segundos de retraso antes de que el servidor FCM devuelva una respuesta de éxito o fracaso a las solicitudes de envío de temas. Asegúrese de configurar el valor de tiempo de espera del servidor de aplicaciones en la solicitud en consecuencia.

Enviar mensajes a grupos de dispositivos

Enviar mensajes a un grupo de dispositivos utilizando las API heredadas y obsoletas es muy similar a enviar mensajes a un dispositivo individual. Establezca el parámetro to en la clave de notificación única para el grupo de dispositivos. Los ejemplos de esta sección muestran cómo enviar mensajes de datos a grupos de dispositivos en los protocolos HTTP y XMPP heredados.

Solicitud POST HTTP de grupo de dispositivos

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

Respuesta HTTP del grupo de dispositivos

A continuación se muestra un ejemplo de "éxito": la notification_key tiene 2 tokens de registro asociados y el mensaje se envió correctamente a ambos:

{
  "success": 2,
  "failure": 0
}

A continuación se muestra un ejemplo de "éxito parcial": la notification_key tiene 3 tokens de registro asociados. El mensaje se envió correctamente solo a 1 de los tokens de registro. El mensaje de respuesta enumera los tokens de registro ( registration_ids ) que no pudieron recibir el mensaje:

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

Cuando un mensaje no se entrega a uno o más de los tokens de registro asociados con una notification_key , el servidor de aplicaciones debe volver a intentarlo con pausas entre reintentos.

Si el servidor intenta enviar un mensaje a un grupo de dispositivos que no tiene miembros, la respuesta se parece a la siguiente, con 0 éxitos y 0 fracasos:

{
  "success": 0,
  "failure": 0
}

Mensaje XMPP del grupo de dispositivos

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

Respuesta XMPP del grupo de dispositivos

Cuando el mensaje se envía correctamente a cualquiera de los dispositivos del grupo, el servidor de conexión XMPP responde con un ACK. Si todos los mensajes enviados a todos los dispositivos del grupo fallan, el servidor de conexión XMPP responde con un NACK.

A continuación se muestra un ejemplo de "éxito": la notification_key tiene 3 tokens de registro asociados y el mensaje se envió correctamente a todos ellos:

{
  "from": "aUniqueKey",
  "message_type": "ack",
  "success": 3,
  "failure": 0,
  "message_id": "m-1366082849205"
}

A continuación se muestra un ejemplo de "éxito parcial": la notification_key tiene 3 tokens de registro asociados. El mensaje se envió correctamente solo a 1 de los tokens de registro. El mensaje de respuesta enumera los tokens de registro que no pudieron recibir el mensaje:

{
  "from": "aUniqueKey",
  "message_type": "ack",
  "success":1,
  "failure":2,
  "failed_registration_ids":[
     "regId1",
     "regId2"
  ]
}

Cuando el servidor de conexión FCM no logra entregar a todos los dispositivos del grupo. El servidor de aplicaciones recibirá una respuesta negativa.

Para obtener la lista completa de opciones de mensajes, consulte la información de referencia del protocolo de servidor de conexión elegido, HTTP o XMPP .

Métodos de envío heredados del SDK de Firebase Admin

El SDK de Firebase Admin Node.js admite métodos para enviar mensajes (FCM) basados ​​en la API del servidor Legacy FCM . Estos métodos aceptan argumentos diferentes en comparación con el método send() . Debe utilizar el método send() siempre que sea posible y utilizar únicamente los métodos descritos en esta página al enviar mensajes a dispositivos individuales o grupos de dispositivos.

Enviar a dispositivos individuales

Puedes pasar un token de registro al método sendToDevice() para enviar un mensaje a ese dispositivo:

Nodo.js

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

// See the "Defining the message payload" section below for details
// on how to define a message payload.
const payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};

// Send a message to the device corresponding to the provided
// registration token.
getMessaging().sendToDevice(registrationToken, payload)
  .then((response) => {
    // See the MessagingDevicesResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

El método sendToDevice() también puede enviar un mensaje de multidifusión (es decir, un mensaje a múltiples dispositivos) pasando una serie de tokens de registro en lugar de solo un token de registro:

Nodo.js

// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...',
  // ...
  'ecupwIfBy1w:APA91bFtuMY7MktgxA3Au_Qx7cKqnf...'
];

// See the "Defining the message payload" section below for details
// on how to define a message payload.
const payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};

// Send a message to the devices corresponding to the provided
// registration tokens.
getMessaging().sendToDevice(registrationTokens, payload)
  .then((response) => {
    // See the MessagingDevicesResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

El método sendToDevice() devuelve una promesa que se resuelve con un objeto MessagingDevicesResponse que contiene la respuesta de FCM. El tipo de devolución tiene el mismo formato cuando se pasa un único token de registro o una serie de tokens de registro.

Algunos casos, como un error de autenticación o una limitación de velocidad, hacen que no se procese la totalidad del mensaje. En estos casos, la promesa devuelta por sendToDevice() se rechaza con un error. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de API de Admin FCM .

Enviar a un grupo de dispositivos

El método sendToDeviceGroup() le permite enviar un mensaje a un grupo de dispositivos especificando la clave de notificación para ese grupo de dispositivos:

Nodo.js

// See the "Managing device groups" link above on how to generate a
// notification key.
const notificationKey = 'some-notification-key';

// See the "Defining the message payload" section below for details
// on how to define a message payload.
const payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};

// Send a message to the device group corresponding to the provided
// notification key.
getMessaging().sendToDeviceGroup(notificationKey, payload)
  .then((response) => {
    // See the MessagingDeviceGroupResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

El método sendToDeviceGroup() devuelve una promesa que se resuelve con un objeto MessagingDevicesResponse que contiene la respuesta de FCM.

Algunos casos, como un error de autenticación o una limitación de velocidad, hacen que no se procese la totalidad del mensaje. En estos casos, la promesa devuelta por sendToDeviceGroup() se rechaza con un error. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de API de Admin FCM .

Definición de la carga útil del mensaje

Los métodos anteriores basados ​​en los protocolos heredados de FCM aceptan una carga útil de mensaje como segundo argumento y admiten mensajes de notificación y de datos . Puede especificar uno o ambos tipos de mensajes creando un objeto con las claves data y/o notification . Por ejemplo, aquí se explica cómo definir diferentes tipos de cargas útiles de mensajes:

Mensaje de notificación

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.'
  }
};

mensaje de datos

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

mensaje combinado

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

Las cargas útiles de mensajes de notificación tienen un subconjunto predefinido de propiedades válidas y difieren ligeramente según el sistema operativo móvil al que se dirige. Consulte los documentos de referencia de NotificationMessagePayload para obtener una lista completa.

Las cargas útiles de mensajes de datos se componen de pares clave-valor personalizados con algunas restricciones, incluido el hecho de que todos los valores deben ser cadenas. Consulte los documentos de referencia de DataMessagePayload para obtener una lista completa de restricciones.

Definición de las opciones de mensaje

Los métodos anteriores basados ​​en los protocolos heredados de FCM aceptan un tercer argumento opcional que especifica algunas opciones para el mensaje. Por ejemplo, el siguiente ejemplo envía un mensaje de alta prioridad a un dispositivo que caduca después de 24 horas:

Nodo.js

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

// See the "Defining the message payload" section above for details
// on how to define a message payload.
const payload = {
  notification: {
    title: 'Urgent action needed!',
    body: 'Urgent action is needed to prevent your account from being disabled!'
  }
};

// Set the message as high priority and have it expire after 24 hours.
const options = {
  priority: 'high',
  timeToLive: 60 * 60 * 24
};

// Send a message to the device corresponding to the provided
// registration token with the provided options.
getMessaging().sendToDevice(registrationToken, payload, options)
  .then((response) => {
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Consulte los documentos de referencia de MessagingOptions para obtener una lista completa de las opciones disponibles.