Erstellen Sie App-Server-Sendeanforderungen

Mit dem Firebase Admin SDK oder den FCM-App-Serverprotokollen können Sie Nachrichtenanfragen erstellen und sie an diese Arten von Zielen senden:

  • Themenname
  • Bedingung
  • Token für die Geräteregistrierung
  • Gerätegruppenname (nur ältere Protokolle und Firebase Admin SDK für Node.js)

Sie können Nachrichten mit einer Benachrichtigungsnutzlast aus vordefinierten Feldern, einer Datennutzlast aus Ihren eigenen benutzerdefinierten Feldern oder einer Nachricht senden, die beide Arten von Nutzlast enthält. Weitere Informationen finden Sie unter Nachrichtentypen .

Die Beispiele auf dieser Seite zeigen, wie Sie Benachrichtigungen mit dem Firebase Admin SDK (das Node , Java , Python , C# und Go unterstützt) und dem HTTP-Protokoll v1 senden. Es gibt auch Anleitungen zum Senden von Nachrichten über die Legacy-HTTP- und XMPP-Protokolle .

Senden Sie Nachrichten an bestimmte Geräte

Um an ein einzelnes, bestimmtes Gerät zu senden, übergeben Sie das Registrierungstoken des Geräts wie gezeigt. Sehen Sie sich die Client-Setup-Informationen für Ihre Plattform an, um mehr über Registrierungstoken zu erfahren.

Node.js

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

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

// Send a message to the device corresponding to the provided
// registration token.
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);

Python

# This registration token comes from the client FCM SDKs.
registration_token = 'YOUR_REGISTRATION_TOKEN'

# See documentation on defining a message payload.
message = messaging.Message(
    data={
        'score': '850',
        'time': '2:45',
    },
    token=registration_token,
)

# Send a message to the device corresponding to the provided
# registration token.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

gehen

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

SICH AUSRUHEN

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

cURL-Befehl:

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

Bei Erfolg gibt jede Sendemethode eine Nachrichten-ID zurück. Das Firebase Admin SDK gibt die ID-Zeichenfolge im Format projects/{project_id}/messages/{message_id} . Die Antwort des HTTP-Protokolls ist ein einzelner JSON-Schlüssel:

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

Senden Sie Nachrichten an mehrere Geräte

Die REST-API und die Admin-FCM-APIs ermöglichen Ihnen das Multicasting einer Nachricht an eine Liste von Geräteregistrierungstoken. Sie können bis zu 500 Geräteregistrierungstoken pro Aufruf angeben.

Node.js

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

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

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

Python

# Create a list containing up to 500 registration tokens.
# These registration tokens come from the client FCM SDKs.
registration_tokens = [
    'YOUR_REGISTRATION_TOKEN_1',
    # ...
    'YOUR_REGISTRATION_TOKEN_N',
]

message = messaging.MulticastMessage(
    data={'score': '850', 'time': '2:45'},
    tokens=registration_tokens,
)
response = messaging.send_multicast(message)
# See the BatchResponse reference documentation
# for the contents of response.
print('{0} messages were sent successfully'.format(response.success_count))

gehen

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

SICH AUSRUHEN

Erstellen Sie eine HTTP-Batch-Anfrage:

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

Speichern Sie die Anfrage in einer Datei (in diesem Beispiel batch_request.txt). Verwenden Sie dann den cURL-Befehl:

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

Für Firebase Admin SDKs verwendet dieser Vorgang die sendAll() API im Hintergrund, wie in den Beispielen gezeigt. Der Rückgabewert ist eine BatchResponse deren Antwortliste der Reihenfolge der Eingabetoken entspricht. Dies ist nützlich, wenn Sie überprüfen möchten, welche Token zu Fehlern geführt haben.

Node.js

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

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

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

Python

# These registration tokens come from the client FCM SDKs.
registration_tokens = [
    'YOUR_REGISTRATION_TOKEN_1',
    # ...
    'YOUR_REGISTRATION_TOKEN_N',
]

message = messaging.MulticastMessage(
    data={'score': '850', 'time': '2:45'},
    tokens=registration_tokens,
)
response = messaging.send_multicast(message)
if response.failure_count > 0:
    responses = response.responses
    failed_tokens = []
    for idx, resp in enumerate(responses):
        if not resp.success:
            # The order of responses corresponds to the order of the registration tokens.
            failed_tokens.append(registration_tokens[idx])
    print('List of tokens that caused failures: {0}'.format(failed_tokens))

gehen

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

SICH AUSRUHEN

