Check out what’s new from Firebase@ Google I/O 2021, and join our alpha program for early access to the new Remote Config personalization feature. Learn more

Zbuduj serwer aplikacji wysyłaj żądania

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

  • Nazwa tematu
  • Stan: schorzenie
  • Token rejestracji urządzenia
  • Nazwa grupy urządzeń (starsze protokoły i pakiet Firebase Admin SDK tylko dla Node.js)

Możesz wysyłać wiadomości z ładunkiem powiadomienia złożonym z predefiniowanych pól, ładunkiem danych z własnych pól zdefiniowanych przez użytkownika lub wiadomością zawierającą oba typy ładunku. Zobacz Typy wiadomości, aby uzyskać więcej informacji.

Przykłady na tej stronie pokazują, jak wysyłać powiadomienia za pomocą pakietu Firebase Admin SDK (który obsługuje Node , Java , Python , C# i Go ) oraz protokołu HTTP v1 . Istnieją również wskazówki dotyczące wysyłania wiadomości przy użyciu starszych protokołów HTTP i XMPP .

Wysyłaj wiadomości do określonych urządzeń

Aby wysłać do jednego, konkretnego urządzenia, przekaż token rejestracji urządzenia, jak pokazano. Zobacz informacje o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej o tokenach 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.
admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Jawa

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

Pyton

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

Udać się

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

DO#

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

RESZTA

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, polecenie:

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 pomyślnym zakończeniu każda metoda send zwraca identyfikator wiadomości. Pakiet Firebase Admin SDK zwraca 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łaj wiadomości do wielu urządzeń

Interfejsy API REST i Admin FCM API umożliwiają multiemisję wiadomości do listy tokenów rejestracji urządzeń. Możesz określić do 500 tokenów rejestracji urządzenia na jedno 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,
};

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

Jawa

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

Pyton

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

Udać się

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

DO#

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

RESZTA

Utwórz żądanie wsadowe HTTP:

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

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

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

...

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

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

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

Zapisz żądanie w pliku (w tym przykładzie batch_request.txt). Następnie użyj polecenia cURL:

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

W przypadku pakietów SDK sendAll() Admin ta operacja korzysta z interfejsu API sendAll() pod maską, jak pokazano w przykładach. Wartość zwracana to BatchResponse której lista odpowiedzi odpowiada kolejności tokenów wejściowych. Jest to przydatne, gdy chcesz sprawdzić, które tokeny spowodowały 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,
};

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

Jawa

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

Pyton

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

Udać się

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

DO#

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

RESZTA

Każde wysłanie podrzędne zwraca odpowiedź. Odpowiedzi są oddzielone ciągiem granicy odpowiedzi zaczynającym się od --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--

Wysyłaj wiadomości do tematów

Po utworzeniu tematu, subskrybując wystąpienia aplikacji klienckiej do tematu po stronie klienta lub za pośrednictwem interfejsu API serwera , możesz wysyłać komunikaty do tematu. Jeśli po raz pierwszy budujesz i wysyłasz żądania FCM, zapoznaj się z przewodnikiem po środowisku serwera i FCM, aby uzyskać ważne informacje o tle i konfiguracji.

W logice wysyłania na zapleczu określ żądaną nazwę tematu, jak pokazano:

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

Jawa

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

Pyton

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

Udać się

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

DO#

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

RESZTA

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, polecenie:

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 , który jest wyrażeniem logicznym określającym tematy docelowe. Na przykład następujący warunek spowoduje wysłanie komunikatów do urządzeń zasubskrybowanych w TopicA i TopicB lub TopicC :

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

FCM najpierw ocenia wszystkie warunki w nawiasach, a następnie ocenia wyrażenie od lewej do prawej. W powyższym wyrażeniu użytkownik zasubskrybowany do dowolnego pojedynczego tematu nie otrzymuje wiadomości. Podobnie użytkownik, który nie subskrybuje TopicA , nie otrzymuje wiadomości. Te kombinacje otrzymują to:

  • TopicA i TopicB
  • TopicA i TopicC

