Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Sendeanfragen für App-Server erstellen

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

  • Themenname
  • Zustand
  • Token zur 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 eigenen benutzerdefinierten Feldern oder einer Nachricht mit beiden Arten von Nutzdaten senden. Siehe Nachrichtentypen für weitere Informationen.

Beispiele auf dieser Seite zeigen , wie Benachrichtigungsmeldungen senden , um die Firebase Admin SDK (die Träger für Knoten , Java , Python , C # und Go ) und das v1 HTTP - Protokoll . Es gibt auch eine Anleitung für Nachrichten über das Senden von Legacy - HTTP und XMPP - Protokolle .

Nachrichten an bestimmte Geräte senden

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.
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 - String 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 per Multicast an eine Liste von Geräteregistrierungstoken senden. Sie können pro Aufruf bis zu 500 Geräteregistrierungstoken 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 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-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 diese Operation die sendAll() API unter der Motorhaube, wie in den Beispielen gezeigt. Der Rückgabewert ist ein BatchResponse der Antworten Liste entspricht die Reihenfolge der Eingabe Token. 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 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. Reaktionen werden durch eine Reaktion Begrenzungszeichenfolge beginnend mit getrennt --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--

Nachrichten an Themen senden

Nachdem Sie ein Thema erstellt haben, entweder durch Client App - Instanzen zum Thema auf der Client - Seite oder über den Abonnement - Server - API können Sie Nachrichten zum Thema senden. Wenn dies Ihre erste Zeit mit dem Aufbau Sendeaufträge für FCM finden Sie im Handbuch zu Ihrer Server - Umgebung und FCM für wichtigen Hintergrund und Setup - Informationen.

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, die ein boolescher Ausdruck ist, der das Ziel Themen gibt. Zum Beispiel wird die folgende Bedingung Nachrichten an Geräte senden , die abonniert werden 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 kann ein Benutzer, der nicht zu nicht abonniert TopicA die Nachricht nicht erhalten. 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.
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 Batch gruppieren und 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 diese 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 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-Batch-Anfrage, 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ückgegebenen Abfrage BatchResponse zu überprüfen , wie viele der Nachrichten wurden erfolgreich FCM übergeben. Es stellt auch eine Liste von Antworten bereit, die verwendet werden kann, um den Status einzelner Nachrichten zu überprüfen. Die Reihenfolge der Antworten entspricht der Reihenfolge der Meldungen in der Eingabeliste.

Direkte Boot-aktivierte Nachrichten senden (nur Android)

Sie können Nachrichten an Geräte im Direktstartmodus senden, indem Sie die HTTP v1- oder Legacy-HTTP-APIs verwenden. Vor dem Senden an Geräten im direkten Boot - Modus, stellen Sie sicher , dass Sie die Schritte , die zum Client - Geräten zu ermöglichen, FCM - Meldungen im direkten Boot - Modus zu erhalten .

Senden Sie mit der FCM v1 HTTP API

Die Nachrichtenanforderung muss den Schlüssel "direct_boot_ok" : true in den AndroidConfig Optionen des Antrags Körper. 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 FCM-HTTP-API

Die Nachrichtenanforderung muss den Schlüssel enthalten "direct_boot_ok" : true auf der obersten Ebene des Antrags Körper. 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 Direktstartmodus (und auch außerhalb dieses Modus) befinden.

Passen Sie Nachrichten plattformübergreifend an

Das Firebase Admin SDK und das FCM v1 HTTP - Protokoll ermöglichen sowohl Ihre Nachrichtenanforderungen alle Felder in der zur Verfügung stehenden festlegen message Objekt. Das beinhaltet:

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

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

Wann sollten allgemeine Felder verwendet werden?

Verwenden Sie allgemeine Felder, wenn Sie:

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

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

Wann sollten plattformspezifische Felder verwendet werden?

Verwenden Sie plattformspezifische Felder, wenn Sie:

  • Felder nur an bestimmte Plattformen senden
  • Sende plattformspezifische Felder zusätzlich zu den gemeinsamen Bereichen

Jedes Mal , wenn Sie Werte wollen auf bestimmte Plattformen nur senden, verwenden Sie keine gemeinsame Felder; plattformspezifische Felder verwenden. Um beispielsweise eine Benachrichtigung nur an iOS und das Web, aber nicht an Android zu senden, müssen Sie zwei separate Feldersätze verwenden, einen für iOS und einen für das Web.

Wenn Sie Nachrichten mit bestimmten Senden Lieferoptionen für die Verwendung plattformspezifische Felder sie einzustellen. Sie können bei Bedarf unterschiedliche Werte pro Plattform angeben. Selbst wenn Sie jedoch plattformübergreifend im Wesentlichen denselben 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: Benachrichtigungsnachricht mit Farb- und Symboloptionen

Diese Beispiel-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 für die Anzeige auf Android-Geräten fest. Was in der Referenz bemerkt AndroidNotification wird die Farbe in #rrggbb Format angegeben, und das Bild muss eine ziehbar Symbol Ressource lokal für den 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 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"
       }
     }
   }
 }