Jeder Sub-Send sendet eine Antwort zurück. Antworten werden durch eine Antwortgrenzenzeichenfolge getrennt, die mit --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--

Senden Sie Nachrichten an Themen

Nachdem Sie ein Thema erstellt haben, entweder durch das Abonnieren von Client-App-Instanzen für das Thema auf der Clientseite oder über die Server-API , können Sie Nachrichten an das Thema senden. Wenn Sie zum ersten Mal Sendeanforderungen für FCM erstellen, finden Sie wichtige Hintergrund- und Einrichtungsinformationen im Leitfaden zu Ihrer Serverumgebung und zu FCM .

Geben Sie in Ihrer Sendelogik im Backend den gewünschten Themennamen wie gezeigt an:

Node.js

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

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

// Send a message to devices subscribed to the provided topic.
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);

Python

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

# See documentation on defining a message payload.
message = messaging.Message(
    data={
        'score': '850',
        'time': '2:45',
    },
    topic=topic,
)

# Send a message to the devices subscribed to the provided topic.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

gehen

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

SICH AUSRUHEN

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

cURL-Befehl:

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

Um eine Nachricht an eine Kombination von Themen zu senden, geben Sie eine Bedingung an, bei der es sich um einen booleschen Ausdruck handelt, der die Zielthemen angibt. Die folgende Bedingung sendet beispielsweise Nachrichten an Geräte, die TopicA und entweder TopicB oder TopicC :

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

FCM wertet zuerst alle Bedingungen in Klammern aus und wertet dann den Ausdruck von links nach rechts aus. Im obigen Ausdruck erhält ein Benutzer, der ein einzelnes Thema abonniert hat, die Nachricht nicht. Ebenso erhält ein Benutzer, der TopicA nicht abonniert, die Nachricht nicht. Diese Kombinationen erhalten es:

  • TopicA und TopicB
  • TopicA und TopicC

Sie können bis zu fünf Themen in Ihren Bedingungsausdruck aufnehmen.

So senden Sie an eine Bedingung:

Node.js

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

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

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
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);

Python

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

# See documentation on defining a message payload.
message = messaging.Message(
    notification=messaging.Notification(
        title='$GOOG up 1.43% on the day',
        body='$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
    ),
    condition=condition,
)

# Send a message to devices subscribed to the combination of topics
# specified by the provided condition.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

gehen

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

SICH AUSRUHEN

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

cURL-Befehl:

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

Senden Sie eine Reihe von Nachrichten

Die REST-API und die Admin-SDKs unterstützen das Senden von Nachrichten in Stapeln. Sie können bis zu 500 Nachrichten in einem einzigen Stapel gruppieren und sie alle in einem einzigen API-Aufruf senden, mit einer erheblichen Leistungsverbesserung gegenüber dem Senden separater HTTP-Anforderungen für jede Nachricht.

Diese Funktion kann verwendet werden, um einen benutzerdefinierten Satz von Nachrichten zu erstellen und sie an verschiedene Empfänger zu senden, einschließlich Themen oder spezifischer Geräteregistrierungstoken. Verwenden Sie diese Funktion, wenn Sie beispielsweise gleichzeitig Nachrichten mit leicht unterschiedlichen Details im Nachrichtentext an verschiedene Zielgruppen senden müssen.

Node.js

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

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

Python

# Create a list containing up to 500 messages.
messages = [
    messaging.Message(
        notification=messaging.Notification('Price drop', '5% off all electronics'),
        token=registration_token,
    ),
    # ...
    messaging.Message(
        notification=messaging.Notification('Price drop', '2% off all books'),
        topic='readers-club',
    ),
]

response = messaging.send_all(messages)
# See the BatchResponse reference documentation
# for the contents of response.
print('{0} messages were sent successfully'.format(response.success_count))

gehen

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

SICH AUSRUHEN

Erstellen Sie eine HTTP-Stapelanforderung, indem Sie eine Liste von Unteranforderungen kombinieren:

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

Sie können die zurückgegebene BatchResponse , um zu überprüfen, wie viele der Nachrichten erfolgreich an FCM übergeben wurden. Es stellt auch eine Liste von Antworten bereit, die verwendet werden können, um den Status einzelner Nachrichten zu überprüfen. Die Reihenfolge der Antworten entspricht der Reihenfolge der Meldungen in der Eingabeliste.

Direkt bootfähige Nachrichten senden (nur Android)

