Catch up on everything we announced at this year's Firebase Summit. Learn more

Crea richieste di invio del server dell'app

Utilizzando l'SDK di amministrazione Firebase o i protocolli del server dell'app FCM, puoi creare richieste di messaggi e inviarle a questi tipi di destinazioni:

  • Nome argomento
  • Condizione
  • Token di registrazione del dispositivo
  • Nome del gruppo di dispositivi (protocolli legacy e Firebase Admin SDK solo per Node.js)

È possibile inviare messaggi con un payload di notifica composto da campi predefiniti, un payload di dati dei propri campi definiti dall'utente o un messaggio contenente entrambi i tipi di payload. Vedere i tipi di messaggio per ulteriori informazioni.

Gli esempi in questa pagina mostrano come inviare i messaggi di notifica utilizzando il Firebase Admin SDK (che ha il supporto per nodo , Java , Python , C # , e Go ) e il protocollo HTTP v1 . C'è anche una guida per l'invio di messaggi tramite l' HTTP legacy e protocolli XMPP .

Invia messaggi a dispositivi specifici

Per inviare a un singolo dispositivo specifico, passa il token di registrazione del dispositivo come mostrato. Consulta le informazioni sulla configurazione del client per la tua piattaforma per ulteriori informazioni sui token di registrazione.

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

Giava

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

Pitone

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

andare

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

RIPOSO

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

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

In caso di successo, ogni metodo di invio restituisce un ID messaggio. Il Firebase Admin SDK restituisce la stringa ID nel formato projects/{project_id}/messages/{message_id} . La risposta del protocollo HTTP è una singola chiave JSON:

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

Invia messaggi a più dispositivi

L'API REST e le API Admin FCM consentono di inviare in multicast un messaggio a un elenco di token di registrazione del dispositivo. Puoi specificare fino a 500 token di registrazione del dispositivo per chiamata.

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

Giava

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

Pitone

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

andare

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

RIPOSO

Costruisci una richiesta batch HTTP:

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

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

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

...

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

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

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

Salva la richiesta in un file (in questo esempio batch_request.txt). Quindi usa il comando cURL:

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

Per Firebase Admin SDK, questa operazione utilizza il sendAll() API sotto il cofano, come mostrato negli esempi. Il valore di ritorno è un BatchResponse cui risposte lista corrisponde all'ordine dei token di ingresso. Ciò è utile quando si desidera verificare quali token hanno generato errori.

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

Giava

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

Pitone

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

andare

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

RIPOSO

Ogni sub-invio di invio restituisce una risposta. Le risposte sono separati da una stringa confine risposta iniziano --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--

Invia messaggi agli argomenti

Dopo aver creato un argomento, sia sottoscrivendo istanze client App al tema sul lato client oppure tramite l' API del server , è possibile inviare messaggi al tema. Se questa è la prima volta che la costruzione di richieste di trasmissione per FCM, consultare la guida per l'ambiente server e FCM per importanti e le informazioni di configurazione.

Nella tua logica di invio sul backend, specifica il nome dell'argomento desiderato come mostrato:

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

Giava

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

Pitone

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

andare

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

RIPOSO

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

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

Per inviare un messaggio a una combinazione di argomenti, specificare una condizione, che è un'espressione booleana che specifica gli argomenti di destinazione. Ad esempio, la seguente condizione inviare messaggi a dispositivi che sono iscritti a TopicA e sia TopicB o TopicC :

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

FCM valuta prima le condizioni tra parentesi, quindi valuta l'espressione da sinistra a destra. Nell'espressione sopra, un utente iscritto a un singolo argomento non riceve il messaggio. Allo stesso modo, un utente che non sottoscrivere TopicA non riceve il messaggio. Queste combinazioni lo ricevono:

  • TopicA e TopicB
  • TopicA e TopicC

Puoi includere fino a cinque argomenti nell'espressione condizionale.

Per inviare a una condizione:

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

Giava

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

Pitone

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

andare

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

RIPOSO

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

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

Invia una serie di messaggi

L'API REST e gli SDK di amministrazione supportano l'invio di messaggi in batch. Puoi raggruppare fino a 500 messaggi in un singolo batch e inviarli tutti in un'unica chiamata API, con un significativo miglioramento delle prestazioni rispetto all'invio di richieste HTTP separate per ciascun messaggio.

Questa funzione può essere utilizzata per creare un set personalizzato di messaggi e inviarli a destinatari diversi, inclusi argomenti o token di registrazione del dispositivo specifici. Utilizzare questa funzione quando, ad esempio, è necessario inviare contemporaneamente messaggi a un pubblico diverso con dettagli leggermente diversi nel corpo del messaggio.

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

Giava

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

Pitone

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

andare

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

RIPOSO

Costruisci una richiesta batch HTTP combinando un elenco di richieste secondarie:

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

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

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

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

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

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

...

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

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

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

È possibile interrogare il restituita BatchResponse per verificare come molti dei messaggi sono stati passata ad FCM successo. Espone anche un elenco di risposte che possono essere utilizzate per verificare lo stato dei singoli messaggi. L'ordine delle risposte corrisponde all'ordine dei messaggi nell'elenco di input.

Invia messaggi abilitati all'avvio diretto (solo Android)

Puoi inviare messaggi ai dispositivi in ​​modalità di avvio diretto utilizzando HTTP v1 o API HTTP legacy. Prima di inviare ai dispositivi in modalità di avvio diretta, assicurarsi di aver completato la procedura per abilitare i dispositivi client per ricevere i messaggi FCM in modalità di avvio diretta .

Invia utilizzando l'API HTTP FCM v1

Il messaggio di richiesta deve includere la chiave "direct_boot_ok" : true nelle AndroidConfig opzioni del corpo della richiesta. Per esempio:

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

Invia utilizzando l'API HTTP legacy di FCM

Il messaggio di richiesta deve includere la chiave "direct_boot_ok" : true al livello superiore del corpo della richiesta. Per esempio:

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
}