W wyrażeniu warunkowym możesz zawrzeć do pięciu 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.
admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Jawa

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

Pyton

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

Udać się

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

DO#

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

RESZTA

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, polecenie:

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

Wyślij partię wiadomości

Interfejsy API REST i pakiety Admin SDK obsługują wysyłanie wiadomości w partiach. Możesz zgrupować do 500 wiadomości w jedną partię i wysłać je wszystkie w jednym wywołaniu interfejsu API, ze znaczną poprawą wydajności w porównaniu z wysyłaniem oddzielnych żądań HTTP dla każdej wiadomości.

Ta funkcja może służyć do tworzenia spersonalizowanego zestawu wiadomości i wysyłania ich do różnych odbiorców, w tym do tematów lub określonych tokenów rejestracji urządzenia. Użyj tej funkcji, gdy na przykład musisz jednocześnie wysyłać wiadomości do różnych odbiorców z nieco innymi szczegółami 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',
});

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

Jawa

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

Pyton

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

Udać się

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

DO#

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

RESZTA

Skonstruuj żądanie wsadowe HTTP, łącząc listę żądań podrzędnych:

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

Możesz BatchResponse zapytanie do zwróconej odpowiedzi BatchResponse aby sprawdzić, ile wiadomości zostało pomyślnie przekazanych do FCM. Udostępnia również listę odpowiedzi, których można użyć do sprawdzenia stanu poszczególnych wiadomości. Kolejność odpowiedzi odpowiada kolejności komunikatów na liście wejściowej.

Wysyłaj wiadomości z włączonym bezpośrednim rozruchem (tylko Android)

Możesz wysyłać wiadomości do urządzeń w trybie rozruchu bezpośredniego przy użyciu interfejsu API HTTP v1 lub starszego interfejsu HTTP. Przed wysłaniem do urządzeń w trybie rozruchu bezpośredniego upewnij się, że wykonano czynności umożliwiające urządzeniom klienckim odbieranie komunikatów FCM w trybie rozruchu bezpośredniego .

Wyślij przy użyciu interfejsu API FCM v1 HTTP

Żądanie wiadomości musi zawierać klucz "direct_boot_ok" : true w opcjach AndroidConfig w treści żądania. Na 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,
    },
}

Wyślij przy użyciu starszego interfejsu API HTTP FCM

Żądanie komunikatu musi zawierać klucz "direct_boot_ok" : true na najwyższym poziomie treści żądania. Na 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 znajdujących się obecnie w trybie rozruchu bezpośredniego (a także wtedy, gdy nie są w tym trybie).

Dostosuj wiadomości na różnych platformach

Pakiet Firebase Admin SDK i protokół HTTP FCM v1 umożliwiają żądaniom wiadomości ustawienie wszystkich pól dostępnych w obiekcie message . To zawiera:

  • wspólny zestaw pól, które mają być interpretowane przez wszystkie wystąpienia aplikacji, które odbierają komunikat.
  • Zestawy pól specyficznych dla platformy, takie jak AndroidConfig i WebpushConfig , interpretowane tylko przez wystąpienia aplikacji działające na określonej platformie.

Bloki specyficzne dla platformy zapewniają elastyczność dostosowywania komunikatów dla różnych platform, aby zapewnić ich prawidłową obsługę po otrzymaniu. Backend FCM weźmie pod uwagę wszystkie określone parametry i dostosuje komunikat dla każdej platformy.

Kiedy używać wspólnych pól

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

  • Kierowanie na instancje aplikacji na wszystkich platformach — iOS, Android i web
  • Wysyłanie wiadomości do tematów

Wszystkie instancje aplikacji, niezależnie od platformy, mogą interpretować następujące wspólne pola:

Kiedy używać pól specyficznych dla platformy

Użyj pól specyficznych dla platformy, jeśli chcesz:

  • Wysyłaj pola tylko do określonych platform
  • Wysyłaj pola specyficzne dla platformy oprócz pól wspólnych

