Utwórz serwer aplikacji na potrzeby wysyłania żądań

Przy użyciu protokołów serwera aplikacji Firebase Admin SDK lub FCM możesz tworzyć żądania wiadomości i wysyłać je do tych typów celów:

  • Nazwa tematu
  • Stan
  • Token rejestracji urządzenia
  • Nazwa grupy urządzeń (tylko protokół)

Możesz wysyłać wiadomości z ładunkiem powiadomień wstępnie zdefiniowanych pól, ładunek danych we własnych polach zdefiniowanych przez użytkownika lub zawierający oba typy ładunków. Zobacz Typy wiadomości, aby dowiedzieć się więcej.

Przykłady na tej stronie pokazują, jak wysyłać powiadomienia za pomocą Firebase Admin SDK (która obsługuje Węzeł, Java, Python, C# oraz Go) v1 protokołu HTTP. Dostępne są też wskazówki dotyczące wysyłania wiadomości za pomocą starszych protokołów HTTP i XMPP.

Wysyłanie wiadomości na określone urządzenia

Aby wysłać wiadomość na konkretne urządzenie, przekaż token rejestracji urządzenia jako wyświetlane. Wyświetl informacje o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej tokeny rejestracji.

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);
FirebaseMessagingSnippets.java

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)
cloud_messaging.py

Go

// 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)
messaging.go

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

REST

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

Polecenie 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

Po udanym działaniu każda metoda wysyłania zwraca identyfikator wiadomości. Firebase Admin SDK powraca ciąg identyfikatora w formacie projects/{project_id}/messages/{message_id}. Odpowiedź protokołu HTTP to pojedynczy klucz JSON:

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

Wysyłanie wiadomości na wiele urządzeń

Interfejsy API Admin FCM umożliwiają multiemisję Możesz określić do 500 urządzeń tokeny rejestracji na wywołanie.

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");
FirebaseMessagingSnippets.java

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))
cloud_messaging.py

Go

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

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

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

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

Zwracana wartość to lista tokenów odpowiadających kolejności tokeny wejściowe. Jest to przydatne, gdy chcesz sprawdzić, które tokeny zawiera błędy.

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);
}
FirebaseMessagingSnippets.java

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))
cloud_messaging.py

Go

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

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

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

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

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

FirebaseMessagingSnippets.cs

Wysyłaj wiadomości do tematów

Po utworzeniu tematu przez zasubskrybowanie instancji aplikacji klienckiej po stronie klienta lub w interfejs API serwera, możesz wysyłać komunikaty do temat. Jeśli po raz pierwszy tworzysz prośby o wysłanie próśb do usługi FCM, zobacz przewodnik środowisko serwera i FCM dla najważniejsze informacje i informacje o konfiguracji.

W logice wysyłania w backendzie określ odpowiednią nazwę tematu Jak widać:

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);
FirebaseMessagingSnippets.java

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)
cloud_messaging.py

Go

// 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)
messaging.go

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

REST

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

Polecenie 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

Aby wysłać wiadomość do kombinacji tematów: Określ warunek, czyli wyrażenie logiczne, które określa kierowania na tematy. Na przykład poniższy warunek spowoduje wysłanie wiadomości do urządzenia z subskrypcją TopicA oraz TopicB lub TopicC:

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

Funkcja FCM najpierw sprawdza warunki w nawiasach, a potem od lewej do prawej. W powyższym wyrażeniu użytkownik zasubskrybował każdy z tematów nie otrzyma wiadomości. Podobnie użytkownik, który nie subskrypcja użytkownika TopicA nie otrzymuje wiadomości. Takie kombinacje mają go otrzymać:

  • TopicA i TopicB
  • TopicA i TopicC

Wyrażenie warunkowe może zawierać maksymalnie 5 tematów.

Aby wysłać do warunku:

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);
FirebaseMessagingSnippets.java

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)
cloud_messaging.py

Go

// 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)
messaging.go

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

REST

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

Polecenie 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

Wysyłanie wiadomości do grup urządzeń

Aby wysyłać wiadomości do grup urządzeń, użyj interfejsu API HTTP w wersji 1. Jeśli obecnie wysyłania do grup urządzeń za pomocą wycofanych, starszych interfejsów API HTTP lub XMPP bądź jego starsze wersje Firebase Admin SDK dla środowiska Node.js na podstawie starszych protokołów, zdecydowanie zalecamy migracja do interfejsu API HTTP w wersji 1 przy najbliższej okazji. Starsze interfejsy API wysyłania zostanie wyłączony i usunięty w czerwcu 2024 r.

Wysyłanie wiadomości do grupy urządzeń jest bardzo podobne do wysyłania wiadomości na pojedyncze urządzenie, w ten sam sposób autoryzować żądania wysłania. Ustaw token do klucza powiadomień grupy:

