Entérate de todos los anuncios de Firebase Summit y descubre cómo Firebase puede ayudarte a acelerar el desarrollo de las apps y a ejecutarlas con confianza. Más información

Crear solicitudes de envío del servidor de aplicaciones

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Con los protocolos del servidor de aplicaciones Firebase Admin SDK o FCM, puede generar solicitudes de mensajes y enviarlas a estos tipos de objetivos:

  • Nombre del tema
  • Condición
  • Token de registro del dispositivo
  • Nombre del grupo de dispositivos (protocolos heredados y SDK de Firebase Admin solo para Node.js)

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 Firebase Admin SDK (que es compatible con Node , Java , Python , C# y Go ) y el protocolo v1 HTTP . También hay una guía para enviar mensajes a través de los protocolos heredados HTTP y XMPP .

Enviar mensajes a dispositivos específicos

Para enviar a un solo dispositivo 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)

Vamos

// 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 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 caso de éxito, cada método de envío devuelve un ID de mensaje. El SDK de administración de Firebase 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 varios dispositivos

La API de REST y las API de administración de FCM le permiten transmitir 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))

Vamos

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

DESCANSAR

Construya una solicitud por lotes HTTP:

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary

POST /v1/projects/myproject-b5ae1/messages:send
Content-Type: application/json
accept: application/json

{
  "message":{
     "token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...",
     "notification":{
       "title":"FCM Message",
       "body":"This is an FCM notification message!"
     }
  }
}

...

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary

POST /v1/projects/myproject-b5ae1/messages:send
Content-Type: application/json
accept: application/json

{
  "message":{
     "token":"cR1rjyj4_Kc:APA91bGusqbypSuMdsh7jSNrW4nzsM...",
     "notification":{
       "title":"FCM Message",
       "body":"This is an FCM notification message!"
     }
  }
}
--subrequest_boundary--

Guarde la solicitud en un archivo (en este ejemplo, batch_request.txt). Luego usa el comando cURL:

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

Para los SDK de Firebase Admin, esta operación usa la API sendAll() bajo el capó, como se muestra en los ejemplos. El valor devuelto es un BatchResponse cuya lista de respuestas 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))

Vamos

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

DESCANSAR

Cada envío secundario devuelve una respuesta. Las respuestas están separadas por una cadena límite de respuesta que comienza con --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--

Enviar mensajes a temas

Una vez que haya creado un tema, ya sea mediante la suscripción de instancias de la aplicación cliente al tema en el lado del cliente o a través de 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)

Vamos

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

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 los dispositivos que están suscritos a TopicA y TopicB o TopicC :

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

FCM primero evalúa cualquier condición 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 se suscriba 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)

Vamos

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

Enviar un lote de mensajes

La API de REST y 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 a la API, con una mejora significativa del rendimiento en comparación con el 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))

Vamos

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

DESCANSAR

Construya una solicitud por lotes HTTP combinando una lista de subsolicitudes:

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary

POST /v1/projects/myproject-b5ae1/messages:send
Content-Type: application/json
accept: application/json

{
  "message":{
     "token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...",
     "notification":{
       "title":"FCM Message",
       "body":"This is an FCM notification message to device 0!"
     }
  }
}

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary

POST /v1/projects/myproject-b5ae1/messages:send
Content-Type: application/json
accept: application/json

{
  "message":{
     "topic":"readers-club",
     "notification":{
       "title":"Price drop",
       "body":"2% off all books"
     }
  }
}

...

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary
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--

Puede consultar el BatchResponse devuelto para comprobar cuántos de los mensajes se entregaron correctamente a FCM. También expone una lista de respuestas que se pueden utilizar para comprobar el estado de los mensajes individuales. El orden de las respuestas corresponde al orden de los mensajes en la lista de entrada.

Enviar mensajes habilitados para arranque directo (solo Android)

Puede enviar mensajes a dispositivos en modo de inicio directo utilizando HTTP v1 o 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 usando 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 usando 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 arranque directo (y también cuando no están en ese modo).

