Google is committed to advancing racial equity for Black communities. See how.
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Erstellen Sie App Server-Sendeanforderungen

Mit den Protokollen des Firebase Admin SDK oder des FCM-App-Servers können Sie Nachrichtenanforderungen erstellen und an folgende Zieltypen senden:

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

Sie können Nachrichten mit einer Benachrichtigungsnutzlast senden, die aus vordefinierten Feldern, einer Datennutzlast Ihrer eigenen benutzerdefinierten Felder oder einer Nachricht mit beiden Nutzlasttypen besteht. Weitere Informationen finden Sie unter Nachrichtentypen .

Beispiele auf dieser Seite zeigen, wie Benachrichtigungsnachrichten mit dem Firebase Admin SDK (das Node , Java , Python , C # und Go unterstützt ) und dem HTTP-Protokoll v1 gesendet werden . Es gibt auch Anleitungen zum Senden von Nachrichten über die alten 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. Weitere Informationen zu Registrierungstoken finden Sie in den Client-Setup-Informationen für Ihre Plattform.

Node.js

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

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

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

Java

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

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

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

Python

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

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

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

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

Befehl cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
   "notification":{
     "title":"FCM Message",
     "body":"This is an FCM Message"
   },
   "token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send

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 HTTP-Protokollantwort ist ein einzelner JSON-Schlüssel:

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

Senden Sie Nachrichten an mehrere Geräte

Mit der REST-API und den Admin-FCM-APIs können Sie eine Nachricht an eine Liste von Geräteregistrierungstoken per Multicast senden. 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,
}

admin.messaging().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 100 registration tokens.
// This registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}
message := &messaging.MulticastMessage{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Tokens: registrationTokens,
}

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

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

C #

// Create a list containing up to 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-Anforderung:

--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 Anforderung in einer Datei (in diesem Beispiel batch_request.txt). Verwenden Sie dann den Befehl cURL:

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() unter der Haube, 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,
}

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

Java

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

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

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

Python

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

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

Gehen

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

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

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

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

C #

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

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

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

SICH AUSRUHEN

Jeder Send-Sub-Send gibt 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, indem Sie entweder Client-App-Instanzen für das Thema auf der Clientseite oder über die Server-API abonnieren, können Sie Nachrichten an das Thema senden. Wenn Sie zum ersten Mal Sendeanforderungen für FCM erstellen, finden Sie im Hintergrund zu Ihrer Serverumgebung und FCM wichtige Hintergrund- und Einrichtungsinformationen.

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

Node.js

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

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

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

Java

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

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

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

Python

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

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

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

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

Befehl cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
  "message": {
    "topic" : "foo-bar",
    "notification": {
      "body": "This is a Firebase Cloud Messaging Topic Message!",
      "title": "FCM Message"
    }
  }
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Geben Sie zum Senden einer Nachricht an eine Kombination von Themen eine Bedingung an . Hierbei handelt es sich um einen booleschen Ausdruck, 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. In dem 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 bedingten Ausdruck 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.
var condition = "'stock-GOOG' in topics || 'industry-tech' in topics";

// See documentation on defining a message payload.
var 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.
admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Java

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

// See documentation on defining a message payload.
Message message = Message.builder()
    .setNotification(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",
    }
  }
}

Befehl cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
  "notification": {
    "title": "FCM Message",
    "body": "This is a Firebase Cloud Messaging Topic Message!",
  },
  "condition": "'dogs' in topics || 'cats' in topics"
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

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 alle in einem einzigen API-Aufruf senden. Dies führt zu einer deutlichen Leistungsverbesserung gegenüber dem Senden separater HTTP-Anforderungen für jede Nachricht.

Mit dieser Funktion können Sie einen benutzerdefinierten Satz von Nachrichten erstellen und diese an verschiedene Empfänger senden, einschließlich Themen oder bestimmter Token für die Geräteregistrierung. Verwenden Sie diese Funktion, wenn Sie beispielsweise gleichzeitig Nachrichten an verschiedene Zielgruppen mit geringfügig unterschiedlichen Details im Nachrichtentext 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',
});

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

Java