Zawsze, gdy chcesz wysłać wartości tylko do określonych platform, nie używaj wspólnych pól; użyj pól specyficznych dla platformy. Na przykład, aby wysłać powiadomienie tylko do systemu iOS i sieci Web, ale nie do systemu Android, musisz użyć dwóch oddzielnych zestawów pól, jednego dla systemu iOS i jednego dla sieci Web.

Gdy wysyłasz wiadomości z określonymi opcjami dostarczania , użyj pól właściwych dla platformy, aby je ustawić. Jeśli chcesz, możesz określić różne wartości dla każdej platformy. Jednak nawet jeśli chcesz ustawić zasadniczo tę samą wartość na różnych platformach, musisz użyć pól specyficznych dla platformy. Dzieje się tak, ponieważ każda platforma może nieco inaczej interpretować wartość — na przykład czas wygaśnięcia jest ustawiony w systemie Android jako czas wygaśnięcia w sekundach, a w systemie iOS jako data wygaśnięcia .

Przykład: powiadomienie z opcjami kolorów i ikon

To przykładowe żądanie wysyłania wysyła wspólny tytuł powiadomienia i zawartość do wszystkich platform, ale wysyła również pewne zastąpienia specyficzne dla platformy na urządzenia z systemem Android.

W przypadku systemu Android żądanie ustawia specjalną ikonę i kolor, które będą wyświetlane na urządzeniach z systemem Android. Jak zauważono w odwołaniu do AndroidNotification , kolor jest określony w formacie #rrggbb, a obraz musi być zasobem ikony możliwym do narysowania lokalnie w aplikacji na Androida.

Oto przybliżenie efektu wizualnego na urządzeniu użytkownika:

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

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

Jawa

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

Pyton

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

Udać się

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

DO#

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

RESZTA

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 dokumentację referencyjną HTTP v1, aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach specyficznych dla platformy w treści wiadomości.

Przykład: powiadomienie z niestandardowym obrazem

Poniższy przykład send request wysyła wspólny tytuł powiadomienia do wszystkich platform, ale również wysyła obraz. Oto przybliżenie efektu wizualnego na urządzeniu użytkownika:

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

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

RESZTA

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 dokumentację referencyjną HTTP v1, aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach specyficznych dla platformy w treści wiadomości.

Przykład: wiadomość z powiadomieniem z powiązanym działaniem kliknięcia

Poniższy przykład wysyłania żądania wysyła wspólny tytuł powiadomienia do wszystkich platform, ale wysyła również akcję, którą aplikacja ma wykonać w odpowiedzi na interakcję użytkownika z powiadomieniem. Oto przybliżenie efektu wizualnego na urządzeniu użytkownika:

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

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

RESZTA

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 dokumentację referencyjną HTTP v1, aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach specyficznych dla platformy w treści wiadomości.

Przykład: powiadomienie z opcjami lokalizacji

Poniższy przykład wysyłania żądania wysyła opcje lokalizacji dla klienta w celu wyświetlenia zlokalizowanych komunikatów. Oto przybliżenie efektu wizualnego na urządzeniu użytkownika:

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

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

RESZTA

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 dokumentację referencyjną HTTP v1, aby uzyskać szczegółowe informacje na temat kluczy dostępnych w blokach specyficznych dla platformy w treści wiadomości.

Kody błędów administratora

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