Sie können Nachrichten an Geräte im direkten Startmodus senden, indem Sie die HTTP v1- oder Legacy-HTTP-APIs verwenden. Stellen Sie vor dem Senden an Geräte im Direktstartmodus sicher, dass Sie die Schritte ausgeführt haben, damit Clientgeräte FCM-Meldungen im Direktstartmodus empfangen können .

Senden Sie mit der HTTP-API von FCM v1

Die Nachrichtenanforderung muss den Schlüssel "direct_boot_ok" : true in den AndroidConfig Optionen des Anforderungstexts enthalten. Zum Beispiel:

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

Senden Sie mit der alten HTTP-API von FCM

Die Nachrichtenanforderung muss den Schlüssel "direct_boot_ok" : true auf der obersten Ebene des Anforderungstexts enthalten. Zum Beispiel:

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
}

Nachrichten, die mit diesem Schlüssel im Anforderungstext gesendet werden, können von Apps auf Geräten verarbeitet werden, die sich derzeit im direkten Startmodus befinden (und auch, wenn sie sich nicht in diesem Modus befinden).

Passen Sie Nachrichten plattformübergreifend an

Das Firebase Admin SDK und das HTTP-Protokoll FCM v1 ermöglichen es Ihren Nachrichtenanforderungen, alle im message verfügbaren Felder festzulegen. Das beinhaltet:

  • ein gemeinsamer Satz von Feldern, die von allen App-Instanzen interpretiert werden, die die Nachricht empfangen.
  • plattformspezifische Sätze von Feldern wie AndroidConfig und WebpushConfig , die nur von App-Instanzen interpretiert werden, die auf der angegebenen Plattform ausgeführt werden.

Plattformspezifische Blöcke geben Ihnen die Flexibilität, Nachrichten für verschiedene Plattformen anzupassen, um sicherzustellen, dass sie beim Empfang korrekt behandelt werden. Das FCM-Backend berücksichtigt alle angegebenen Parameter und passt die Nachricht für jede Plattform an.

Wann sollten gemeinsame Felder verwendet werden?

Verwenden Sie allgemeine Felder, wenn Sie:

  • Ausrichtung auf App-Instanzen auf allen Plattformen – Apple, Android und Web
  • Senden von Nachrichten an Themen

Alle App-Instanzen können unabhängig von der Plattform die folgenden gemeinsamen Felder interpretieren:

Wann sollten plattformspezifische Felder verwendet werden?

Verwenden Sie plattformspezifische Felder, wenn Sie Folgendes möchten:

  • Senden Sie Felder nur an bestimmte Plattformen
  • Senden Sie zusätzlich zu den allgemeinen Feldern plattformspezifische Felder

Wenn Sie Werte nur an bestimmte Plattformen senden möchten, verwenden Sie keine gemeinsamen Felder. verwenden Sie plattformspezifische Felder. Um beispielsweise eine Benachrichtigung nur an Apple-Plattformen und das Web, aber nicht an Android zu senden, müssen Sie zwei separate Feldsätze verwenden, einen für Apple und einen für das Web.

Wenn Sie Nachrichten mit bestimmten Zustelloptionen senden, verwenden Sie plattformspezifische Felder, um diese festzulegen. Sie können bei Bedarf unterschiedliche Werte pro Plattform angeben. Aber selbst wenn Sie plattformübergreifend im Wesentlichen denselben Wert festlegen möchten, müssen Sie plattformspezifische Felder verwenden. Dies liegt daran, dass jede Plattform den Wert etwas anders interpretieren kann – beispielsweise wird die Lebensdauer auf Android als Ablaufzeit in Sekunden festgelegt, während sie auf Apple als Ablaufdatum festgelegt wird.

Beispiel: Benachrichtigungsnachricht mit Farb- und Symboloptionen

Diese beispielhafte Sendeanforderung sendet einen gemeinsamen Benachrichtigungstitel und -inhalt an alle Plattformen, sendet aber auch einige plattformspezifische Überschreibungen an Android-Geräte.

Für Android legt die Anforderung ein spezielles Symbol und eine spezielle Farbe fest, die auf Android-Geräten angezeigt werden. Wie in der Referenz für AndroidNotification erwähnt , wird die Farbe im Format #rrggbb angegeben, und das Bild muss eine zeichenbare Symbolressource lokal in der Android-App sein.

Hier ist eine Annäherung an den visuellen Effekt auf dem Gerät eines Benutzers:

Einfaches Zeichnen von zwei Geräten, wobei eines ein benutzerdefiniertes Symbol und eine benutzerdefinierte Farbe anzeigt

Node.js

const topicName = 'industry-tech';

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

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

Python