// Create a list containing up to 500 messages.
List<Message> messages = Arrays.asList(
    Message.builder()
        .setNotification(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 100 messages.
messages := []*messaging.Message{
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "5% off all electronics",
		},
		Token: registrationToken,
	},
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "2% off all books",
		},
		Topic: "readers-club",
	},
}

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

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

C #

// Create a list containing up to 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. Außerdem wird eine Liste von Antworten angezeigt, mit denen der Status einzelner Nachrichten überprüft werden kann. Die Reihenfolge der Antworten entspricht der Reihenfolge der Nachrichten in der Eingabeliste.

Senden Sie direkt bootfähige Nachrichten (nur für Android)

Sie können Nachrichten im Direktstartmodus mithilfe der HTTP v1- oder älteren HTTP-APIs an Geräte senden. Stellen Sie vor dem Senden an Geräte im Direktstartmodus sicher, dass Sie die Schritte ausgeführt haben, damit Clientgeräte FCM-Nachrichten im Direktstartmodus empfangen können .

Senden mit der FCM v1-HTTP-API

Die Nachrichtenanforderung muss den Schlüssel "direct_boot_ok" : true in den AndroidConfig Optionen des Anforderungshauptteils. Beispielsweise:

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 mit der FCM-Legacy-HTTP-API

Die Nachrichtenanforderung muss den Schlüssel "direct_boot_ok" : true auf der obersten Ebene des Anforderungshauptteils. Beispielsweise:

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
}

Mit diesem Schlüssel im Anforderungshauptteil gesendete Nachrichten können von Apps auf Geräten verarbeitet werden, die sich derzeit im Direktstartmodus befinden (und auch, wenn sie sich nicht in diesem Modus befinden).

Passen Sie Nachrichten plattformübergreifend an

Mit dem Firebase Admin SDK und dem HTTP-Protokoll FCM v1 können Ihre Nachrichtenanforderungen alle im message verfügbaren Felder festlegen. Das beinhaltet:

  • Ein gemeinsamer Satz von Feldern, die von allen App-Instanzen interpretiert werden sollen, die die Nachricht empfangen.
  • Plattformspezifische AndroidConfig wie AndroidConfig und WebpushConfig werden nur von App-Instanzen interpretiert, die auf der angegebenen Plattform ausgeführt werden.

Plattformspezifische Blöcke bieten Ihnen Flexibilität beim Anpassen von Nachrichten für verschiedene Plattformen, 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 werden allgemeine Felder verwendet?

Verwenden Sie allgemeine Felder, wenn Sie:

  • Targeting von App-Instanzen auf allen Plattformen - iOS, Android und Web
  • Senden von Nachrichten an Themen

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

Wann werden plattformspezifische Felder verwendet?

Verwenden Sie plattformspezifische Felder, wenn Sie:

  • 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 allgemeinen Felder. Verwenden Sie plattformspezifische Felder. Um beispielsweise eine Benachrichtigung nur an iOS und das Web, nicht jedoch an Android zu senden, müssen Sie zwei separate Feldsätze verwenden, eines für iOS und eines für das Web.

Wenn Sie Nachrichten mit bestimmten Zustelloptionen senden, verwenden Sie plattformspezifische Felder, um sie festzulegen. Sie können bei Bedarf unterschiedliche Werte pro Plattform angeben. Selbst wenn Sie plattformübergreifend im Wesentlichen den gleichen Wert festlegen möchten, müssen Sie plattformspezifische Felder verwenden. Dies liegt daran , dass jede Plattform den Wert interpretieren kann etwas anders, zum Beispiel Time-to-live auf Android als Ablaufzeit in Sekunden eingestellt, während auf iOS es als Ablaufdatum festgelegt ist.

Beispiel: Benachrichtigung mit Farb- und Symboloptionen

Diese Beispielanforderung zum Senden sendet einen gemeinsamen Benachrichtigungstitel und -inhalt an alle Plattformen, sendet jedoch auch einige plattformspezifische Überschreibungen an Android-Geräte.

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

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

Node.js

var admin = require("firebase-admin")

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

var topicName = 'industry-tech'

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

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

Java

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 Referenzdokumentation zu HTTP v1 .

Beispiel: Benachrichtigungsnachricht mit einem benutzerdefinierten Bild