I messaggi inviati con questa chiave nel corpo della richiesta possono essere gestiti dalle app sui dispositivi attualmente in modalità di avvio diretto (e anche quando non sono in tale modalità).

Personalizza i messaggi su più piattaforme

Il Firebase Admin SDK e il protocollo HTTP FCM v1 sia permettono le richieste di messaggi per impostare tutti i campi disponibili nel message oggetto. Ciò comprende:

  • un insieme comune di campi per essere interpretato da tutte le istanze app che ricevono il messaggio.
  • set di piattaforma-specifici di campi, come AndroidConfig e WebpushConfig , interpretati solo da istanze app in esecuzione sulla piattaforma specificata.

I blocchi specifici della piattaforma offrono la flessibilità di personalizzare i messaggi per piattaforme diverse per garantire che vengano gestiti correttamente una volta ricevuti. Il backend FCM terrà conto di tutti i parametri specificati e personalizzerà il messaggio per ciascuna piattaforma.

Quando utilizzare i campi comuni

Utilizza i campi comuni quando:

  • Identificazione di istanze di app su tutte le piattaforme - Apple, Android, e web
  • Invio di messaggi agli argomenti

Tutte le istanze dell'app, indipendentemente dalla piattaforma, possono interpretare i seguenti campi comuni:

Quando utilizzare i campi specifici della piattaforma

Utilizza i campi specifici della piattaforma quando desideri:

  • Invia campi solo a piattaforme particolari
  • Invia campi piattaforma specifici in aggiunta ai campi comuni

Ogni volta che si desidera inviare i valori solo per piattaforme particolari, non utilizzare campi comuni; utilizzare campi specifici della piattaforma. Ad esempio, per inviare una notifica solo alle piattaforme Apple e al web ma non ad Android, è necessario utilizzare due set di campi separati, uno per Apple e uno per il web.

Quando si inviano messaggi con specifiche opzioni di consegna , i campi specifici delle piattaforme utilizzare per impostare loro. Se lo desideri, puoi specificare valori diversi per piattaforma. Tuttavia, anche quando si desidera impostare essenzialmente lo stesso valore tra piattaforme, è necessario utilizzare campi specifici della piattaforma. Questo perché ogni piattaforma può interpretare il valore in modo leggermente diverso, ad esempio, il time-to-live è impostato su Android come un tempo di scadenza in secondi, mentre su Apple è impostato come una data di scadenza.

Esempio: messaggio di notifica con opzioni di colore e icona

Questa richiesta di invio di esempio invia un titolo e un contenuto di notifica comuni a tutte le piattaforme, ma invia anche alcune sostituzioni specifiche della piattaforma ai dispositivi Android.

Per Android, la richiesta imposta un'icona e un colore speciali da visualizzare sui dispositivi Android. Come notato nel riferimento per AndroidNotification , il colore è specificato in formato #RRGGBB, e l'immagine deve essere una risorsa icona disegnabile locale per l'applicazione Android.