message = messaging.Message(
    notification=messaging.Notification(
        title='$GOOG up 1.43% on the day',
        body='$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
    ),
    android=messaging.AndroidConfig(
        ttl=datetime.timedelta(seconds=3600),
        priority='normal',
        notification=messaging.AndroidNotification(
            icon='stock_ticker_update',
            color='#f45342'
        ),
    ),
    apns=messaging.APNSConfig(
        payload=messaging.APNSPayload(
            aps=messaging.Aps(badge=42),
        ),
    ),
    topic='industry-tech',
)

gehen

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

SICH AUSRUHEN

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

Ausführliche Informationen zu den Schlüsseln, die in plattformspezifischen Blöcken im Nachrichtentext verfügbar sind, finden Sie in der HTTP v1-Referenzdokumentation .

Beispiel: Benachrichtigungsnachricht mit einem benutzerdefinierten Bild

Die folgende beispielhafte Sendeanforderung sendet einen gemeinsamen Benachrichtigungstitel an alle Plattformen, sendet aber auch ein Bild. Hier ist eine Annäherung an den visuellen Effekt auf dem Gerät eines Benutzers:

Einfaches Zeichnen eines Bildes in einer Anzeigebenachrichtigung

Node.js

const topicName = 'industry-tech';

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

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

SICH AUSRUHEN

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

Ausführliche Informationen zu den Schlüsseln, die in plattformspezifischen Blöcken im Nachrichtentext verfügbar sind, finden Sie in der HTTP v1-Referenzdokumentation .

Beispiel: Benachrichtigungsnachricht mit einer zugehörigen Klickaktion

Die folgende beispielhafte Sendeanforderung sendet einen gemeinsamen Benachrichtigungstitel an alle Plattformen, sendet aber auch eine Aktion, die die App als Reaktion auf die Interaktion des Benutzers mit der Benachrichtigung ausführen soll. Hier ist eine Annäherung an den visuellen Effekt auf dem Gerät eines Benutzers:

Einfaches Zeichnen eines Benutzertipps zum Öffnen einer Webseite

Node.js

const topicName = 'industry-tech';

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

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

SICH AUSRUHEN

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

Ausführliche Informationen zu den Schlüsseln, die in plattformspezifischen Blöcken im Nachrichtentext verfügbar sind, finden Sie in der HTTP v1-Referenzdokumentation .

Beispiel: Benachrichtigungsnachricht mit Lokalisierungsoptionen

Die folgende beispielhafte Sendeanforderung sendet Lokalisierungsoptionen für den Client, um lokalisierte Nachrichten anzuzeigen. Hier ist eine Annäherung an den visuellen Effekt auf dem Gerät eines Benutzers:

Einfache Zeichnung von zwei Geräten, die Text in Englisch und Spanisch anzeigen

Node.js

var topicName = 'industry-tech';

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

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

SICH AUSRUHEN

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

Ausführliche Informationen zu den Schlüsseln, die in plattformspezifischen Blöcken im Nachrichtentext verfügbar sind, finden Sie in der HTTP v1-Referenzdokumentation .

Admin-Fehlercodes

In der folgenden Tabelle sind die Fehlercodes der Firebase Admin FCM API und ihre Beschreibungen aufgeführt, einschließlich der empfohlenen Lösungsschritte.