Siehe die HTTP v1 Referenzdokumentation für die vollständigen Einzelheiten über die verfügbaren Tasten in plattformspezifische Blöcken im Nachrichtentext.

Beispiel: Benachrichtigungsnachricht mit einem benutzerdefinierten Bild

Die folgende Beispiel-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"
       }
     }
   }
 }

Siehe die HTTP v1 Referenzdokumentation für die vollständigen Einzelheiten über die verfügbaren Tasten in plattformspezifische Blöcken im Nachrichtentext.

Beispiel: Benachrichtigungsnachricht mit zugehöriger Klickaktion

Die folgende Beispiel-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:

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

Siehe die HTTP v1 Referenzdokumentation für die vollständigen Einzelheiten über die verfügbaren Tasten in plattformspezifische Blöcken im Nachrichtentext.

Beispiel: Benachrichtigungsnachricht mit Lokalisierungsoptionen

Die folgende Beispiel-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:

Einfaches Zeichnen von zwei Geräten mit Textanzeige in Englisch und Spanisch

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

Siehe die HTTP v1 Referenzdokumentation für die vollständigen Einzelheiten über die verfügbaren Tasten in plattformspezifische Blöcken im Nachrichtentext.

Admin-Fehlercodes

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

Fehlercode Beschreibung und Lösungsschritte
messaging/invalid-argument Ein ungültiges Argument wurde einer FCM-Methode 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 Es wurde ein ungültiges Nachrichtennutzlastobjekt bereitgestellt. Die Fehlermeldung sollte zusätzliche Informationen enthalten.
messaging/invalid-data-payload-key Die Nutzlast der Datennachricht enthält einen ungültigen Schlüssel. Siehe die Referenzdokumentation für DataMessagePayload für eingeschränkte Schlüssel.
messaging/payload-size-limit-exceeded Die bereitgestellte Nachrichtennutzlast überschreitet die FCM-Größenbeschränkungen. Für die meisten Nachrichten beträgt die Grenze 4096 Byte. Für Nachrichten, die an Themen gesendet werden, beträgt die Grenze 2048 Byte. Die Gesamtnutzlastgröße umfasst sowohl Schlüssel als auch Werte.
messaging/invalid-options Es wurde ein ungültiges Nachrichtenoptionsobjekt bereitgestellt. Die Fehlermeldung sollte zusätzliche Informationen enthalten.
messaging/invalid-registration-token Ungültiges Registrierungstoken bereitgestellt. Stellen Sie sicher, dass es mit dem Registrierungstoken übereinstimmt, das die Client-App von der 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. Ein zuvor gültiger Registrierungstoken kann aus verschiedenen Gründen abgemeldet werden, darunter:
  • Die Client-App hat sich selbst bei FCM abgemeldet.
  • Die Client-App wurde automatisch abgemeldet. Dies kann passieren, wenn der Benutzer die Anwendung deinstalliert oder unter iOS, wenn der APNs-Feedbackdienst das APNs-Token als ungültig gemeldet hat.
  • Das Registrierungstoken ist abgelaufen. Beispielsweise könnte Google beschließen, Registrierungstokens zu aktualisieren, oder das APNs-Token ist für iOS-Geräte 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 einen Registrierungstoken Name nicht den vorgesehenen übereinstimmen , deren Paket adressiert restrictedPackageName Option.