Ecco un'approssimazione dell'effetto visivo sul dispositivo di un utente:

Disegno semplice di due dispositivi, uno dei quali visualizza un'icona e un colore personalizzati

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

Giava

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

Pitone

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

andare

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

RIPOSO

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

Vedere la documentazione di riferimento v1 HTTP per dettaglio completo sui tasti disponibili in blocchi di piattaforma-specifici nel corpo del messaggio.

Esempio: messaggio di notifica con un'immagine personalizzata

La richiesta di invio di esempio seguente invia un titolo di notifica comune a tutte le piattaforme, ma invia anche un'immagine. Ecco un'approssimazione dell'effetto visivo sul dispositivo di un utente:

Semplice disegno di un'immagine in una notifica sul display

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

RIPOSO

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

Vedere la documentazione di riferimento v1 HTTP per dettaglio completo sui tasti disponibili in blocchi di piattaforma-specifici nel corpo del messaggio.

Esempio: messaggio di notifica con un'azione di clic associata

La richiesta di invio di esempio seguente invia un titolo di notifica comune a tutte le piattaforme, ma invia anche un'azione che l'app deve eseguire in risposta all'interazione dell'utente con la notifica. Ecco un'approssimazione dell'effetto visivo sul dispositivo di un utente:

Disegno semplice di un tocco dell'utente che apre una pagina 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);
  });

RIPOSO

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

Vedere la documentazione di riferimento v1 HTTP per dettaglio completo sui tasti disponibili in blocchi di piattaforma-specifici nel corpo del messaggio.

Esempio: messaggio di notifica con opzioni di localizzazione

La seguente richiesta di invio di esempio invia le opzioni di localizzazione per consentire al client di visualizzare i messaggi localizzati. Ecco un'approssimazione dell'effetto visivo sul dispositivo di un utente:

Disegno semplice di due dispositivi con testo in inglese e spagnolo

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

RIPOSO

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

Vedere la documentazione di riferimento v1 HTTP per dettaglio completo sui tasti disponibili in blocchi di piattaforma-specifici nel corpo del messaggio.

Codici di errore dell'amministratore

La tabella seguente elenca i codici di errore dell'API Firebase Admin FCM e le relative descrizioni, inclusi i passaggi di risoluzione consigliati.

Codice di errore Descrizione e passaggi di risoluzione
messaging/invalid-argument È stato fornito un argomento non valido a un metodo FCM. Il messaggio di errore dovrebbe contenere ulteriori informazioni.
messaging/invalid-recipient Il destinatario del messaggio previsto non è valido. Il messaggio di errore dovrebbe contenere ulteriori informazioni.
messaging/invalid-payload È stato fornito un oggetto payload del messaggio non valido. Il messaggio di errore dovrebbe contenere ulteriori informazioni.
messaging/invalid-data-payload-key Il payload del messaggio di dati contiene una chiave non valida. Vedere la documentazione di riferimento per DataMessagePayload per tonalità ristrette.
messaging/payload-size-limit-exceeded Il payload del messaggio fornito supera i limiti di dimensione FCM. Il limite è 4096 byte per la maggior parte dei messaggi. Per i messaggi inviati agli argomenti, il limite è 2048 byte. La dimensione totale del payload include chiavi e valori.
messaging/invalid-options È stato fornito un oggetto opzioni messaggio non valido. Il messaggio di errore dovrebbe contenere ulteriori informazioni.
messaging/invalid-registration-token Token di registrazione non valido fornito. Assicurati che corrisponda al token di registrazione che l'app client riceve dalla registrazione con FCM. Non troncare o aggiungere caratteri aggiuntivi.
messaging/registration-token-not-registered Il token di registrazione fornito non è registrato. Un token di registrazione precedentemente valido può essere annullato per una serie di motivi, tra cui:
  • L'app client ha annullato la registrazione da FCM.
  • La registrazione dell'app client è stata automaticamente annullata. Ciò può accadere se l'utente disinstalla l'applicazione o, su piattaforme Apple, se il servizio di feedback APN ha segnalato che il token APN non è valido.
  • Il token di registrazione è scaduto. Ad esempio, Google potrebbe decidere di aggiornare i token di registrazione o il token APN potrebbe essere scaduto per i dispositivi Apple.
  • L'app client è stata aggiornata, ma la nuova versione non è configurata per ricevere messaggi.