Fehlercode Beschreibung und Lösungsschritte
messaging/invalid-argument Einer FCM-Methode wurde ein ungültiges Argument bereitgestellt. Die Fehlermeldung sollte zusätzliche Informationen enthalten.
messaging/invalid-recipient Der beabsichtigte Nachrichtenempfänger ist ungültig. Die Fehlermeldung sollte zusätzliche Informationen enthalten.
messaging/invalid-payload Ein ungültiges Nachrichtennutzlastobjekt wurde bereitgestellt. Die Fehlermeldung sollte zusätzliche Informationen enthalten.
messaging/invalid-data-payload-key Die Nutzlast der Datennachricht enthält einen ungültigen Schlüssel. Informationen zu eingeschränkten Schlüsseln finden Sie in der Referenzdokumentation für DataMessagePayload .
messaging/payload-size-limit-exceeded Die bereitgestellte Nachrichtennutzlast überschreitet die FCM-Größenbeschränkungen. Die Grenze liegt für die meisten Nachrichten bei 4096 Bytes. Für Nachrichten, die an Themen gesendet werden, beträgt das Limit 2048 Byte. Die Gesamtnutzlastgröße umfasst sowohl Schlüssel als auch Werte.
messaging/invalid-options Ein ungültiges Nachrichtenoptionsobjekt wurde bereitgestellt. Die Fehlermeldung sollte zusätzliche Informationen enthalten.
messaging/invalid-registration-token Ungültiges Registrierungstoken angegeben. Stellen Sie sicher, dass es mit dem Registrierungstoken übereinstimmt, das die Client-App durch die Registrierung bei FCM erhält. Kürzen Sie es nicht und fügen Sie keine zusätzlichen Zeichen hinzu.
messaging/registration-token-not-registered Das bereitgestellte Registrierungstoken ist nicht registriert. Die Registrierung eines zuvor gültigen Registrierungstokens kann aus verschiedenen Gründen aufgehoben werden, darunter:
  • Die Client-App hat sich selbst von FCM abgemeldet.
  • Die Registrierung der Client-App wurde automatisch aufgehoben. Dies kann passieren, wenn der Benutzer die Anwendung deinstalliert oder, auf Apple-Plattformen, wenn der APNs Feedback Service das APNs-Token als ungültig gemeldet hat.
  • Das Registrierungstoken ist abgelaufen. Beispielsweise könnte Google beschließen, Registrierungstoken zu aktualisieren, oder das APNs-Token für Apple-Geräte ist möglicherweise abgelaufen.
  • Die Client-App wurde aktualisiert, aber die neue Version ist nicht für den Empfang von Nachrichten konfiguriert.
Entfernen Sie in all diesen Fällen dieses Registrierungstoken und verwenden Sie es nicht mehr zum Senden von Nachrichten.
messaging/invalid-package-name Die Nachricht wurde an ein Registrierungstoken adressiert, dessen Paketname nicht mit der angegebenen Option „ restrictedPackageName “ übereinstimmt.
messaging/message-rate-exceeded Die Nachrichtenrate an ein bestimmtes Ziel ist zu hoch. Reduzieren Sie die Anzahl der an dieses Gerät oder Thema gesendeten Nachrichten und versuchen Sie nicht sofort erneut, an dieses Ziel zu senden.
messaging/device-message-rate-exceeded Die Nachrichtenrate an ein bestimmtes Gerät ist zu hoch. Reduzieren Sie die Anzahl der an dieses Gerät gesendeten Nachrichten und versuchen Sie nicht sofort erneut, sie an dieses Gerät zu senden.
messaging/topics-message-rate-exceeded Die Rate der Nachrichten an Abonnenten zu einem bestimmten Thema ist zu hoch. Reduzieren Sie die Anzahl der für dieses Thema gesendeten Nachrichten, und versuchen Sie nicht sofort erneut, an dieses Thema zu senden.
messaging/too-many-topics Ein Registrierungstoken wurde für die maximale Anzahl von Themen abonniert und kann nicht mehr abonniert werden.
messaging/invalid-apns-credentials Eine an ein Apple-Gerät gerichtete Nachricht konnte nicht gesendet werden, da das erforderliche APNs-SSL-Zertifikat nicht hochgeladen wurde oder abgelaufen ist. Prüfen Sie die Gültigkeit Ihrer Entwicklungs- und Produktionszertifikate.
messaging/mismatched-credential Die zur Authentifizierung dieses SDK verwendeten Anmeldeinformationen sind nicht berechtigt, Nachrichten an das Gerät zu senden, das dem bereitgestellten Registrierungstoken entspricht. Stellen Sie sicher, dass die Anmeldeinformationen und das Registrierungstoken beide zum selben Firebase-Projekt gehören. Unter Hinzufügen von Firebase zu Ihrer App finden Sie eine Dokumentation zum Authentifizieren der Firebase Admin SDKs.
messaging/authentication-error Das SDK konnte sich nicht bei den FCM-Servern authentifizieren. Stellen Sie sicher, dass Sie das Firebase Admin SDK mit einem Berechtigungsnachweis authentifizieren, der über die erforderlichen Berechtigungen zum Senden von FCM-Nachrichten verfügt. Unter Hinzufügen von Firebase zu Ihrer App finden Sie eine Dokumentation zum Authentifizieren der Firebase Admin SDKs.
messaging/server-unavailable Der FCM-Server konnte die Anfrage nicht rechtzeitig verarbeiten. Sie sollten dieselbe Anfrage erneut versuchen, aber Sie müssen:
  • Berücksichtigen Sie den Retry-After Header, wenn er in der Antwort vom FCM-Verbindungsserver enthalten ist.
  • Implementieren Sie exponentielles Backoff in Ihrem Wiederholungsmechanismus. Wenn Sie beispielsweise vor der ersten Wiederholung eine Sekunde gewartet haben, warten Sie vor der nächsten mindestens zwei Sekunden, dann vier Sekunden und so weiter. Wenn Sie mehrere Nachrichten senden, verzögern Sie jede einzeln um einen zusätzlichen zufälligen Betrag, um zu vermeiden, dass eine neue Anfrage für alle Nachrichten gleichzeitig gesendet wird.