REST

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":"APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ",
      "data":{
        "hello": "This is a Firebase Cloud Messaging device group message!"
      }
   }
}

Polecenie cURL

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
   "data":{
     "hello": "This is a Firebase Cloud Messaging device group message!"
   },
   "token":"APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ"
}}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send

Wysyłanie grupy wiadomości

Pakiety Admin SDK obsługują wysyłanie wiadomości zbiorczo. Możesz zgrupować do 500 osób wiadomości do jednej partii i wysyłanie ich w ramach jednego wywołania interfejsu API, przy czym znacząco poprawiła wydajność w porównaniu z wysyłaniem osobnych żądań HTTP do każdej wiadomości.

Za pomocą tej funkcji możesz utworzyć niestandardowy zestaw wiadomości i je wysyłać do różnych odbiorców, np. według tematów lub konkretnych tokenów rejestracji urządzenia. Użyj tej funkcji, jeśli na przykład musisz wysyłać komunikaty do różnych odbiorców w nieco odmienny sposób, w treści wiadomości.

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");
FirebaseMessagingSnippets.java

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))
cloud_messaging.py

Go

// Create a list containing up to 500 messages.
messages := []*messaging.Message{
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "5% off all electronics",
		},
		Token: registrationToken,
	},
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "2% off all books",
		},
		Topic: "readers-club",
	},
}

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

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

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

Wysyłanie wiadomości przy włączonym bezpośrednim rozruchu (tylko Android)

Możesz wysyłać wiadomości na urządzenia w trybie bezpośredniego rozruchu za pomocą HTTP w wersji 1 lub starszych interfejsów API HTTP. Przed wysłaniem do: urządzeń w trybie bezpośredniego rozruchu, upewnij się, że zostały wykonane włącz na urządzeniach klienckich odbieranie wiadomości FCM w trybie bezpośredniego rozruchu.

Wyślij przez interfejs API HTTP FCM w wersji 1

Żądanie wiadomości musi zawierać klucz "direct_boot_ok" : true w AndroidConfig opcji treści żądania. Przykład:

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

Wysyłanie przy użyciu starszej wersji interfejsu HTTP API FCM

U góry prośby o rozpoczęcie czatu musi się znajdować klucz "direct_boot_ok" : true treści żądania. Przykład:

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
}

Wiadomości wysyłane z tym kluczem w treści żądania mogą być obsługiwane przez aplikacje na urządzeniach, które są obecnie w trybie bezpośredniego uruchamiania (i także gdy nie działają w tym trybie).

Dostosuj wiadomości na różnych platformach

Zarówno protokół HTTP Firebase Admin SDK, jak i protokoły HTTP FCM w wersji 1 zezwalają na przesyłanie wiadomości prosi o ustawienie wszystkich pól dostępnych message. obiektu. Obejmuje to:

  • wspólny zestaw pól do interpretowania przez wszystkie instancje aplikacji, które odebranie wiadomości.
  • zestawy pól właściwych dla danej platformy, np. AndroidConfig i WebpushConfig, interpretowane tylko przez instancje aplikacji działające na określonej platformie.

Blokady związane z określoną platformą zapewniają elastyczność w dostosowywaniu komunikatów z różnych platform, aby mieć pewność, że po otrzymaniu pliku będą obsługiwane poprawnie. Backend FCM bierze pod uwagę wszystkie określone parametry i dostosowuje parametr na każdą platformę.

Kiedy używać wspólnych pól

Używaj wspólnych pól, gdy:

  • kierowanie na instancje aplikacji na wszystkich platformach – Apple, Android i sieć.
  • Wysyłanie wiadomości do tematów

Wszystkie instancje aplikacji, niezależnie od platformy, mogą interpretować te wspólne pola:

Kiedy używać pól związanych z konkretną platformą

Użyj pól związanych z konkretną platformą, jeśli chcesz:

  • Wysyłaj pola tylko do określonych platform
  • Wysyłaj pola dotyczące platformy oprócz wspólnych pól.

Jeśli chcesz wysyłać wartości tylko do konkretnych platform, nie używaj: wspólne pola; korzystać z pól związanych z daną platformą. Aby na przykład wysłać powiadomienie, tylko na platformy Apple i internet, ale nie na Androida, musisz użyć dwóch osobnych zbiorów 1 dla Apple, a drugi dla sieci.

Gdy wysyłasz wiadomości z określonymi opcji dostawy, ustaw je za pomocą pól powiązanych z konkretną platformą. Możesz określić różne wartości na każdą platformę, jeśli w dowolnym momencie. Jednak nawet wtedy, gdy chcesz ustawić zasadniczo tę samą wartość musisz użyć pól dotyczących konkretnej platformy. To dlatego, że każda platforma może zinterpretować wartość nieco inaczej – np. czas życia danych to ustawiany na Androidzie jako czas ważności w sekundach, a na Apple data ważności.