Kod błędu Opis i kroki rozwiązania
messaging/invalid-argument Do metody FCM dostarczono nieprawidłowy argument. Komunikat o błędzie powinien zawierać dodatkowe informacje.
messaging/invalid-recipient Zamierzony odbiorca wiadomości jest nieprawidłowy. Komunikat o błędzie powinien zawierać dodatkowe informacje.
messaging/invalid-payload Podano nieprawidłowy obiekt ładunku komunikatu. Komunikat o błędzie powinien zawierać dodatkowe informacje.
messaging/invalid-data-payload-key Ładunek wiadomości danych zawiera nieprawidłowy klucz. Zobacz dokumentację referencyjną dla DataMessagePayload dla kluczy z ograniczeniami.
messaging/payload-size-limit-exceeded Dostarczony ładunek komunikatu przekracza limity rozmiaru FCM. Limit dla większości wiadomości wynosi 4096 bajtów. W przypadku wiadomości wysyłanych do tematów limit wynosi 2048 bajtów. Całkowity 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 zawierać dodatkowe informacje.
messaging/invalid-registration-token Podano nieprawidłowy token rejestracji. Upewnij się, że jest zgodny z tokenem rejestracji otrzymanym przez aplikację kliencką podczas rejestracji w FCM. Nie skracaj ani nie dodawaj do niego dodatkowych znaków.
messaging/registration-token-not-registered Podany token rejestracji nie jest zarejestrowany. Wcześniej ważny 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ę lub, w systemie iOS, jeśli usługa opinii APNs zgłosiła token APNs jako nieprawidłowy.
  • Token rejestracji wygasł. Na przykład Google może zdecydować o odświeżeniu tokenów rejestracji lub token APNs mógł wygasnąć dla urządzeń z systemem iOS.
  • Aplikacja kliencka została zaktualizowana, ale nowa wersja nie jest skonfigurowana do odbierania komunikatów.
We wszystkich tych przypadkach usuń ten token rejestracji i przestań go używać do wysyłania wiadomości.
messaging/invalid-package-name Wiadomość została skierowana do tokena rejestracji którego pakiet nazwa nie pasuje do dostarczonego restrictedPackageName opcję.
messaging/message-rate-exceeded Wskaźnik wiadomości do określonego celu jest zbyt wysoki. Zmniejsz liczbę wiadomości wysyłanych do tego urządzenia lub tematu i nie próbuj od razu ponawiać wysyłania do tego celu.
messaging/device-message-rate-exceeded Szybkość wysyłania wiadomości do konkretnego urządzenia jest zbyt wysoka. Zmniejsz liczbę wiadomości wysyłanych na to urządzenie i nie próbuj od razu ponawiać wysyłania na to urządzenie.
messaging/topics-message-rate-exceeded Wskaźnik wiadomości do subskrybentów określonego tematu jest zbyt wysoki. Zmniejsz liczbę wiadomości wysyłanych w tym temacie i nie próbuj od razu ponawiać wysyłania do tego tematu.
messaging/too-many-topics Token rejestracji został zasubskrybowany do maksymalnej liczby tematów i nie można go już subskrybować.
messaging/invalid-apns-credentials Nie można wysłać wiadomości skierowanej do urządzenia z systemem iOS, ponieważ wymagany certyfikat SSL APNs nie został przesłany lub wygasł. Sprawdź ważność swoich certyfikatów rozwoju i produkcji.
messaging/mismatched-credential Poświadczenie używane do uwierzytelniania tego zestawu SDK nie ma uprawnień do wysyłania komunikatów do urządzenia odpowiadającego podanemu tokenowi rejestracji. Upewnij się, że poświadczenia i token rejestracji należą do tego samego projektu Firebase. Zobacz Dodawanie Firebase do swojej aplikacji, aby uzyskać dokumentację dotyczącą uwierzytelniania pakietów Firebase Admin SDK.
messaging/authentication-error Zestaw SDK nie mógł uwierzytelnić się na serwerach FCM. Upewnij się, że uwierzytelniasz pakiet Firebase Admin SDK za pomocą poświadczeń, które mają odpowiednie uprawnienia do wysyłania wiadomości FCM. Zobacz Dodawanie Firebase do swojej aplikacji, aby uzyskać dokumentację dotyczącą uwierzytelniania pakietów Firebase Admin SDK.
messaging/server-unavailable Serwer FCM nie mógł przetworzyć żądania na czas. Powinieneś ponowić to samo żądanie, ale musisz:
  • Uwzględnij nagłówek Retry-After jeśli znajduje się on w odpowiedzi z serwera połączeń FCM.
  • Zaimplementuj wykładnicze wycofywanie w mechanizmie ponawiania prób. Na przykład, jeśli czekałeś jedną sekundę przed pierwszą próbą, odczekaj co najmniej dwie sekundy przed następną, potem cztery sekundy i tak dalej. Jeśli wysyłasz wiele wiadomości, opóźnij każdą z nich niezależnie o dodatkową losową wartość, aby uniknąć wysyłania nowego żądania dla wszystkich wiadomości jednocześnie.