Absender, die Probleme verursachen, laufen Gefahr, auf die schwarze Liste gesetzt zu werden.
messaging/internal-error Der FCM-Server hat beim Versuch, die Anfrage zu verarbeiten, einen Fehler festgestellt. Sie können dieselbe Anfrage erneut versuchen, indem Sie die Anforderungen erfüllen, die oben in der Zeile „ messaging/server-unavailable “ aufgeführt sind. Wenn der Fehler weiterhin besteht, melden Sie das Problem bitte unserem Bug Report -Supportkanal.
messaging/unknown-error Ein unbekannter Serverfehler wurde zurückgegeben. Weitere Einzelheiten finden Sie in der unformatierten Serverantwort in der Fehlermeldung. Wenn Sie diesen Fehler erhalten, melden Sie bitte die vollständige Fehlermeldung an unseren Support-Kanal für Fehlerberichte .

Senden Sie Nachrichten mit den Legacy-App-Server-Protokollen

Wenn Sie es vorziehen, die Legacy-Protokolle zu verwenden, erstellen Sie Nachrichtenanforderungen wie in diesem Abschnitt gezeigt. Denken Sie daran, dass das v1-Protokoll Ihre Nachrichtenanforderungen vereinfachen kann, wenn Sie über HTTP an mehrere Plattformen senden.

Senden Sie Nachrichten an bestimmte Geräte

Um Nachrichten an bestimmte Geräte zu senden, legen Sie den to -Schlüssel auf das Registrierungstoken für die jeweilige App-Instanz fest. Sehen Sie sich die Client-Setup-Informationen für Ihre Plattform an, um mehr über Registrierungstoken zu erfahren.

HTTP-POST-Anfrage

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

HTTP-Antwort

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

XMPP-Nachricht

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

XMPP-Antwort

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

Der XMPP-Verbindungsserver bietet einige andere Optionen für Antworten. Siehe Server-Antwortformat .

Die vollständige Liste der Nachrichtenoptionen, die beim Senden von Downstream-Nachrichten an Client-Apps verfügbar sind, finden Sie in den Referenzinformationen für das von Ihnen gewählte Verbindungsserverprotokoll, HTTP oder XMPP .

Senden Sie Nachrichten an Themen

Das Senden von Nachrichten an ein Firebase Cloud Messaging-Thema ist dem Senden von Nachrichten an ein einzelnes Gerät oder an eine Benutzergruppe sehr ähnlich. Der App-Server legt den Schlüssel to mit einem Wert wie /topics/yourTopic . Entwickler können einen beliebigen Themennamen auswählen, der dem regulären Ausdruck entspricht: "/topics/[a-zA-Z0-9-_.~%]+" .

Um an Kombinationen mehrerer Themen zu senden, muss der App-Server den condition (anstelle des to -Schlüssels) auf eine boolesche Bedingung setzen, die die Zielthemen angibt. So senden Sie beispielsweise Nachrichten an Geräte, die TopicA und entweder TopicB oder TopicC :

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

FCM wertet zuerst alle Bedingungen in Klammern aus und wertet dann den Ausdruck von links nach rechts aus. Im obigen Ausdruck erhält ein Benutzer, der ein einzelnes Thema abonniert hat, die Nachricht nicht. Ebenso erhält ein Benutzer, der TopicA nicht abonniert, die Nachricht nicht. Diese Kombinationen erhalten es:

  • ThemaA und ThemaB
  • ThemaA und ThemaC

Sie können bis zu fünf Themen in Ihren bedingten Ausdruck aufnehmen, und Klammern werden unterstützt. Unterstützte Operatoren: && , || .

Thema HTTP-POST-Anfrage

An ein einzelnes Thema senden:

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


An Geräte senden, die die Themen „Hunde“ oder „Katzen“ abonniert haben:

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


Thema HTTP-Antwort

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

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

Thema XMPP-Nachricht

An ein einzelnes Thema senden:

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


  </gcm>
</message>

An Geräte senden, die die Themen „Hunde“ oder „Katzen“ abonniert haben:

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


  </gcm>
</message>

Thema XMPP-Antwort

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

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