Przykład: powiadomienie z opcjami koloru i ikon

To przykładowe żądanie wysłania powoduje wysłanie wspólnego tytułu i treści powiadomienia do wszystkich , ale wysyła też do Androida pewne zastąpienia urządzenia.

W przypadku Androida żądanie to ustawia specjalną ikonę i kolor do wyświetlania na urządzeniach z Androidem. Jak wskazano w pliku referencyjnym Android Notification, kolor jest określony w formacie #rrggbb, a obraz musi być możliwy do rysowania. ikona zasobu lokalnego dla aplikacji na Androida.

Oto szacowany efekt wizualny na urządzenie użytkownika:

Prosty rysunek na 2 urządzeniach, z których jedno wyświetla własną ikonę i kolor

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();
FirebaseMessagingSnippets.java

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',
)
cloud_messaging.py

Go

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",
}
messaging.go

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

REST

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

Zobacz Dokumentacja standardu HTTP v1 aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach związanych z daną platformą w sekcji treść wiadomości.

Przykład: powiadomienie z niestandardowym obrazem

Poniższe przykładowe żądanie wysłania powoduje wysłanie wspólnego tytułu powiadomienia do wszystkich platform, ale powoduje też przesłanie obrazu. Oto w przybliżeniu efekt wizualny na urządzenie użytkownika:

Prosty rysunek z obrazem w powiadomieniu o wyświetlaniu

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

REST

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

Zobacz Dokumentacja standardu HTTP v1 aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach związanych z daną platformą w sekcji treść wiadomości.

Przykład: powiadomienie z powiązanym działaniem powodującym kliknięcie

Poniższe przykładowe żądanie wysłania powoduje wysłanie wspólnego tytułu powiadomienia do wszystkich z platform, ale wysyła też działanie, które aplikacja ma wykonać w odpowiedzi na gdy użytkownik wejdzie w interakcję z powiadomieniem. Oto szacowany efekt wizualny na urządzenie użytkownika:

Prosty rysunek przedstawiający użytkowniczkę otwierającą stronę internetową

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

REST

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

Zobacz Dokumentacja standardu HTTP v1 aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach związanych z daną platformą w sekcji treść wiadomości.

Przykład: powiadomienie z opcjami lokalizacji

Poniższe przykładowe żądanie wysyłania wysyła do klienta opcje lokalizacji umożliwiające wyświetlenie zlokalizowanych wiadomości. Oto szacowany efekt wizualny na urządzenie użytkownika:

Prosty rysunek na 2 urządzeniach wyświetlających tekst w języku angielskim i hiszpańskim

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

REST

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

Zobacz Dokumentacja standardu HTTP v1 aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach związanych z daną platformą w sekcji treść wiadomości.

Kody błędów REST interfejsu HTTP v1 API

Odpowiedzi na błędy HTTP dla interfejsu API HTTP w wersji 1 zawierają kod błędu, komunikat o błędzie i stan błędu. Mogą też zawierać tablicę details ze szczegółowymi informacjami o błędzie.

Oto 2 przykładowe odpowiedzi na błąd:

Przykład 1. Odpowiedź błędu z żądania HTTP w wersji 1 interfejsu API z nieprawidłową wartością w komunikacie z danymi

{
  "error": {
    "code": 400,
    "message": "Invalid value at 'message.data[0].value' (TYPE_STRING), 12",
    "status": "INVALID_ARGUMENT",
    "details": [
      {
        "@type": "type.googleapis.com/google.rpc.BadRequest",
        "fieldViolations": [
          {
            "field": "message.data[0].value",
            "description": "Invalid value at 'message.data[0].value' (TYPE_STRING), 12"
          }
        ]
      }
    ]
  }
}

Przykład 2. Odpowiedź błędu z żądania HTTP w wersji 1 do interfejsu API z nieprawidłowym tokenem rejestracji

{
  "error": {
    "code": 400,
    "message": "The registration token is not a valid FCM registration token",
    "status": "INVALID_ARGUMENT",
    "details": [
      {
        "@type": "type.googleapis.com/google.firebase.fcm.v1.FcmError",
        "errorCode": "INVALID_ARGUMENT"
      }
    ]
   }
}

Pamiętaj, że obie wiadomości mają ten sam kod i ten sam stan, ale tablica details zawiera wartości różnych typów. Pierwszy przykład zawiera typ type.googleapis.com/google.rpc.BadRequest, który wskazuje błąd w wartościach żądań. W drugim przykładzie typu type.googleapis.com/google.firebase.fcm.v1.FcmError występuje błąd związany z FCM. W przypadku wielu błędów tablica details zawiera informacje, które trzeba debugować i znaleźć rozwiązanie.