messaging/message-rate-exceeded Die Rate der Nachrichten an ein bestimmtes Ziel ist zu hoch. Reduzieren Sie die Anzahl der an dieses Gerät oder dieses Thema gesendeten Nachrichten und versuchen Sie nicht sofort erneut, an dieses Ziel zu senden.
messaging/device-message-rate-exceeded Die Rate der Nachrichten 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, 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 Nachrichten, die für dieses Thema gesendet werden, 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 iOS-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 zum selben Firebase-Projekt gehören. Siehe In Firebase , um Ihre Anwendung für die Dokumentation, wie die Firebase Admin SDKs zu authentifizieren.
messaging/authentication-error Das SDK konnte sich bei den FCM-Servern nicht authentifizieren. Stellen Sie sicher, dass Sie das Firebase Admin SDK mit Anmeldedaten authentifizieren, die über die erforderlichen Berechtigungen zum Senden von FCM-Nachrichten verfügen. Siehe In Firebase , um Ihre Anwendung für die Dokumentation, wie die Firebase Admin SDKs zu authentifizieren.
messaging/server-unavailable Der FCM-Server konnte die Anfrage nicht rechtzeitig verarbeiten. Sie sollten dieselbe Anfrage wiederholen, aber Sie müssen:
  • Ehre der Retry-After - Header , wenn es in der Antwort von dem FCM Connection Server enthält.
  • Implementieren Sie exponentielles Backoff in Ihrem Wiederholungsmechanismus. Wenn Sie beispielsweise eine Sekunde vor dem ersten Versuch gewartet haben, warten Sie mindestens zwei Sekunden vor dem nächsten Versuch, dann vier Sekunden usw. Wenn Sie mehrere Nachrichten senden, verzögern Sie jede Nachricht unabhängig voneinander um einen zusätzlichen zufälligen Betrag, um zu vermeiden, dass für alle Nachrichten gleichzeitig eine neue Anfrage gestellt wird.
Absender, die Probleme verursachen, riskieren, auf die schwarze Liste gesetzt zu werden.
messaging/internal-error Der FCM-Server hat beim Versuch, die Anforderung zu verarbeiten, einen Fehler festgestellt. Sie könnten die gleiche Anfrage nach den Anforderungen in den aufgelisteten wiederholen messaging/server-unavailable Zeile oben. Wenn der Fehler weiterhin besteht, melden Sie bitte das Problem zu unserem Bug Report Support - Kanal.
messaging/unknown-error Es wurde ein unbekannter Serverfehler zurückgegeben. Weitere Informationen finden Sie in der Rohserverantwort 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 mit den alten App-Serverprotokollen

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 Nachrichtenanfragen vereinfachen kann, wenn Sie über HTTP an mehrere Plattformen senden.

Nachrichten an bestimmte Geräte senden

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 Server Antwortformat .

Für die vollständige Liste der Nachrichten - Optionen zur Verfügung , wenn Downstream - Nachrichten an Client - Anwendungen zu senden, finden Sie in die Referenzinformationen für das gewünschte Verbindungsserver - Protokoll, HTTP oder XMPP .

Nachrichten an Themen senden

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

Um zu Kombinationen von mehreren Themen zu senden, muß der App - Server die eingestellte condition Schlüssel (statt dem to Taste) , um eine Booleschen Bedingung , dass gibt das Ziel Themen. Zum Beispiel Nachrichten an Geräte zu senden , die abonnierten 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 hat, 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 erfolgreiche oder fehlgeschlagene Antwort auf die Sendeanforderungen des Themas 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. Stellen Sie den to Parameter der einzigartigen Benachrichtigung Schlüssel für die Gerätegruppe. Siehe Nachrichtentypen für Details auf Nutzlast Unterstützung. Beispiele auf dieser Seite zeigen, wie Datennachrichten an Gerätegruppen in HTTP- und XMPP-Protokollen 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“ - das notification_key hat 2 Registrierung Token mit ihm verbunden, und die Nachricht wurde erfolgreich an beide gesendet:

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

Hier ist ein Beispiel für eine „Teilerfolg“ - die notification_key hat 3 Registrierung Token mit ihm verbunden ist . Die Nachricht wurde nur an 1 der Registrierungstoken erfolgreich gesendet. Die Antwortnachricht listet die Registrierungstoken ( registration_ids ), die die Nachricht erhalten fehlgeschlagen:

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

Wenn eine Nachricht an einen oder mehrere der Eintragung geliefert werden nicht mit einem zugehörigen Token notification_key , sollte die App - Server mit Backoff zwischen Wiederholungen wiederholen.

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