Rechnen Sie mit einer Verzögerung von bis zu 30 Sekunden, bevor der FCM-Server eine Erfolgs- oder Fehlerantwort auf die Topic-Sendeanforderungen zurückgibt. Stellen Sie sicher, dass Sie den Timeout-Wert des App-Servers in der Anfrage entsprechend festlegen.

Nachrichten an Gerätegruppen senden

Das Senden von Nachrichten an eine Gerätegruppe ist dem Senden von Nachrichten an ein einzelnes Gerät sehr ähnlich. Legen Sie den to -Parameter auf den eindeutigen Benachrichtigungsschlüssel für die Gerätegruppe fest. Einzelheiten zur Payload-Unterstützung finden Sie unter Nachrichtentypen . Beispiele auf dieser Seite zeigen, wie Datennachrichten an Gerätegruppen in den Legacy-Protokollen HTTP und XMPP gesendet werden.

HTTP-POST-Anfrage der Gerätegruppe

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

HTTP-Antwort der Gerätegruppe

Hier ist ein Beispiel für „Erfolg“ – dem notification_key sind zwei Registrierungstoken zugeordnet, und die Nachricht wurde erfolgreich an beide gesendet:

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

Hier ist ein Beispiel für „partiellen Erfolg“ – dem notification_key sind 3 Registrierungstoken zugeordnet. Die Nachricht wurde erfolgreich nur an 1 der Registrierungstoken gesendet. Die Antwortnachricht listet die Registrierungstokens ( registration_ids ) auf, die die Nachricht nicht erhalten haben:

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

Wenn eine Nachricht nicht an einen oder mehrere Registrierungstoken zugestellt werden kann, die mit einem notification_key verknüpft sind, sollte der App-Server es mit einem Backoff zwischen den Wiederholungen erneut versuchen.

Wenn der Server versucht, eine Nachricht an eine Gerätegruppe zu senden, die keine Mitglieder hat, sieht die Antwort wie folgt aus, mit 0 Erfolg und 0 Fehler:

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

XMPP-Nachricht der Gerätegruppe

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

XMPP-Antwort der Gerätegruppe

Wenn die Nachricht erfolgreich an eines der Geräte in der Gruppe gesendet wurde, antwortet der XMPP-Verbindungsserver mit einem ACK. Wenn alle an alle Geräte in der Gruppe gesendeten Nachrichten fehlschlagen, antwortet der XMPP-Verbindungsserver mit einem NACK.

Hier ist ein Beispiel für „Erfolg“ – dem notification_key sind 3 Registrierungstoken zugeordnet, und die Nachricht wurde erfolgreich an alle gesendet:

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

Hier ist ein Beispiel für „partiellen Erfolg“ – dem notification_key sind 3 Registrierungstoken zugeordnet. Die Nachricht wurde erfolgreich nur an 1 der Registrierungstoken gesendet. Die Antwortnachricht listet die Registrierungstoken auf, die die Nachricht nicht erhalten haben:

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

Wenn der FCM-Verbindungsserver nicht an alle Geräte in der Gruppe liefern kann. Der App-Server erhält eine NACK-Antwort.

Die vollständige Liste der Nachrichtenoptionen finden Sie in den Referenzinformationen für das von Ihnen gewählte Verbindungsserverprotokoll, HTTP oder XMPP .

Legacy-Sendemethoden des Firebase Admin SDK

Das Node.js-SDK von Firebase Admin unterstützt Methoden zum Senden von (FCM-)Nachrichten basierend auf der Legacy-FCM-Server-API . Diese Methoden akzeptieren andere Argumente als die Methode send() . Sie sollten nach Möglichkeit die send() Methode verwenden und nur die auf dieser Seite beschriebenen Methoden verwenden, wenn Sie Nachrichten an einzelne Geräte oder Gerätegruppen senden.

An einzelne Geräte senden

Sie können ein Registrierungstoken an die Methode sendToDevice() , um eine Nachricht an dieses Gerät zu senden:

Node.js

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

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

// Send a message to the device corresponding to the provided
// registration token.
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);
  });

Die Methode sendToDevice() kann auch eine Multicast -Nachricht (d. h. eine Nachricht an mehrere Geräte) senden, indem sie ein Array von Registrierungstoken anstelle nur eines einzigen Registrierungstokens übergibt:

Node.js

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

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

// Send a message to the devices corresponding to the provided
// registration tokens.
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);
  });

Die sendToDevice() Methode gibt eine Zusage zurück, die mit einem MessagingDevicesResponse -Objekt aufgelöst wird, das die Antwort von FCM enthält. Der Rückgabetyp hat dasselbe Format, wenn ein einzelnes Registrierungstoken oder ein Array von Registrierungstoken übergeben wird.