Personaliza los mensajes en todas las plataformas

Tanto el SDK de administración de Firebase como el protocolo HTTP de FCM v1 permiten que sus solicitudes de mensajes configuren todos los campos disponibles en el objeto del message . Esto incluye:

  • un conjunto común de campos que deben interpretar 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 las instancias de la aplicación que se ejecutan en la plataforma especificada.

Los bloques específicos de la plataforma le brindan flexibilidad para personalizar los 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 usar campos comunes

Utilice campos comunes cuando esté:

  • Dirigirse a instancias de aplicaciones en todas las plataformas: Apple, Android y web
  • Envío de mensajes a temas

Todas las instancias de la aplicación, independientemente de la plataforma, pueden interpretar los siguientes campos comunes:

Cuándo usar campos específicos de la plataforma

Utilice campos específicos de la plataforma cuando desee:

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

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

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

Ejemplo: mensaje de notificación con opciones de color e icono

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

Aquí hay 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',
)

Vamos

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 los 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. Aquí hay una aproximación del efecto visual en el dispositivo de un usuario:

Dibujo simple de una imagen en una notificación de visualización

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 los 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. Aquí hay una aproximación del efecto visual en el dispositivo de un usuario:

Dibujo simple de un toque de usuario que abre 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 los 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. Aquí hay 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 los bloques específicos de la plataforma en el cuerpo del mensaje.

Códigos de error del administrador

En la siguiente tabla, se enumeran los códigos de error de la API de Firebase Admin FCM 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 a 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 de mensaje no válido. El mensaje de error debe contener información adicional.
messaging/invalid-data-payload-key La carga del mensaje de datos contiene una clave no válida. Consulte la documentación de referencia de DataMessagePayload para conocer las claves restringidas.
messaging/payload-size-limit-exceeded La carga del mensaje proporcionado supera los límites de tamaño de FCM. El límite es de 4096 bytes para la mayoría de los mensajes. Para mensajes enviados a temas, el límite es de 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 Token de registro proporcionado no válido. Asegúrese de que coincida con el token de registro que recibe la aplicación del cliente al registrarse en FCM. No lo trunque ni le agregue caracteres adicionales.
messaging/registration-token-not-registered El token de registro proporcionado no está registrado. Un token de registro previamente válido puede cancelarse por una variedad de razones, que incluyen:
  • La aplicación del cliente canceló su registro de FCM.
  • La aplicación del cliente se canceló automáticamente. Esto puede suceder si el usuario desinstala la aplicación o, en las plataformas de Apple, si el servicio de comentarios de APN informa que el token de APN no es válido.
  • El token de registro caducó. Por ejemplo, es posible que Google decida actualizar los tokens de registro o que el token de APN haya caducado para los dispositivos de Apple.
  • La aplicación cliente se actualizó, pero la nueva versión no está configurada para recibir mensajes.
Para todos estos casos, elimine este token de registro y deje de usarlo para enviar mensajes.
messaging/invalid-package-name El mensaje estaba dirigido a un token de registro cuyo nombre de paquete no coincide con la opción de nombre de paquete restrictedPackageName proporcionada.
messaging/message-rate-exceeded La tasa de mensajes a un objetivo en 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 los 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 caducó. Consulta la vigencia 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. Consulte Agregar Firebase a su aplicación para obtener documentación sobre cómo autenticar los SDK de administrador de Firebase.
messaging/authentication-error El SDK no pudo autenticarse en los servidores de FCM. Asegúrese de autenticar el SDK de administrador de Firebase con una credencial que tenga los permisos adecuados para enviar mensajes de FCM. Consulte Agregar Firebase a su aplicación para obtener documentación sobre cómo autenticar los SDK de administrador de Firebase.
messaging/server-unavailable El servidor FCM no pudo procesar la solicitud a tiempo. Debe volver a intentar la misma solicitud, pero debe:
  • Retry-After si está incluido en la respuesta del servidor de conexión de 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 está enviando varios mensajes, retrase cada uno de forma independiente por 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 de FCM encontró un error al intentar procesar la solicitud. Puede volver a intentar la misma solicitud siguiendo los requisitos enumerados en la fila anterior messaging/server-unavailable . 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 del servidor sin procesar 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.