W tabeli poniżej znajdziesz kody błędów interfejsu API REST FCM w wersji 1. ich opisów.

Kod błędu Etapy opisu i rozwiązania
UNSPECIFIED_ERROR Brak dodatkowych informacji na temat tego błędu. Brak.
INVALID_ARGUMENT (kod błędu HTTP = 400) Parametry żądania były nieprawidłowe. Zwracane jest rozszerzenie typu google.rpc.BadRequest, aby określić, które pole było nieprawidłowe. Potencjalne przyczyny to m.in. nieprawidłowa rejestracja, niewłaściwa nazwa pakietu, zbyt duża wiadomość, nieprawidłowy klucz danych, nieprawidłowa wartość TTL i inne nieprawidłowe parametry.
Nieprawidłowa rejestracja: sprawdź format tokena rejestracji, który przekazujesz na serwer. Upewnij się, że jest on zgodny z tokenem rejestracji, który aplikacja kliencka otrzymuje po rejestracji w FCM. Nie skracaj tokena ani nie dodawaj dodatkowych znaków.
Nieprawidłowa nazwa pakietu: upewnij się, że wiadomość jest zaadresowana na token rejestracji, którego nazwa pakietu pasuje do wartości przekazanej w żądaniu.
Zbyt duża wiadomość: sprawdź, czy łączny rozmiar danych ładunkowych zawartych w wiadomości nie przekracza limitów FCM: 4096 bajtów w przypadku większości wiadomości lub 2048 bajtów w przypadku wiadomości do tematów. Dotyczy to zarówno kluczy, jak i wartości.
Nieprawidłowy klucz danych: sprawdź, czy dane ładunku nie zawierają klucza (takiego jak from, gcm czy wartości poprzedzonej prefiksem google) używanego wewnętrznie przez FCM. Pamiętaj, że niektóre słowa (takie jak fold_key) są również używane przez FCM, ale są dozwolone w ładunku. W takim przypadku wartość ładunku zostanie zastąpiona wartością FCM.
Nieprawidłowa wartość TTL: sprawdź, czy wartość użyta w parametrze ttl jest liczbą całkowitą oznaczającą czas trwania w sekundach z zakresu od 0 do 2 419 200 (4 tygodnie).
Nieprawidłowe parametry: sprawdź, czy podane parametry mają właściwą nazwę i typ.
UNREGISTERED (kod błędu HTTP = 404) Wystąpienie aplikacji zostało wyrejestrowane z FCM. Zwykle oznacza to, że użyty token stracił ważność i trzeba użyć nowego. Przyczyną tego błędu może być brak tokenów rejestracji lub niezarejestrowane tokeny.
Brak rejestracji: jeśli celem wiadomości jest wartość token, sprawdź, czy żądanie zawiera token rejestracji.
Nie zarejestrowano: istniejący token rejestracji może stracić ważność w wielu sytuacjach, takich jak:
– Jeśli aplikacja kliencka wyrejestruje się z FCM.
– Jeśli aplikacja kliencka została automatycznie wyrejestrowana, co może nastąpić po odinstalowaniu aplikacji przez użytkownika. Na przykład w systemie iOS, jeśli usługa opinii APNs zgłosiła token APNs jako nieprawidłowy.
– Jeśli token rejestracji wygaśnie (np. Google może odświeżyć tokeny rejestracji lub token APNs wygasł w przypadku urządzeń z iOS).
– Jeśli aplikacja kliencka jest zaktualizowana, ale nowa wersja nie jest skonfigurowana do odbierania wiadomości.
W tych przypadkach usuń token rejestracji z serwera aplikacji i przestań używać go do wysyłania wiadomości.
SENDER_ID_MISMATCH (kod błędu HTTP = 403) uwierzytelniony identyfikator nadawcy różni się od identyfikatora nadawcy dla tokena rejestracji. Token rejestracji jest powiązany z określoną grupą nadawców. Gdy aplikacja kliencka rejestruje się w FCM, musi określić, którzy nadawcy mogą wysyłać wiadomości. Jeden z tych identyfikatorów nadawcy należy używać podczas wysyłania wiadomości do aplikacji klienckiej. Jeśli zmienisz nadawcę, istniejące tokeny rejestracji przestaną działać.
QUOTA_EXCEEDED (kod błędu HTTP = 429) Przekroczono limit wysyłania w przypadku celu wiadomości. Zwracane jest rozszerzenie typu google.rpc.QuotaFailure, które wskazuje, który limit został przekroczony. Przyczyną tego błędu może być przekroczenie limitu liczby wiadomości na urządzeniu, przekroczenie limitu liczby wiadomości na urządzeniu lub przekroczenie limitu liczby wiadomości w temacie.
Przekroczono liczbę wiadomości: częstotliwość wysyłania wiadomości jest za duża. Musisz zmniejszyć ogólną częstotliwość wysyłania wiadomości. Używaj wykładniczego czasu do ponowienia z minimalnym opóźnieniem początkowym wynoszącym 1 minutę, aby ponawiać próby odrzucenia wiadomości.
Przekroczono liczbę wiadomości na urządzeniu: liczba wiadomości wysyłanych na dane urządzenie jest za duża. Zobacz ograniczenie liczby wiadomości na jednym urządzeniu. Zmniejsz liczbę wiadomości wysyłanych do tego urządzenia i użyj wykładniczego ponawiania, aby spróbować ponownie wysłać pocztę.
Przekroczono liczbę wiadomości z tego tematu: liczba wiadomości do subskrybentów określonego tematu jest za wysoka. Zmniejsz liczbę wiadomości wysyłanych w tym temacie i użyj wykładniczego czasu do ponowienia z minimalnym opóźnieniem początkowym wynoszącym 1 minutę, aby spróbować ponownie wysłać wiadomość.
UNAVAILABLE (kod błędu HTTP = 503) Serwer jest przeciążony. Serwer nie mógł przetworzyć żądania na czas. Ponów tę samą prośbę, ale musisz:
– Uwzględniaj nagłówek Ponów próbę po, jeśli jest on zawarty w odpowiedzi serwera połączenia FCM.
– Wdróż wykładniczy czas ponowienia w mechanizmie ponawiania. (np.jeśli odczekałeś sekundy przed pierwszą próbą, odczekaj co najmniej dwie sekundy przed kolejną, potem 4 sekundy itd.). Jeśli wysyłasz wiele wiadomości, rozważ zastosowanie zakłóceń. Więcej informacji znajdziesz w artykule Obsługa ponownych prób. Nadawcy, którzy powodują problemy, mogą zostać umieszczone na liście odrzuconych.
INTERNAL (kod błędu HTTP = 500) Wystąpił nieznany błąd wewnętrzny. Podczas próby przetworzenia żądania serwer napotkał błąd. Możesz ponowić tę samą prośbę zgodnie z sugestiami w sekcji Obsługa ponownych prób. Jeśli błąd będzie się powtarzał, skontaktuj się z zespołem pomocy Firebase.
THIRD_PARTY_AUTH_ERROR (kod błędu HTTP = 401) nie ma certyfikatu APNs lub klucza uwierzytelniania push push, Nie udało się wysłać wiadomości kierowanej na urządzenie z iOS ani rejestracji push. Sprawdź poprawność swoich uprawnień związanych z programowaniem i produkcją.