Das folgende Beispiel für eine Sendeanforderung sendet einen gemeinsamen Benachrichtigungstitel an alle Plattformen, sendet jedoch auch ein Bild. Hier ist eine Annäherung an den visuellen Effekt auf dem Gerät eines Benutzers:

Node.js

var admin = require("firebase-admin")

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

var topicName = 'industry-tech'

var message = {
  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''
    }
  },
  topic: topicName,
};

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

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 Referenzdokumentation zu HTTP v1 .

Beispiel: Benachrichtigungsnachricht mit einer zugehörigen Klickaktion

Das folgende Beispiel für eine Sendeanforderung sendet einen gemeinsamen Benachrichtigungstitel an alle Plattformen, sendet jedoch 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:

Node.js

var admin = require("firebase-admin")

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

var topicName = 'industry-tech'

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

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

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 Referenzdokumentation zu HTTP v1 .

Beispiel: Benachrichtigungsnachricht mit Lokalisierungsoptionen

Das folgende Beispiel für eine 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:

Node.js

var admin = require("firebase-admin")

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

var topicName = 'industry-tech'

var message = {
  android: {
    ttl: 3600000,
    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']
        }
      }
    }
  },
  topic: topicName,
};

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

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 Referenzdokumentation zu HTTP v1 .

Admin-Fehlercodes

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

Fehlercode Beschreibungs- und Auflösungsschritte
messaging/invalid-argument Für eine FCM-Methode wurde ein ungültiges Argument angegeben. 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 Datennachrichtennutzdaten enthalten einen ungültigen Schlüssel. DataMessagePayload zu eingeschränkten Schlüsseln finden Sie in der Referenzdokumentation zu DataMessagePayload .
messaging/payload-size-limit-exceeded Die bereitgestellte Nachrichtennutzlast überschreitet die FCM-Größenbeschränkungen. Das Limit beträgt für die meisten Nachrichten 4096 Byte. 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ültiger Registrierungstoken bereitgestellt. Stellen Sie sicher, dass es mit dem Registrierungstoken übereinstimmt, das die Client-App von der Registrierung bei FCM erhält. Schneiden Sie keine zusätzlichen Zeichen ab oder fügen Sie sie hinzu.
messaging/registration-token-not-registered Das bereitgestellte Registrierungstoken ist nicht registriert. Ein zuvor gültiger Registrierungstoken kann aus verschiedenen Gründen nicht registriert werden, darunter:
  • Die Client-App hat sich von FCM abgemeldet.
  • Die Client-App wurde automatisch abgemeldet. Dies kann passieren, wenn der Benutzer die Anwendung deinstalliert oder unter iOS, wenn der APNs Feedback Service das APNs-Token als ungültig gemeldet hat.
  • Das Registrierungstoken ist abgelaufen. Beispielsweise kann Google entscheiden, Registrierungstoken zu aktualisieren, oder das APN-Token ist für iOS-Geräte 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 Paketname" ü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 wiederholen Sie das Senden an dieses Ziel nicht sofort.
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 wiederholen Sie das Senden an dieses Gerät nicht sofort.
messaging/topics-message-rate-exceeded Die Rate der Nachrichten an Abonnenten eines bestimmten Themas ist zu hoch. Reduzieren Sie die Anzahl der für dieses Thema gesendeten Nachrichten und wiederholen Sie das Senden an dieses Thema nicht sofort.
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 auf ein iOS-Gerät gerichtete Nachricht konnte nicht gesendet werden, da das erforderliche SSN-Zertifikat des APN nicht hochgeladen wurde oder abgelaufen ist. Überprüfen Sie die Gültigkeit Ihrer Entwicklungs- und Produktionszertifikate.
messaging/mismatched-credential Der zur Authentifizierung dieses SDK verwendete Berechtigungsnachweis hat keine Berechtigung zum Senden von Nachrichten an das Gerät, die dem bereitgestellten Registrierungstoken entsprechen. Stellen Sie sicher, dass sowohl der Berechtigungsnachweis als auch das Registrierungstoken zum selben Firebase-Projekt gehören. Weitere Informationen zur Authentifizierung der Firebase Admin-SDKs finden Sie unter Hinzufügen von Firebase zu Ihrer App .
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 entsprechenden Berechtigungen zum Senden von FCM-Nachrichten verfügt. Weitere Informationen zur Authentifizierung der Firebase Admin-SDKs finden Sie unter Hinzufügen von Firebase zu Ihrer App .
messaging/server-unavailable Der FCM-Server konnte die Anforderung nicht rechtzeitig verarbeiten. Sie sollten dieselbe Anfrage erneut versuchen, müssen jedoch:
  • Beachten Sie den Retry-After Header, wenn er in der Antwort des FCM-Verbindungsservers enthalten ist.
  • Implementieren Sie ein exponentielles Back-Off in Ihrem Wiederholungsmechanismus. Wenn Sie beispielsweise eine Sekunde vor dem ersten erneuten Versuch gewartet haben, warten Sie mindestens zwei Sekunden vor dem nächsten, dann vier Sekunden und so weiter. Wenn Sie mehrere Nachrichten senden, verzögern Sie jede unabhängig voneinander um einen zusätzlichen zufälligen Betrag, um zu vermeiden, dass für alle Nachrichten gleichzeitig eine neue Anforderung ausgegeben wird.