Envíe mensajes utilizando los protocolos del servidor de aplicaciones heredados

Si prefiere usar los protocolos heredados, cree solicitudes de mensajes como se muestra en esta sección. Tenga en cuenta que, si está enviando a múltiples plataformas a través de HTTP, el protocolo v1 puede simplificar sus solicitudes de mensajes.

Enviar mensajes a dispositivos específicos

Para enviar mensajes a dispositivos específicos, configure la tecla 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 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..."
}

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 para las respuestas. Consulte Formato de respuesta del servidor .

Para ver la lista completa de opciones de mensajes disponibles cuando se envían 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 tecla 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 a combinaciones de varios temas, el servidor de aplicaciones debe establecer la clave de 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 TopicB o TopicC :

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

FCM primero evalúa cualquier condición 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 se suscriba 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 HTTP POST

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 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 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 falla a las solicitudes de envío de temas. Asegúrese de establecer 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 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. Consulte Tipos de mensajes para obtener detalles sobre el soporte de carga útil. Los ejemplos de esta página muestran cómo enviar mensajes de datos a grupos de dispositivos en los protocolos heredados HTTP y XMPP.

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

Este es 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
}

Este es un ejemplo de "éxito parcial": la notification_key tiene 3 tokens de registro asociados. El mensaje se envió con éxito 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 la aplicación debe volver a intentarlo con un retroceso entre reintentos.

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

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

Este es un ejemplo de "éxito": la notification_key tiene 3 tokens de registro asociados y el mensaje se envió con éxito a todos ellos:

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

Este es un ejemplo de "éxito parcial": la notification_key tiene 3 tokens de registro asociados. El mensaje se envió con éxito 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 de FCM no puede entregar a todos los dispositivos del grupo. El servidor de aplicaciones recibirá una respuesta negativa.

Para ver 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 administrador de Firebase

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 diferentes argumentos en comparación con el método send() . Debe usar el método send() siempre que sea posible, y solo use los métodos descritos en esta página cuando envíe mensajes a dispositivos individuales o grupos de dispositivos.

Enviar a dispositivos individuales

Puede 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 varios dispositivos) al pasar una matriz de tokens de registro en lugar de solo un token de registro único:

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 retorno tiene el mismo formato cuando se pasa un solo token de registro o una matriz de tokens de registro.

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

Enviar a un grupo de dispositivos

La mensajería de grupo de dispositivos le permite agregar varios dispositivos a un solo grupo. Esto es similar a la mensajería de temas, pero incluye autenticación para garantizar que la membresía del grupo sea administrada solo por sus servidores. Por ejemplo, si desea enviar diferentes mensajes a diferentes modelos de teléfonos, sus servidores pueden agregar/eliminar registros a los grupos apropiados y enviar el mensaje apropiado a cada grupo. La mensajería de grupos de dispositivos se diferencia de la mensajería de temas en que implica administrar grupos de dispositivos desde sus servidores en lugar de directamente dentro de su aplicación.

Puede usar la mensajería de grupos de dispositivos a través de los protocolos heredados XMPP o HTTP en su servidor de aplicaciones. Las versiones anteriores del SDK de administrador de Firebase para Node.js se basan en los protocolos heredados y también brindan capacidades de mensajería de grupo de dispositivos. El número máximo de miembros permitidos para una clave de notificación es 20.

Puede crear grupos de dispositivos y generar claves de notificación a través de un servidor de aplicaciones o un cliente de Android. Consulte Administrar grupos de dispositivos para obtener más información.

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 la totalidad del mensaje no se procese. En estos casos, la promesa devuelta por sendToDeviceGroup() se rechaza con un error. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de la 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 su segundo argumento y admiten tanto mensajes de notificación como de datos . Puede especificar uno o ambos tipos de mensajes creando un objeto con las claves de 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 los 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 los 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.