Nadawcy, którzy powodują problemy, mogą zostać wciągnięci na czarną listę.
messaging/internal-error Serwer FCM napotkał błąd podczas próby przetworzenia żądania. Możesz ponowić to samo żądanie zgodnie z wymaganiami wymienionymi w powyższym wierszu messaging/server-unavailable . Jeżeli nadal występuje błąd, zgłoś problem do naszego zgłoszenia kanału nośnej.
messaging/unknown-error Zwrócono nieznany błąd serwera. Zobacz nieprzetworzoną odpowiedź serwera w komunikacie o błędzie, aby uzyskać więcej informacji. Jeśli pojawi się ten błąd, zgłoś pełny komunikat o błędzie do naszego zgłoszenia kanału nośnej.

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

Jeśli wolisz używać starszych protokołów, utwórz żądania wiadomości, jak pokazano w tej sekcji. Pamiętaj, że jeśli wysyłasz do wielu platform przez HTTP, protokół v1 może uprościć żądania wiadomości.

Wysyłaj wiadomości do określonych urządzeń

Wysyłanie wiadomości do konkretnych urządzeń, ustawić to kluczu do rejestracji token instancji konkretnej aplikacji. Zobacz informacje o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej 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" }
  ]
}

Wiadomość 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łączeń XMPP udostępnia kilka innych opcji odpowiedzi. Zobacz Format odpowiedzi serwera .

Aby uzyskać pełną listę opcji komunikatów dostępnych podczas wysyłania komunikatów podrzędnych do aplikacji klienckich, zobacz informacje referencyjne dotyczące wybranego protokołu serwera połączeń HTTP lub XMPP .

Wysyłaj wiadomości do tematów

Wysyłanie wiadomości do tematu Firebase Cloud Messaging jest bardzo podobne do wysyłania wiadomości na pojedyncze urządzenie lub do grupy użytkowników. Zestawy serwera aplikacji to to klucza o wartości podobnego /topics/yourTopic . Deweloperzy mogą wybrać dowolną nazwę tematu pasującą do wyrażenia regularnego: "/topics/[a-zA-Z0-9-_.~%]+" .

Aby wysłać do kombinacji wielu tematów, serwer aplikacji musi ustawić condition klawisza (zamiast to klucz) do logicznego stanu, który określa tematów docelowe. Na przykład, aby wysyłać wiadomości do urządzeń, które zasubskrybowały TopicA i TopicB lub TopicC :

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

FCM najpierw ocenia wszystkie warunki w nawiasach, a następnie ocenia wyrażenie od lewej do prawej. W powyższym wyrażeniu użytkownik zasubskrybowany do dowolnego pojedynczego tematu nie otrzymuje wiadomości. Podobnie użytkownik, który nie subskrybuje TopicA, nie otrzymuje wiadomości. Te kombinacje otrzymują to:

  • Temat A i Temat B
  • Temat A i Temat C

W wyrażeniu warunkowym można umieścić maksymalnie pięć tematów, a obsługiwane są nawiasy. Obsługiwane operatory: && , || .

Aby uzyskać więcej informacji na temat kluczy serwera aplikacji, zobacz informacje referencyjne dotyczące wybranego protokołu serwera połączeń HTTP lub XMPP . Przykłady na tej stronie pokazują, jak wysyłać wiadomości do tematów w HTTP i XMPP.

Temat żądanie HTTP POST

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 zasubskrybowane w tematach „psy” lub „koty”:

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


Temat odpowiedzi HTTP

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

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

Temat wiadomości XMPP

Wyślij do jednego tematu:

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


  </gcm>
</message>