Einige Fälle wie ein Authentifizierungsfehler oder eine Ratenbegrenzung führen dazu, dass die gesamte Nachricht nicht verarbeitet werden kann. In diesen Fällen wird das von sendToDevice() zurückgegebene Promise mit einem Fehler zurückgewiesen. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-FCM-API-Fehler .

An eine Gerätegruppe senden

Gerätegruppen-Messaging ermöglicht es Ihnen, mehrere Geräte zu einer einzelnen Gruppe hinzuzufügen. Dies ähnelt dem Themen-Messaging, beinhaltet jedoch eine Authentifizierung, um sicherzustellen, dass die Gruppenmitgliedschaft nur von Ihren Servern verwaltet wird. Wenn Sie beispielsweise verschiedene Nachrichten an verschiedene Telefonmodelle senden möchten, können Ihre Server Registrierungen zu den entsprechenden Gruppen hinzufügen/entfernen und die entsprechende Nachricht an jede Gruppe senden. Das Messaging von Gerätegruppen unterscheidet sich vom Topic-Messaging dadurch, dass es die Verwaltung von Gerätegruppen von Ihren Servern und nicht direkt in Ihrer Anwendung umfasst.

Sie können Gerätegruppennachrichten über die alten XMPP- oder HTTP -Protokolle auf Ihrem App-Server verwenden. Ältere Versionen des Firebase Admin SDK für Node.js basieren auf den Legacy-Protokollen und bieten auch Nachrichtenfunktionen für Gerätegruppen. Die maximal zulässige Anzahl von Mitgliedern für einen Benachrichtigungsschlüssel beträgt 20.

Sie können Gerätegruppen erstellen und Benachrichtigungsschlüssel über einen App-Server oder einen Android-Client generieren. Einzelheiten finden Sie unter Verwalten von Gerätegruppen .

Mit der Methode sendToDeviceGroup() können Sie eine Nachricht an eine Gerätegruppe senden, indem Sie den Benachrichtigungsschlüssel für diese Gerätegruppe angeben:

Node.js

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

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

// Send a message to the device group corresponding to the provided
// notification key.
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);
  });

Die sendToDeviceGroup() Methode gibt eine Zusage zurück, die mit einem MessagingDevicesResponse -Objekt aufgelöst wird, das die Antwort von FCM enthält.

Einige Fälle wie ein Authentifizierungsfehler oder eine Ratenbegrenzung führen dazu, dass die gesamte Nachricht nicht verarbeitet werden kann. In diesen Fällen wird das von sendToDeviceGroup() zurückgegebene Promise mit einem Fehler zurückgewiesen. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-FCM-API-Fehler .

Definieren der Nachrichtennutzlast

Die obigen Verfahren, die auf den alten FCM-Protokollen basieren, akzeptieren eine Nachrichtennutzlast als ihr zweites Argument und unterstützen sowohl Benachrichtigungs- als auch Datennachrichten . Sie können einen oder beide Nachrichtentypen angeben, indem Sie ein Objekt mit den data und / oder notification erstellen. So definieren Sie beispielsweise verschiedene Arten von Nachrichtennutzlasten:

Benachrichtigungsnachricht

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

Datennachricht

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

Kombinierte Nachricht

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

Nutzlasten von Benachrichtigungsnachrichten haben eine vordefinierte Teilmenge gültiger Eigenschaften und unterscheiden sich geringfügig, je nachdem, auf welches mobile Betriebssystem Sie abzielen. Eine vollständige Liste finden Sie in den Referenzdokumenten für NotificationMessagePayload .

Nutzlasten von Datennachrichten bestehen aus benutzerdefinierten Schlüssel-Wert-Paaren mit einigen Einschränkungen, einschließlich der Tatsache, dass alle Werte Zeichenfolgen sein müssen. Eine vollständige Liste der Einschränkungen finden Sie in den Referenzdokumenten für DataMessagePayload .

Nachrichtenoptionen festlegen

Die obigen Verfahren, die auf den alten FCM-Protokollen basieren, akzeptieren ein optionales drittes Argument, das einige Optionen für die Nachricht angibt. Das folgende Beispiel sendet beispielsweise eine Nachricht mit hoher Priorität an ein Gerät, das nach 24 Stunden abläuft:

Node.js

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

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

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

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

Eine vollständige Liste der verfügbaren Optionen finden Sie in den Referenzdokumenten für MessagingOptions .