Absender, die Probleme verursachen, laufen Gefahr, auf die schwarze Liste gesetzt zu werden.
messaging/internal-error Der FCM-Server hat beim Verarbeiten der Anforderung einen Fehler festgestellt. Sie können dieselbe Anforderung erneut ausführen, indem Sie die in der obigen Zeile " messaging/server-unavailable aufgeführten Anforderungen erfüllen. Wenn der Fehler weiterhin besteht, melden Sie bitte das Problem zu unserem Bug Report Support - Kanal.
messaging/unknown-error Ein unbekannter Serverfehler wurde zurückgegeben. Weitere Informationen finden Sie in der Antwort des Raw-Servers in der Fehlermeldung. Wenn Sie diesen Fehler erhalten, benutzen Sie bitte die vollständige Fehlermeldung zu unserem Bericht Bug Report Support - Kanal.

Senden Sie Nachrichten mithilfe der Legacy-App-Server-Protokolle

Wenn Sie die älteren Protokolle bevorzugen, erstellen Sie Nachrichtenanforderungen wie in diesem Abschnitt gezeigt. Beachten Sie, 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, stellen Sie die senden , to Schlüssel für die für die jeweilige App - Instanz Token - Registrierung. Weitere Informationen zu Registrierungstoken finden Sie in den Client-Setup-Informationen für Ihre Plattform.

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

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 ausgewählte Verbindungsserverprotokoll, HTTP oder XMPP .

Senden Sie Nachrichten an Themen

Das Senden von Nachrichten an ein Firebase Cloud Messaging-Thema ähnelt dem Senden von Nachrichten an ein einzelnes Gerät oder an eine Benutzergruppe. Der App-Server setzt den to Schlüssel mit einem Wert wie /topics/yourTopic . Entwickler können einen beliebigen "/topics/[a-zA-Z0-9-_.~%]+" 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. In dem 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 bedingten Ausdruck aufnehmen, und Klammern werden unterstützt. Unterstützte Betreiber: && , || .

Weitere Informationen zu App-Server-Schlüsseln finden Sie in den Referenzinformationen für das von Ihnen ausgewählte Verbindungsserverprotokoll, HTTP oder XMPP . Beispiele auf dieser Seite zeigen, wie Nachrichten an Themen in HTTP und XMPP gesendet werden.

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

Erwarten Sie eine Verzögerung von bis zu 30 Sekunden, bevor der FCM-Server eine erfolgreiche oder fehlerhafte Antwort auf die Sendeanforderungen des Themas zurückgibt. Stellen Sie sicher, dass der Timeout-Wert des App-Servers in der Anforderung entsprechend festgelegt wird.

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

Senden Sie Nachrichten an Gerätegruppen

Das Senden von Nachrichten an eine Gerätegruppe ist dem Senden von Nachrichten an ein einzelnes Gerät sehr ähnlich. Stellen Sie den to Parameter der einzigartigen Benachrichtigung Schlüssel für die Gerätegruppe. Weitere Informationen zur Nutzlastunterstützung finden Sie unter Nachrichtentypen . Beispiele auf dieser Seite zeigen, wie Datennachrichten in HTTP- und XMPP-Protokollen an Gerätegruppen gesendet werden.