Kody błędów administratora

W poniższej tabeli znajdziesz kody błędów interfejsu API Firebase Admin FCM. ich opisy, w tym zalecane sposoby rozwiązania problemu.

Kod błędu Etapy opisu i rozwiązania
messaging/invalid-argument Podano nieprawidłowy argument do metody FCM. Błąd powinien zawierać dodatkowe informacje.
messaging/invalid-recipient Adresat wiadomości jest nieprawidłowy. Komunikat o błędzie powinien zawierają dodatkowe informacje.
messaging/invalid-payload Podano nieprawidłowy obiekt ładunku wiadomości. Komunikat o błędzie powinien zawierają dodatkowe informacje.
messaging/invalid-data-payload-key Ładunek wiadomości z danymi zawiera nieprawidłowy klucz. Zobacz materiał referencyjny dokumentacja dla DataMessagePayload w przypadku kluczy z ograniczeniami.
messaging/payload-size-limit-exceeded Podany ładunek wiadomości przekracza limity rozmiaru (FCM). limit to 4096 bajtów dla większości wiadomości. W przypadku wiadomości wysyłanych do tematów: limit to 2048 bajtów. łączny rozmiar ładunku obejmuje zarówno klucze, jak i wartości.
messaging/invalid-options Podano nieprawidłowy obiekt opcji wiadomości. Komunikat o błędzie powinien zawierają dodatkowe informacje.
messaging/invalid-registration-token Podano nieprawidłowy token rejestracji. Upewnij się, że jest on zgodny z danymi rejestracyjnymi. token, jaki aplikacja kliencka otrzymuje po rejestracji w FCM. Nie wolno go skrócić ani dodać do niego dodatkowych znaków.
messaging/registration-token-not-registered Podany token rejestracji nie został zarejestrowany. Dotychczasowy prawidłowy token rejestracji może zostać wyrejestrowany z różnych powodów, w tym:
  • Aplikacja kliencka wyrejestrowała się z: FCM.
  • Aplikacja kliencka została automatycznie wyrejestrowana. Może się tak zdarzyć, jeśli: użytkownik odinstaluje aplikację, a na platformach Apple – jeśli pojawi się komunikat Usługa zgłosiła token APNs jako nieprawidłowy.
  • Token rejestracji wygasł. Google może na przykład zdecydować się tokeny rejestracji odświeżania lub token APNs mógł wygasnąć dla Urządzenia Apple.
  • Aplikacja kliencka została zaktualizowana, ale nowa wersja nie jest skonfigurowana tak odbieranie wiadomości.