Wysyłaj na urządzenia zasubskrybowane w tematach „psy” lub „koty”:

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


  </gcm>
</message>

Odpowiedź XMPP na temat

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

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

Oczekuj do 30 sekund opóźnienia, zanim FCM Server zwróci odpowiedź o powodzeniu lub niepowodzeniu na żądania wysłania tematu. Pamiętaj, aby odpowiednio ustawić wartość limitu czasu serwera aplikacji w żądaniu.

Aby uzyskać pełną listę opcji wiadomości, zobacz informacje referencyjne dotyczące wybranego protokołu serwera połączeń HTTP lub XMPP .

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

Wysyłanie wiadomości do grupy urządzeń jest bardzo podobne do wysyłania wiadomości do pojedynczego urządzenia. Ustaw to parametru do unikalnego klucza powiadomień dla grupy urządzeń. Zobacz Typy wiadomości, aby uzyskać szczegółowe informacje na temat obsługi ładunku. Przykłady na tej stronie pokazują, jak wysyłać wiadomości z danymi do grup urządzeń w protokołach HTTP i XMPP.

Żądanie POST HTTP 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 z nim 2 tokeny rejestracji i wiadomość została pomyślnie wysłana do obu z nich:

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

Oto przykład „częściowego sukcesu” — notification_key ma powiązane z nim 3 tokeny rejestracji. Wiadomość została pomyślnie wysłana tylko do 1 z tokenów rejestracji. Wykazy wiadomość odpowiedź tokenów rejestracyjne ( registration_ids ), które nie otrzymały wiadomość:

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

Gdy komunikat nie zostanie dostarczony do co najmniej jednego tokenu rejestracji skojarzonego z notification_key , serwer aplikacji powinien ponowić próbę z wycofywaniem się między ponownymi próbami.

Jeśli serwer próbuje wysłać wiadomość do grupy urządzeń, która nie ma członków, odpowiedź wygląda następująco, z 0 sukcesami i 0 niepowodzeniem:

04e553750

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 pomyślnie wysłana do dowolnego urządzenia w grupie, serwer połączeń XMPP odpowiada ACK. Jeśli wszystkie wiadomości wysłane do wszystkich urządzeń w grupie zawiodą, serwer połączeń XMPP odpowiada NACK.

Oto przykład „sukcesu” — notification_key ma powiązane z nim 3 tokeny rejestracyjne, a wiadomość została pomyślnie wysłana do wszystkich z nich:

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

Oto przykład „częściowego sukcesu” — notification_key ma powiązane z nim 3 tokeny rejestracji. Wiadomość została pomyślnie wysłana tylko do jednego z tokenów rejestracji. Komunikat odpowiedzi zawiera listę tokenów rejestracji, które nie otrzymały 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ć do wszystkich urządzeń w grupie. Serwer aplikacji otrzyma odpowiedź nack.

Aby uzyskać pełną listę opcji wiadomości, zobacz informacje referencyjne dotyczące wybranego protokołu serwera połączeń HTTP lub XMPP .

Starsze metody wysyłania pakietu Firebase Admin SDK

Pakiet Firebase Admin SDK Node.js obsługuje metody wysyłania wiadomości (FCM) na podstawie interfejsu API starszego serwera FCM . Metody te akceptują inne argumenty w porównaniu do metody send() . W miarę możliwości należy używać metody send() i używać tylko metod opisanych na tej stronie podczas wysyłania komunikatów do poszczególnych urządzeń lub grup urządzeń.

Wyślij do poszczególnych urządzeń

Możesz przekazać token rejestracji do metody sendToDevice() , aby wysłać wiadomość do tego urządzenia:

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.
admin.messaging().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 również wysyłać komunikat multiemisji (czyli komunikat do wielu urządzeń), przekazując tablicę tokenów rejestracji zamiast 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.
admin.messaging().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ę, która jest rozwiązana za pomocą obiektu MessagingDevicesResponse zawierającego odpowiedź z FCM. Zwracany typ ma ten sam format podczas przekazywania pojedynczego tokenu rejestracji lub tablicy tokenów rejestracji.