In tutti questi casi, rimuovi questo token di registrazione e smetti di usarlo per inviare messaggi.
messaging/invalid-package-name Il messaggio è stato indirizzato a un token di registrazione il cui nome di pacchetto non corrisponde alla condizione restrictedPackageName opzione.
messaging/message-rate-exceeded La frequenza dei messaggi a un determinato target è troppo alta. Riduci il numero di messaggi inviati a questo dispositivo o argomento e non riprovare immediatamente a inviare a questa destinazione.
messaging/device-message-rate-exceeded La frequenza dei messaggi a un particolare dispositivo è troppo alta. Riduci il numero di messaggi inviati a questo dispositivo e non riprovare immediatamente a inviare a questo dispositivo.
messaging/topics-message-rate-exceeded La frequenza dei messaggi agli abbonati a un particolare argomento è troppo alta. Riduci il numero di messaggi inviati per questo argomento e non riprovare immediatamente a inviare a questo argomento.
messaging/too-many-topics Un token di registrazione è stato sottoscritto per il numero massimo di argomenti e non può più essere sottoscritto.
messaging/invalid-apns-credentials Non è stato possibile inviare un messaggio indirizzato a un dispositivo Apple perché il certificato SSL dell'APN richiesto non è stato caricato o è scaduto. Verifica la validità dei tuoi certificati di sviluppo e produzione.
messaging/mismatched-credential La credenziale utilizzata per autenticare questo SDK non dispone dell'autorizzazione per inviare messaggi al dispositivo corrispondente al token di registrazione fornito. Assicurati che la credenziale e il token di registrazione appartengano entrambi allo stesso progetto Firebase. Vedere Aggiungi Firebase per la vostra applicazione per la documentazione su come autenticare la Firebase Admin SDK.
messaging/authentication-error L'SDK non è stato in grado di autenticarsi sui server FCM. Assicurati di autenticare l'SDK di amministrazione di Firebase con una credenziale che disponga delle autorizzazioni appropriate per inviare messaggi FCM. Vedere Aggiungi Firebase per la vostra applicazione per la documentazione su come autenticare la Firebase Admin SDK.
messaging/server-unavailable Il server FCM non ha potuto elaborare la richiesta in tempo. Dovresti riprovare la stessa richiesta, ma devi:
  • Onore al Retry-After intestazione se è incluso nella risposta dal server FCM Connection.
  • Implementa il back-off esponenziale nel tuo meccanismo di riprova. Ad esempio, se hai aspettato un secondo prima del primo tentativo, attendi almeno due secondi prima del successivo, quindi quattro secondi e così via. Se stai inviando più messaggi, ritarda ciascuno in modo indipendente di un importo aggiuntivo casuale per evitare di inviare una nuova richiesta per tutti i messaggi contemporaneamente.
I mittenti che causano problemi rischiano di essere inseriti nella lista nera.
messaging/internal-error Il server FCM ha riscontrato un errore durante il tentativo di elaborare la richiesta. Si potrebbe ripetere la stessa richiesta seguendo i requisiti elencati nella messaging/server-unavailable riga sopra. Se i persiste errore, si prega di segnalare il problema al nostro Bug Report canale di supporto.
messaging/unknown-error È stato restituito un errore del server sconosciuto. Per ulteriori dettagli, vedere la risposta del server non elaborato nel messaggio di errore. Se si riceve questo errore, si prega di segnalare il messaggio di errore completo al nostro Bug Report canale di supporto.

Invia messaggi utilizzando i protocolli del server dell'app legacy

Se preferisci utilizzare i protocolli legacy, crea richieste di messaggi come mostrato in questa sezione. Tieni presente che, se invii a più piattaforme tramite HTTP, il protocollo v1 può semplificare le tue richieste di messaggi.

Invia messaggi a dispositivi specifici

Per inviare messaggi a dispositivi specifici, impostare la to chiave per la registrazione gettone per l'istanza specifica applicazione. Consulta le informazioni sulla configurazione del client per la tua piattaforma per ulteriori informazioni sui token di registrazione.

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

Risposta HTTP

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

Messaggio XMPP

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

Risposta XMPP

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

Il server di connessione XMPP fornisce alcune altre opzioni per le risposte. Vedere formato di risposta del server .

Per l'elenco completo di opzioni di messaggi disponibili per l'invio di messaggi a valle di applicazioni client, vedere le informazioni di riferimento per il vostro scelto protocollo del server di connessione, HTTP o XMPP .