. We wszystkich tych przypadkach usuń token rejestracji i przestań go używać do: wysyłać wiadomości.
messaging/invalid-package-name Wiadomość była zaadresowana na token rejestracji, którego nazwa pakietu nie nie pasuje do podanego restrictedPackageName.
messaging/message-rate-exceeded Odsetek wiadomości do określonego celu jest zbyt duży. Zmniejsz liczbę wiadomości wysłanych na to urządzenie lub ten temat i nie ponawiaj próby wysyłanie do tego miejsca docelowego.
messaging/device-message-rate-exceeded Częstotliwość wiadomości do konkretnego urządzenia jest za duża. Zmniejsz liczbę wiadomości wysłanych na to urządzenie i nie ponawiaj próby wysłania na na tym urządzeniu.
messaging/topics-message-rate-exceeded Częstotliwość wiadomości do subskrybentów określonego tematu jest zbyt duża. Zmniejsz liczbę wiadomości wysyłanych w tym temacie i nie wysyłaj od razu spróbuj wysłać ponownie do tego tematu.
messaging/too-many-topics Token rejestracji został zasubskrybowany do maksymalnej liczby tematów i nie można ich już subskrybować.
messaging/invalid-apns-credentials Nie można wysłać wiadomości kierowanej na urządzenie Apple, ponieważ wymagany certyfikat SSL APNs nie został przesłany lub wygasł. Zajrzyj do ważności certyfikatów programistycznych i produkcyjnych.
messaging/mismatched-credential Dane logowania używane do uwierzytelniania tego pakietu SDK nie mają uprawnień do wysyłania wiadomości do urządzenia odpowiadającego podanej rejestracji token. Sprawdź, czy dane logowania i token rejestracji należą do ten sam projekt Firebase. Zobacz Dodaj Firebase do swojej aplikacji znajdziesz dokumentację dotyczącą uwierzytelniania Firebase Admin SDK.
messaging/authentication-error Pakiet SDK nie mógł uwierzytelnić się na serwerach FCM. Upewnij się, że uwierzytelnij Firebase Admin SDK za pomocą danych logowania z odpowiednim uprawnienia do wysyłania FCM wiadomości. Zobacz Dodaj Firebase do swojej aplikacji znajdziesz dokumentację dotyczącą uwierzytelniania Firebase Admin SDK.
messaging/server-unavailable Serwer FCM nie mógł przetworzyć żądania na czas. Zalecenia ponów tę samą prośbę, ale musisz:
  • Uwzględniaj nagłówek Retry-After, jeśli znajduje się w parametrze odpowiedź z serwera połączenia FCM.
  • Wdróż wykładniczy czas ponowienia w mechanizmie ponawiania. Przykład: jeśli przed pierwszym ponowną próbą upłynęło co najmniej sekundę, poczekaj co najmniej dwa sekund przed następnym, potem cztery sekundy i tak dalej. Jeśli wysyłając kilka wiadomości, opóźnij każdą z nich osobno o losową kwotę, aby uniknąć konieczności wysyłania nowego żądania do wszystkich wiadomości w tym samym czasie.
. Nadawcy, którzy powodują problemy, mogą zostać umieszczone na czarnej liście.
messaging/internal-error Serwer FCM napotkał błąd podczas próby przetworzenia pliku użytkownika. Możesz ponowić tę samą prośbę zgodnie z wymaganiami wymienione w wierszu messaging/server-unavailable powyżej. Jeśli będzie się powtarzać, zgłoś go do naszego Kanał pomocy dotyczący raportu o błędzie.
messaging/unknown-error Został zwrócony nieznany błąd serwera. Nieprzetworzoną odpowiedź serwera znajdziesz w . Jeśli pojawi się ten błąd, zgłoś pełny komunikat o błędzie Kanał pomocy dotyczący raportu o błędzie.

Wysyłanie wiadomości przy użyciu starszych protokołów serwera aplikacji

Jeśli obecnie używasz starszych protokołów, utwórz żądania wiadomości w sposób pokazany poniżej w tej sekcji. Pamiętaj, że jeśli wysyłasz wiadomości na wiele platform przez HTTP, protokół v1 może znacznie uprościć żądania wiadomości.

Wysyłanie wiadomości na określone urządzenia