Gerätegruppen-HTTP-POST-Anforderung

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

Gerätegruppe der Gerätegruppe

Hier ist ein Beispiel für "Erfolg": Dem notification_key sind 2 Registrierungstoken zugeordnet, und die Nachricht wurde erfolgreich an beide gesendet:

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

Hier ist ein Beispiel für "Teilerfolg" - dem notification_key sind 3 Registrierungstoken zugeordnet. Die Nachricht wurde erfolgreich nur an 1 der Registrierungstoken gesendet. In der Antwortnachricht werden die Registrierungstoken aufgelistet, die die Nachricht nicht empfangen haben:

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

Wenn eine Nachricht nicht an eines oder mehrere der mit einem notification_key verknüpften Registrierungstoken übermittelt werden kann, sollte der App-Server zwischen den Wiederholungsversuchen einen erneuten Versuch mit einem Backoff durchführen.

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

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

Gerätegruppen-XMPP-Nachricht

<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 einer Bestätigung. 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 "Teilerfolg" - dem notification_key sind 3 Registrierungstoken zugeordnet. Die Nachricht wurde erfolgreich nur an 1 der Registrierungstoken gesendet. In der Antwortnachricht werden die Registrierungstoken aufgelistet, die die Nachricht nicht empfangen 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 übermittelt werden 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 ausgewählte Verbindungsserverprotokoll, HTTP oder XMPP .

Legacy-Sendemethoden für Firebase Admin SDK

Das Firebase Admin Node.js SDK unterstützt Methoden zum Senden von FCM-Nachrichten basierend auf der Legacy FCM-Server-API . Diese Methoden akzeptieren andere Argumente als die send() -Methode. 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.
var registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';

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

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

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

Node.js

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

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

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

Die sendToDevice() -Methode gibt ein Versprechen zurück, das mit einem MessagingDevicesResponse Objekt aufgelöst wird, das die Antwort von FCM enthält. Der Rückgabetyp hat das gleiche 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 Versprechen mit einem Fehler abgelehnt. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin FCM API-Fehler .

An eine Gerätegruppe senden

Mit Gerätegruppen-Messaging können Sie einer Gruppe mehrere Geräte hinzufügen. Dies ähnelt dem Thema Messaging, umfasst jedoch die 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 Versenden von Gerätegruppen unterscheidet sich vom Versenden von Themen durch das Verwalten von Gerätegruppen von Ihren Servern anstatt direkt in Ihrer Anwendung.

Sie können Gerätegruppen-Messaging über die alten XMPP- oder HTTP- Protokolle auf Ihrem App-Server verwenden. Das Firebase Admin SDK für Node.js, das auf den Legacy-Protokollen basiert, bietet auch Messagingfunktionen für Gerätegruppen. Die maximale Anzahl von Mitgliedern, die für einen Benachrichtigungsschlüssel zulässig sind, beträgt 20.

Sie können Gerätegruppen erstellen und Benachrichtigungsschlüssel über einen App-Server oder einen Android-Client generieren. Weitere Informationen 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 sendToDeviceGroup() :

Node.js

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

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

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

Die sendToDeviceGroup() -Methode gibt ein Versprechen zurück, das mit einem MessagingDeviceGroupResponse 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 Versprechen mit einem Fehler abgelehnt. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin FCM API-Fehler .

Definieren der Nachrichtennutzlast

Die oben auf den FCM-Legacy-Protokollen basierenden Methoden akzeptieren eine Nachrichtennutzlast als 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. Hier erfahren Sie beispielsweise, wie Sie verschiedene Arten von Nachrichtennutzdaten definieren:

Benachrichtigungsnachricht

var 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

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

Kombinierte Nachricht

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

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

Nutzdaten für 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 .

Definieren der Nachrichtenoptionen

Die obigen Methoden, die auf den FCM-Legacy-Protokollen basieren, akzeptieren ein optionales drittes Argument, das einige Optionen für die Nachricht angibt. Im folgenden Beispiel wird beispielsweise eine Nachricht mit hoher Priorität an ein Gerät gesendet, das nach 24 Stunden abläuft:

Node.js

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

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

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

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

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