Niektóre przypadki, takie jak błąd uwierzytelniania lub ograniczenie szybkości, powodują niepowodzenie przetwarzania całej wiadomości. W takich przypadkach obietnica zwrócona przez sendToDevice() jest odrzucana z błędem. Aby uzyskać pełną listę kodów błędów, w tym opisy i kroki rozwiązywania, zobacz Admin FCM API Errors .

Wyślij do grupy urządzeń

Wiadomości grupowe urządzeń umożliwiają dodawanie wielu urządzeń do jednej grupy. Jest to podobne do przesyłania wiadomości tematowych, ale obejmuje uwierzytelnianie, aby zapewnić, że członkostwo w grupie jest zarządzane tylko przez serwery. Na przykład, jeśli chcesz wysłać różne wiadomości do różnych modeli telefonów, twoje serwery mogą dodawać/usuwać rejestracje do odpowiednich grup i wysyłać odpowiednią wiadomość do każdej grupy. Komunikaty grup urządzeń różnią się od komunikatów tematów tym, że polegają na zarządzaniu grupami urządzeń z serwerów, a nie bezpośrednio w aplikacji.

Możesz używać wiadomości grupowych urządzeń za pośrednictwem starszych protokołów XMPP lub HTTP na serwerze aplikacji. Pakiet Firebase Admin SDK dla Node.js oparty na starszych protokołach zapewnia również funkcje przesyłania wiadomości w grupach urządzeń. Maksymalna liczba członków dozwolonych dla klucza powiadomienia to 20.

Możesz tworzyć grupy urządzeń i generować klucze powiadomień za pośrednictwem serwera aplikacji lub klienta Android. Zobacz Zarządzanie grupami urządzeń, aby uzyskać szczegółowe informacje.

Metoda sendToDeviceGroup() umożliwia wysyłanie wiadomości do grupy urządzeń poprzez określenie klucza powiadomienia 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.
admin.messaging().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ę, która jest rozwiązana za pomocą obiektu MessagingDeviceGroupResponse zawierającego odpowiedź z FCM.

Niektóre przypadki, takie jak błąd uwierzytelniania lub ograniczenie szybkości, powodują niepowodzenie przetwarzania całej wiadomości. W takich przypadkach obietnica zwrócona przez sendToDeviceGroup() jest odrzucana z błędem. Aby uzyskać pełną listę kodów błędów, w tym opisy i kroki rozwiązywania, zobacz Admin FCM API Errors .

Definiowanie ładunku wiadomości

Powyższe metody oparte na starszych protokołach FCM akceptują ładunek wiadomości jako drugi argument i obsługują zarówno powiadomienia, jak i wiadomości z danymi . Możesz określić jeden lub oba typy wiadomości, tworząc obiekt z kluczami data i/lub notification . Na przykład, oto jak zdefiniować różne typy ładunków wiadomości:

Wiadomość z powiadomieniem

0783ffff580

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 powiadomień mają wstępnie zdefiniowany podzbiór prawidłowych właściwości i różnią się nieznacznie w zależności od docelowego mobilnego systemu operacyjnego. Pełna lista znajduje się w dokumentacji referencyjnej NotificationMessagePayload .

Ładunki komunikatów danych składają się z niestandardowych par klucz-wartość z kilkoma ograniczeniami, w tym faktem, że wszystkie wartości muszą być ciągami. Pełna lista ograniczeń znajduje się w dokumentacji referencyjnej DataMessagePayload .

Definiowanie opcji wiadomości

Powyższe metody oparte na starszych protokołach FCM akceptują opcjonalny trzeci argument określający niektóre opcje komunikatu. Na przykład poniższy przykład wysyła wiadomość o wysokim priorytecie do urządzenia, która 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.
admin.messaging().sendToDevice(registrationToken, payload, options)
  .then((response) => {
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Zobacz dokumentację referencyjną MessagingOptions aby uzyskać pełną listę dostępnych opcji.