Aby wysyłać wiadomości na określone urządzenia, ustaw klucz to na wartość rejestracji dla danej instancji aplikacji. Wyświetl informacje o konfiguracji klienta dla Twojego , aby uzyskać więcej informacji o tokenach rejestracji.

Żądanie HTTP POST

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

{ "data": {
    "score": "5x1",
    "time": "15:10"
  },
  "to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}

Odpowiedź HTTP

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

Komunikat XMPP

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

Odpowiedź XMPP

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

Serwer połączenia XMPP oferuje inne opcje odpowiedzi. Zobacz Format odpowiedzi serwera.

Pełną listę opcji wiadomości dostępnych podczas wysyłania kolejnych wiadomości wiadomości do aplikacji klienckich, zapoznaj się z informacjami referencyjnymi dla wybranych protokół serwera połączeń, HTTP lub protokół XMPP.

Wysyłaj wiadomości do tematów

Wysyłanie wiadomości do tematu w usłudze Firebase Cloud Messaging jest bardzo podobne do wysyłania wiadomości na poszczególne urządzenia lub do grupy użytkowników. Aplikacja Serwer ustawia klucz to na wartość taką jak /topics/yourTopic. Deweloperzy mogą wybierz dowolną nazwę tematu, która pasuje do wyrażenia regularnego: "/topics/[a-zA-Z0-9-_.~%]+"

Aby wysyłać wiadomości do kombinacji tematów, serwer aplikacji musi ustawić condition (zamiast klucza to) do warunku logicznego, który określa tematy docelowe. Aby na przykład wysyłać wiadomości na urządzenia, które subskrybują do TopicA i TopicB lub TopicC:

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

Funkcja FCM najpierw sprawdza wszystkie warunki w nawiasach, a następnie ocenia wyrażenie od lewej do prawej. W powyższym wyrażeniu użytkownik zasubskrybował dowolny pojedynczy temat nie odebranie wiadomości. Jeśli użytkownik, który nie subskrybuje TopicA, nie otrzymuje wiadomości. Efekt:

  • Tematy A i B
  • Tematy A i TopicC

Wyrażenie warunkowe może zawierać maksymalnie 5 tematów. Nawiasy są obsługiwane. Obsługiwane operatory: &&, ||.

Żądanie HTTP POST tematu

Wyślij do jednego tematu:

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

Wysyłaj na urządzenia subskrybujące tematy „psy” lub „koty”:

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

Odpowiedź HTTP dotycząca tematu

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

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

Komunikat XMPP z tematu

Wyślij do jednego tematu:

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


  </gcm>
</message>

Wysyłaj na urządzenia subskrybujące tematy „psy” lub „koty”:

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


  </gcm>
</message>

Temat – odpowiedź XMPP

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

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

Oczekuj do 30 sekund opóźnienia przed serwerem FCM zwraca odpowiedź o pomyślnym lub niepowodzeniu do wysyłania żądań do tematu. Upewnij się, , aby odpowiednio ustawić w żądaniu wartość limitu czasu serwera aplikacji.

Wysyłanie wiadomości do grup urządzeń

Wysyłanie wiadomości do grupy urządzeń przy użyciu wycofanych starszych interfejsów API jest bardzo podobny do wysyłania na pojedyncze urządzenie. Ustaw parametr to do unikalnego klucza powiadomień dla grupy urządzeń. Przykłady w tej sekcji pokazują, jak wysyłać dane do grup urządzeń w starszych protokołach HTTP i XMPP.

Żądanie HTTP POST grupy urządzeń 

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

Odpowiedź HTTP grupy urządzeń

Oto przykład „sukcesu” – notification_key ma powiązane 2 tokeny rejestracji, a komunikat udało się wysłać do obu: 

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

Oto przykład „częściowego sukcesu” – Z notification_key powiązane są 3 tokeny rejestracji z nim. Wiadomość została wysłana do 1 z rejestracji tokeny. Komunikat z odpowiedzią zawiera listę tokenów rejestracji. (registration_ids), które nie otrzymały wiadomości: 

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

Gdy wiadomości nie można dostarczyć do co najmniej jednego tokeny rejestracji powiązane z notification_key, serwer aplikacji powinien ponawiać próby z ponawianiem.

Jeśli serwer spróbuje wysłać wiadomość do grupy urządzeń, która nie ma użytkowników, odpowiedź wygląda tak, z 0 powodów i 0 niepowodzeń: 

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

Komunikat XMPP grupy urządzeń 

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

Odpowiedź XMPP grupy urządzeń

Gdy wiadomość zostanie wysłana na dowolne z urządzeń w grupie serwer połączenia XMPP zwraca komunikat ACK. Jeśli wszystkie komunikaty wysyłane do wszystkich urządzeń w grupie kończą się niepowodzeniem, połączenie XMPP w odpowiedzi serwer wysyła żądanie NACK.

Oto przykład „sukcesu” – notification_key ma powiązane 3 tokeny rejestracji, a komunikat wysłano do wszystkich: 

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

Oto przykład „częściowego sukcesu” – Z notification_key powiązane są 3 tokeny rejestracji z nim. Wiadomość została wysłana do 1 z rejestracji tokeny. Komunikat z odpowiedzią zawiera listę tokenów rejestracji. którzy nie odebrali wiadomości: 

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

Gdy serwer połączeń FCM nie może dostarczyć wiadomości do na wszystkich urządzeniach w grupie. Serwer aplikacji otrzyma odpowiedź nack.

Pełną listę opcji dotyczących wiadomości znajdziesz w materiałach referencyjnych dla wybranego protokołu serwera połączeń: HTTP lub protokół XMPP.

Firebase Admin SDK starsze metody wysyłania

Pakiet SDK Firebase Admin Node.js obsługuje metody wysyłania (FCM) wiadomości na podstawie Starszy interfejs API serwera FCM. Te metody przyjmują inne argumenty niż metoda send(). Gdy tylko jest to możliwe, używaj metody send() i używaj wyłącznie opisane na tej stronie przy wysyłaniu wiadomości na poszczególne urządzenia lub grup urządzeń.

Wysyłaj na poszczególne urządzenia

Token rejestracji możesz przekazać do sendToDevice() aby wysłać wiadomość na to urządzenie:

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

Metoda sendToDevice() może też wysyłać wiadomość multicast (czyli do wielu urządzeń), przekazując tablicę tokenów rejestracji pojedynczego tokena rejestracji:

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

Metoda sendToDevice() zwraca obietnicę rozstrzygniętą za pomocą MessagingDevicesResponse. obiekt z odpowiedzią z FCM. Zwracany typ ma takie samo podczas przekazywania pojedynczego tokena rejestracji lub tablicy rejestracyjnej tokeny.

Niektóre przypadki, takie jak błąd uwierzytelniania czy ograniczenie liczby żądań, powodują pełną wiadomości, których nie można przetworzyć. W takich przypadkach obietnica zwrócona przez Prośba sendToDevice() została odrzucona z powodu błędu. Pełną listę kodów błędów znajdziesz w tym opisy i sposoby rozwiązania problemu, zobacz Błędy interfejsu API administratora FCM.

Wyślij do grupy urządzeń

sendToDeviceGroup() umożliwia wysłanie wiadomości do grupy urządzeń przez określenie klawisz powiadomień dla tej grupy urządzeń:

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

Metoda sendToDeviceGroup() zwraca obietnicę rozstrzygniętą za pomocą MessagingDevicesResponse. obiekt z odpowiedzią z FCM.

Niektóre przypadki, takie jak błąd uwierzytelniania czy ograniczenie liczby żądań, powodują pełną wiadomości, których nie można przetworzyć. W takich przypadkach obietnica zwrócona przez Prośba sendToDeviceGroup() została odrzucona z powodu błędu. Pełną listę kodów błędów znajdziesz w tym opisy i sposoby rozwiązania problemu, zobacz Błędy interfejsu API administratora FCM.

Definiowanie ładunku wiadomości

Powyższe metody oparte na starszych protokołach FCM przyjmują ładunek wiadomości jako drugi argument oba powiadomień i wiadomości z danymi. Możesz określić jeden lub oba typy wiadomości, tworząc obiekt za pomocą funkcji data lub notification. Poniżej pokazujemy na przykład, jak definiować różne typy ładunków wiadomości:

Powiadomienie

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

Wiadomość z danymi

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

Połączona wiadomość

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

Ładunki wiadomości z powiadomieniami mają wstępnie zdefiniowany podzbiór prawidłowych właściwości i nieco się różnią w zależności od tego, na jaki system operacyjny na urządzenia mobilne kierujesz reklamy. Zapoznaj się z dokumentami NotificationMessagePayload .

Ładunki komunikatów z danymi składają się z niestandardowych par klucz-wartość z kilkoma m.in. z uwagi na to, że wszystkie wartości muszą być ciągami tekstowymi. Zobacz dokumentacja dla DataMessagePayload aby zobaczyć pełną listę ograniczeń.

Definiowanie opcji wiadomości

Powyższe metody oparte na starszych protokołach FCM zaakceptuj opcjonalny trzeci argument określający opcje dla wiadomość. Na przykład poniższy przykład wysyła wiadomość o wysokim priorytecie na urządzenie, które wygasa po 24 godzinach:

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

Zapoznaj się z dokumentami MessagingOptions , aby zobaczyć pełną listę dostępnych opcji.