Invia messaggi agli argomenti

L'invio di messaggi a un argomento Firebase Cloud Messaging è molto simile all'invio di messaggi a un singolo dispositivo oa un gruppo di utenti. I set application server le to chiave con un valore come /topics/yourTopic . Gli sviluppatori possono scegliere qualsiasi nome argomento che corrisponde all'espressione regolare: "/topics/[a-zA-Z0-9-_.~%]+" .

Per inviare a combinazioni di più argomenti, l'application server deve impostare la condition chiave (al posto del to chiave) ad una condizione booleana che specifica gli argomenti di destinazione. Ad esempio, per inviare messaggi a dispositivi che sottoscritto TopicA e sia TopicB o TopicC :

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

FCM valuta prima le condizioni tra parentesi, quindi valuta l'espressione da sinistra a destra. Nell'espressione sopra, un utente iscritto a un singolo argomento non riceve il messaggio. Allo stesso modo, un utente che non si iscrive a TopicA non riceve il messaggio. Queste combinazioni lo ricevono:

  • ArgomentoA e ArgomentoB
  • ArgomentoA e ArgomentoC

Puoi includere fino a cinque argomenti nell'espressione condizionale e le parentesi sono supportate. Operatori supportati: && , || .

Argomento Richiesta HTTP POST

Invia a un singolo argomento:

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


Invia a dispositivi abbonati agli argomenti "cani" o "gatti":

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


Risposta HTTP dell'argomento

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

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

Messaggio XMPP dell'argomento

Invia a un singolo argomento:

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


  </gcm>
</message>

Invia a dispositivi abbonati agli argomenti "cani" o "gatti":

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


  </gcm>
</message>

Risposta XMPP dell'argomento

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

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

Aspettati fino a 30 secondi di ritardo prima che il server FCM restituisca una risposta di esito positivo o negativo alle richieste di invio dell'argomento. Assicurati di impostare di conseguenza il valore di timeout del server dell'app nella richiesta.

Invia messaggi a gruppi di dispositivi

L'invio di messaggi a un gruppo di dispositivi è molto simile all'invio di messaggi a un singolo dispositivo. Impostare il to parametro la chiave di notifica univoco per il gruppo di dispositivi. Vedere i tipi di messaggio per i dettagli sul supporto di carico utile. Gli esempi in questa pagina mostrano come inviare messaggi di dati a gruppi di dispositivi nei protocolli HTTP e XMPP.

Richiesta POST HTTP del gruppo di dispositivi

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

Risposta HTTP del gruppo di dispositivi

Ecco un esempio di "successo" - la notification_key ha 2 gettoni di registrazione ad esso associati, e il messaggio è stato inviato con successo ad entrambi:

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

Ecco un esempio di "successo parziale" - il notification_key ha 3 registrazione token associati con esso. Il messaggio è stato inviato correttamente solo a 1 dei token di registrazione. Le liste dei messaggi di risposta i token di registrazione ( registration_ids ) che non è riuscito a ricevere il messaggio:

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

Quando un messaggio non riesce ad essere consegnato ad uno o più gettoni della registrazione associato ad un notification_key , il server di applicazione dovrebbe riprovare con backoff tra i tentativi.

Se il server tenta di inviare un messaggio a un gruppo di dispositivi che non ha membri, la risposta sarà simile alla seguente, con 0 operazioni riuscite e 0 errori:

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

Messaggio XMPP gruppo dispositivi

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

Risposta XMPP del gruppo di dispositivi

Quando il messaggio viene inviato correttamente a uno qualsiasi dei dispositivi del gruppo, il server di connessione XMPP risponde con un ACK. Se tutti i messaggi inviati a tutti i dispositivi del gruppo falliscono, il server di connessione XMPP risponde con un NACK.

Ecco un esempio di "successo" - la notification_key ha 3 gettoni di registrazione ad esso associati, e il messaggio è stato inviato con successo a tutti loro:

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

Ecco un esempio di "successo parziale" - il notification_key ha 3 registrazione token associati con esso. Il messaggio è stato inviato correttamente solo a 1 dei token di registrazione. Il messaggio di risposta elenca i token di registrazione che non sono riusciti a ricevere il messaggio:

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

Quando il server di connessione FCM non riesce a fornire a tutti i dispositivi del gruppo. Il server dell'app riceverà una risposta nack.

Per l'elenco completo di opzioni di messaggi, vedere le informazioni di riferimento per il vostro scelto protocollo del server di connessione, HTTP o XMPP .