{
  "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 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“ - das notification_key hat 3 Registrierung Token mit ihm verbunden, und die Nachricht wurde erfolgreich auf alle von ihnen gesendet:

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

Hier ist ein Beispiel für eine „Teilerfolg“ - die notification_key hat 3 Registrierung Token mit ihm verbunden ist . Die Nachricht wurde nur an 1 der Registrierungstoken erfolgreich 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 liefert. Der App-Server erhält eine Nack-Antwort.

Für die vollständige Liste der Nachrichten - Optionen finden Sie in die Referenzinformationen für das gewünschte Verbindungsserver - Protokoll, HTTP oder XMPP .

Alte Sendemethoden des Firebase Admin SDK

Das Firebase Admin Node.js SDK unterstützt Methoden zum Senden (FCM) -Nachrichten auf dem basierend Legacy - FCM - Server - API . Diese Methoden nehmen verschiedene Argumente im Vergleich zu der send() Methode. Sie sollten die Verwendung send() Methode , wann immer möglich, und nur die Methoden in dieser Seite beschrieben verwenden , wenn Nachrichten an einzelne Geräte oder Gerätegruppen zu senden.

An einzelne Geräte senden

Sie können eine Anmeldung an das Token passieren sendToDevice() Methode eine Nachricht an das 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 sendToDevice() Methode kann auch eine Multicast - Nachricht senden (das heißt, eine Nachricht an mehrere Geräte) durch ein Feld von Registrierungstoken vorbei statt nur einer einzigen Anmeldung Token:

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 ein Versprechen , das mit einem behoben ist MessagingDevicesResponse Objekt enthält die Antwort von FCM. Der Rückgabetyp hat das gleiche Format, wenn ein einzelnes Registrierungstoken oder ein Array von Registrierungstoken übergeben wird.

In einigen Fällen wie einem Authentifizierungsfehler oder einer Ratenbegrenzung kann die gesamte Nachricht nicht verarbeitet werden. In diesen Fällen kehrten die Versprechen von sendToDevice() mit einem Fehler zurückgewiesen. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Admin FCM API - Fehler .

An eine Gerätegruppe senden

Mit der Nachrichtenübermittlung für Gerätegruppen können Sie mehrere Geräte zu einer einzelnen Gruppe hinzufügen. Dies ähnelt dem Themen-Messaging, beinhaltet jedoch eine Authentifizierung, um sicherzustellen, dass die Gruppenmitgliedschaft nur von Ihren Servern verwaltet wird. Wenn Sie beispielsweise unterschiedliche 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. Gerätegruppen-Messaging unterscheidet sich von Themen-Messaging dadurch, dass Gerätegruppen von Ihren Servern aus verwaltet werden, anstatt direkt in Ihrer Anwendung.

Sie können Gerätegruppe Messaging über das Vermächtnis verwenden XMPP oder HTTP - Protokolle auf dem Applikationsserver. Firebase Admin SDK für Node.js basierend auf den Legacy - Protokolle auch Fähigkeiten Gerätegruppe Messaging bieten. Die maximale Anzahl von Mitgliedern für einen Benachrichtigungsschlüssel beträgt 20.

Über einen App-Server oder einen Android-Client können Sie Gerätegruppen erstellen und Benachrichtigungsschlüssel generieren. Siehe Verwalten von Gerätegruppen für weitere Einzelheiten.

Die sendToDeviceGroup() Methode können Sie durch die Angabe der Benachrichtigungsschlüssel für diese Gerätegruppe eine Nachricht an eine Gerätegruppe senden:

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 ein Versprechen , das mit einem behoben ist MessagingDeviceGroupResponse Objekt enthält die Antwort von FCM.

In einigen Fällen wie einem Authentifizierungsfehler oder einer Ratenbegrenzung kann die gesamte Nachricht nicht verarbeitet werden. In diesen Fällen kehrten die Versprechen von sendToDeviceGroup() mit einem Fehler zurückgewiesen. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Admin FCM API - Fehler .

Definieren der Nachrichtennutzlast

Die obigen Verfahren auf der Grundlage der FCM legacy Protokolle akzeptieren eine Nachrichtennutzlast als ihr zweites Argument und unterstützen beide Benachrichtigung und Datennachricht . Sie können mit den durch die Schaffung eines Objekts eine oder beide Nachrichtentypen angeben data und / oder notification Tasten. 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'
  }
};

Die Nutzlasten von Benachrichtigungsnachrichten haben eine vordefinierte Teilmenge gültiger Eigenschaften und unterscheiden sich geringfügig, je nachdem, welches mobile Betriebssystem Sie ansprechen. Siehe die Referenz - Dokumentation für NotificationMessagePayload für eine vollständige Liste.

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. Siehe die Referenz - Dokumentation für DataMessagePayload für eine vollständige Liste der Einschränkungen.

Nachrichtenoptionen definieren

Die obigen Verfahren, die auf den FCM-Legacy-Protokollen basieren, akzeptieren ein optionales drittes Argument, das einige Optionen für die Nachricht spezifiziert. Im folgenden Beispiel wird beispielsweise eine Nachricht mit hoher Priorität an ein Gerät gesendet, die 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);
  });

Siehe die Referenz - Dokumentation für MessagingOptions für eine vollständige Liste der verfügbaren Optionen.