Metodi di invio legacy di Firebase Admin SDK

Il Firebase Admin Node.js SDK supporta i metodi per l'invio di messaggi (FCM) in base al server API Legacy FCM . Questi metodi accettano argomenti diversi rispetto al send() metodo. Si dovrebbe usare il send() metodo, quando possibile, e utilizzare solo i metodi descritti in questa pagina per l'invio di messaggi a singoli dispositivi o gruppi di dispositivi.

Invia a singoli dispositivi

È possibile passare una registrazione token al sendToDevice() metodo per inviare un messaggio a quel 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);
  });

Il sendToDevice() metodo può anche inviare un messaggio multicast (cioè, un messaggio a più dispositivi) passando un array di registrazione gettoni invece di una sola registrazione token:

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

Il sendToDevice() restituisce una promessa che si risolve con un MessagingDevicesResponse oggetto contenente la risposta da FCM. Il tipo restituito ha lo stesso formato quando si passa un singolo token di registrazione o un array di token di registrazione.

Alcuni casi, come un errore di autenticazione o una limitazione della velocità, causano la mancata elaborazione dell'intero messaggio. In questi casi, la promessa restituito da sendToDevice() viene rifiutato con un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedi Admin FCM errori API .

Invia a un gruppo di dispositivi

La messaggistica del gruppo di dispositivi consente di aggiungere più dispositivi a un singolo gruppo. È simile alla messaggistica degli argomenti, ma include l'autenticazione per garantire che l'appartenenza al gruppo sia gestita solo dai tuoi server. Ad esempio, se desideri inviare messaggi diversi a modelli di telefono diversi, i tuoi server possono aggiungere/rimuovere registrazioni ai gruppi appropriati e inviare il messaggio appropriato a ciascun gruppo. La messaggistica dei gruppi di dispositivi differisce dalla messaggistica degli argomenti in quanto implica la gestione dei gruppi di dispositivi dai server anziché direttamente dall'applicazione.

È possibile utilizzare la messaggistica di gruppo dispositivo tramite l'eredità XMPP o HTTP protocolli sul server app. Firebase Admin SDK per Node.js sulla base dei protocolli legacy anche fornire funzionalità di messaggistica di gruppo dispositivo. Il numero massimo di membri consentiti per una chiave di notifica è 20.

Puoi creare gruppi di dispositivi e generare chiavi di notifica tramite un server app o un client Android. Vedere Gestione dei gruppi di dispositivi per i dettagli.

Il sendToDeviceGroup() il metodo consente di inviare un messaggio a un gruppo di dispositivi specificando la chiave di notifica per quel gruppo di dispositivi:

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

Il sendToDeviceGroup() restituisce una promessa che si risolve con un MessagingDevicesResponse oggetto contenente la risposta da FCM.

Alcuni casi, come un errore di autenticazione o una limitazione della velocità, causano la mancata elaborazione dell'intero messaggio. In questi casi, la promessa restituito da sendToDeviceGroup() viene rifiutato con un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedi Admin FCM errori API .

Definire il payload del messaggio

I metodi di cui sopra in base ai protocolli legacy FCM accettare un carico utile messaggio di come il loro secondo argomento e supportano sia i messaggi di notifica e di dati . È possibile specificare i tipi di uno o entrambi i messaggi con la creazione di un oggetto con i data e / o notification chiavi. Ad esempio, ecco come definire diversi tipi di payload dei messaggi:

Messaggio di notifica

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

Messaggio dati

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

Messaggio combinato

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

I payload dei messaggi di notifica hanno un sottoinsieme predefinito di proprietà valide e differiscono leggermente a seconda del sistema operativo mobile scelto come target. Vedere la documentazione di riferimento per NotificationMessagePayload per una lista completa.

I payload dei messaggi di dati sono composti da coppie chiave-valore personalizzate con alcune limitazioni, incluso il fatto che tutti i valori devono essere stringhe. Vedere la documentazione di riferimento per DataMessagePayload per un elenco completo delle restrizioni.

Definire le opzioni del messaggio

I metodi precedenti basati sui protocolli legacy FCM accettano un terzo argomento opzionale che specifica alcune opzioni per il messaggio. Ad esempio, l'esempio seguente invia un messaggio ad alta priorità a un dispositivo che scade dopo 24 ore:

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

Vedere la documentazione di riferimento per MessagingOptions per una lista completa delle opzioni disponibili.