Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Zbuduj serwer aplikacji wysyłaj żądania

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Korzystając z protokołów 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
  • Token rejestracji urządzenia
  • Nazwa grupy urządzeń (starsze protokoły i Firebase Admin SDK tylko dla Node.js)

Możesz wysyłać wiadomości z ładunkiem powiadomienia składającym się z predefiniowanych pól, ładunkiem danych złożonym z własnych pól zdefiniowanych przez użytkownika lub komunikatem zawierającym oba typy ładunków. 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 (obsługującego Node , Java , Python , C# i Go ) oraz protokołu HTTP w wersji 1 . Istnieją również wskazówki dotyczące wysyłania wiadomości za pośrednictwem starszych protokołów HTTP i XMPP .

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

Aby wysłać do jednego, określonego urządzenia, przekaż token rejestracji urządzenia, jak pokazano. Zapoznaj się z informacjami o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej o tokenach rejestracyjnych.

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

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)

Iść

// Obtain a messaging.Client from the App.
ctx := context.Background()
client, err := app.Messaging(ctx)
if err != nil {
	log.Fatalf("error getting Messaging client: %v\n", err)
}

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

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Token: registrationToken,
}

// Send a message to the device corresponding to the provided
// registration token.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

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

// See documentation on defining a message payload.
var message = new Message()
{
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
    Token = registrationToken,
};

// Send a message to the device corresponding to the provided
// registration token.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

ODPOCZYNEK

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

W przypadku powodzenia każda metoda wysyłania 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 interfejsy API Admin FCM umożliwiają multiemisję wiadomości do listy tokenów rejestracji urządzeń. Możesz określić do 500 tokenów rejestracji urządzeń 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');
  });

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

Iść

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

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

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

C#

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

var response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(message);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

ODPOCZYNEK

Skonstruuj żądanie wsadowe HTTP:

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary

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

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 wsad_request.txt). Następnie użyj polecenia cURL:

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

W przypadku zestawów SDK Firebase Admin ta operacja wykorzystuje ukryty interfejs API sendAll() , jak pokazano w przykładach. Zwracana wartość 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,
};

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

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

Iść

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

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

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

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

C#

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

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

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

ODPOCZYNEK

Każde wysyłanie sub-wysyłania 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 przez zasubskrybowanie instancji aplikacji klienckiej do tematu po stronie klienta lub za pośrednictwem interfejsu API serwera można wysyłać wiadomości do tematu. Jeśli tworzysz żądania wysyłania dla FCM po raz pierwszy, zapoznaj się z przewodnikiem po środowisku serwera i FCM, aby uzyskać ważne informacje ogólne i konfiguracyjne.

W logice wysyłania na zapleczu podaj żą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.
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);
  });

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)

Iść

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

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Topic: topic,
}

// Send a message to the devices subscribed to the provided topic.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

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

// See documentation on defining a message payload.
var message = new Message()
{
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
    Topic = topic,
};

// Send a message to the devices subscribed to the provided topic.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

ODPOCZYNEK

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 , który jest wyrażeniem boolowskim określającym tematy docelowe. Na przykład następujący warunek spowoduje wysłanie wiadomości do urządzeń, które subskrybują 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 go otrzymują:

  • TopicA i TopicB
  • TopicA i TopicC

W wyrażeniu warunkowym można uwzględnić maksymalnie pięć 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);
  });

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)

Iść

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

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Condition: condition,
}

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

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

// See documentation on defining a message payload.
var message = new Message()
{
    Notification = new Notification()
    {
        Title = "$GOOG up 1.43% on the day",
        Body = "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.",
    },
    Condition = condition,
};

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

ODPOCZYNEK

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

Wyślij partię wiadomości

Interfejs 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 API, co znacznie poprawi wydajność w porównaniu z wysyłaniem oddzielnych żądań HTTP dla każdej wiadomości.

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

getMessaging().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))

Iść

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

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

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

C#

// Create a list containing up to 500 messages.
var messages = new List<Message>()
{
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "5% off all electronics",
        },
        Token = registrationToken,
    },
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "2% off all books",
        },
        Topic = "readers-club",
    },
};

var response = await FirebaseMessaging.DefaultInstance.SendAllAsync(messages);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

ODPOCZYNEK

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

--subrequest_boundary
Content-Type: application/http
Content-Transfer-Encoding: binary

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

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

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 wysłać zapytanie do zwróconego BatchResponse , aby sprawdzić, ile komunikatów zostało pomyślnie przekazanych do FCM. Udostępnia również listę odpowiedzi, które można wykorzystać do sprawdzenia stanu poszczególnych wiadomości. Kolejność odpowiedzi odpowiada kolejności komunikatów na liście wejściowej.

Wysyłaj wiadomości umożliwiające bezpośrednie uruchamianie (tylko Android)

Możesz wysyłać wiadomości do urządzeń w trybie rozruchu bezpośredniego, używając HTTP v1 lub starszych interfejsów API 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 HTTP FCM v1

Żądanie komunikatu musi zawierać klucz "direct_boot_ok" : true w opcjach AndroidConfig 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,
    },
}

Wysyłaj 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 aktualnie w trybie rozruchu bezpośredniego (a także poza tym trybem).

Dostosuj wiadomości na różnych platformach

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

  • wspólny zestaw pól do interpretacji przez wszystkie instancje aplikacji, które odbierają komunikat.
  • zestawy pól specyficzne dla platformy, takie jak AndroidConfig i WebpushConfig , interpretowane tylko przez wystąpienia aplikacji działające na określonej platformie.

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

Kiedy używać wspólnych pól

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

  • Kierowanie na wystąpienia aplikacji na wszystkich platformach — Apple, Android i w internecie
  • 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 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 wspólnych pól

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 platform i sieci Apple, ale nie do Androida, musisz użyć dwóch oddzielnych zestawów pól, jednego dla Apple i jednego dla Internetu.

Gdy wysyłasz wiadomości z określonymi opcjami dostarczania , użyj pól specyficznych 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. Wynika to z faktu, że każda platforma może nieco inaczej interpretować tę wartość — na przykład czas życia jest ustawiany w systemie Android jako czas wygaśnięcia w sekundach, podczas gdy w systemie Apple jest ustawiany jako data wygaśnięcia.

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

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

W przypadku Androida żądanie ustawia specjalną ikonę i kolor do wyświetlenia na urządzeniach z Androidem. Jak zauważono w odwołaniu do AndroidNotification , kolor jest określony w formacie #rrggbb, a obraz musi być lokalnym zasobem ikony do rysowania dla aplikacji systemu Android.

Oto przybliżony efekt wizualny na urządzeniu użytkownika:

Prosty rysunek dwóch urządzeń, z których jedno wyświetla niestandardową 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);
  });

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

Iść

oneHour := time.Duration(1) * time.Hour
badge := 42
message := &messaging.Message{
	Notification: &messaging.Notification{
		Title: "$GOOG up 1.43% on the day",
		Body:  "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.",
	},
	Android: &messaging.AndroidConfig{
		TTL: &oneHour,
		Notification: &messaging.AndroidNotification{
			Icon:  "stock_ticker_update",
			Color: "#f45342",
		},
	},
	APNS: &messaging.APNSConfig{
		Payload: &messaging.APNSPayload{
			Aps: &messaging.Aps{
				Badge: &badge,
			},
		},
	},
	Topic: "industry-tech",
}

C#

var message = new Message
{
    Notification = new Notification()
    {
        Title = "$GOOG up 1.43% on the day",
        Body = "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.",
    },
    Android = new AndroidConfig()
    {
        TimeToLive = TimeSpan.FromHours(1),
        Notification = new AndroidNotification()
        {
            Icon = "stock_ticker_update",
            Color = "#f45342",
        },
    },
    Apns = new ApnsConfig()
    {
        Aps = new Aps()
        {
            Badge = 42,
        },
    },
    Topic = "industry-tech",
};

ODPOCZYNEK

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

Zapoznaj się z 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ższe przykładowe żądanie wysłania wysyła wspólny tytuł powiadomienia do wszystkich platform, ale wysyła również obraz. Oto przybliżony efekt wizualny na urządzeniu użytkownika:

Prosty rysunek obrazu w powiadomieniu na wyświetlaczu

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

ODPOCZYNEK

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

Zapoznaj się z 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 powiązaną akcją kliknięcia

Poniższe przykładowe żądanie wysłania wysyła wspólny tytuł powiadomienia do wszystkich platform, ale także wysyła akcję do wykonania przez aplikację w odpowiedzi na interakcję użytkownika z powiadomieniem. Oto przybliżony efekt wizualny na urządzeniu użytkownika:

Prosty rysunek użytkownika, który otwiera 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);
  });

ODPOCZYNEK

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

Zapoznaj się z 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ższe przykładowe żądanie wysłania wysyła opcje lokalizacji dla klienta w celu wyświetlenia zlokalizowanych komunikatów. Oto przybliżony efekt wizualny na urządzeniu użytkownika:

Prosty rysunek przedstawiający dwa urządzenia wyświetlające 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);
  });

ODPOCZYNEK

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

Zapoznaj się z 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 i ich opisy, w tym zalecane kroki rozwiązania.

Kod błędu Opis i kroki rozwiązania
messaging/invalid-argument Do metody FCM podano 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 komunikatu danych zawiera nieprawidłowy klucz. Zapoznaj się z dokumentacją referencyjną dla DataMessagePayload dla kluczy z ograniczeniami.
messaging/payload-size-limit-exceeded Podany ładunek komunikatu przekracza limity rozmiaru FCM. Limit dla większości komunikatów 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, który aplikacja kliencka otrzymuje po zarejestrowaniu w FCM. Nie obcinaj go ani nie dodawaj do niego dodatkowych znaków.
messaging/registration-token-not-registered Podany token rejestracji nie jest zarejestrowany. Wcześniej ważny token rejestracyjny 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ę to zdarzyć, jeśli użytkownik odinstaluje aplikację lub, na platformach Apple, jeśli usługa opinii APNs zgłosi token APNs jako nieprawidłowy.
  • Token rejestracji wygasł. Na przykład Google może podjąć decyzję o odświeżeniu tokenów rejestracji lub token APNs może wygasnąć dla urządzeń Apple.
  • Aplikacja kliencka została zaktualizowana, ale nowa wersja nie jest skonfigurowana do odbierania wiadomości.
We wszystkich tych przypadkach usuń ten token rejestracji i przestań używać go do wysyłania wiadomości.
messaging/invalid-package-name Wiadomość została zaadresowana do tokenu rejestracji, którego nazwa pakietu nie jest zgodna z podaną opcją restrictedPackageName .
messaging/message-rate-exceeded Częstotliwość wiadomości do określonego celu jest zbyt wysoka. Zmniejsz liczbę wiadomości wysyłanych do tego urządzenia lub tematu i nie próbuj od razu wysyłać do tego celu.
messaging/device-message-rate-exceeded Szybkość wiadomości do określonego urządzenia jest zbyt wysoka. Zmniejsz liczbę wiadomości wysyłanych na to urządzenie i nie próbuj od razu wysyłać na to urządzenie.
messaging/topics-message-rate-exceeded Wskaźnik wiadomości do subskrybentów na określony temat jest zbyt wysoki. Zmniejsz liczbę wiadomości wysyłanych w tym temacie i nie próbuj natychmiast ponownie wysyłać do tego tematu.
messaging/too-many-topics Token rejestracji został zasubskrybowany dla maksymalnej liczby tematów i nie można go już subskrybować.
messaging/invalid-apns-credentials Wiadomość skierowana do urządzenia Apple nie mogła zostać wysłana, ponieważ wymagany certyfikat SSL APNs nie został przesłany lub wygasł. Sprawdź ważność swoich certyfikatów rozwojowych i produkcyjnych.
messaging/mismatched-credential Poświadczenie użyte do uwierzytelnienia tego zestawu SDK nie ma uprawnień do wysyłania wiadomości do urządzenia odpowiadającego podanemu tokenowi rejestracji. Upewnij się, że poświadczenie 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 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ć tę samą prośbę, ale musisz:
  • Szanuj nagłówek Retry-After , jeśli jest zawarty w odpowiedzi z serwera połączeń FCM.
  • Zaimplementuj wykładnicze wycofywanie w mechanizmie ponawiania. Na przykład, jeśli odczekałeś jedną sekundę przed pierwszą ponowną próbą, poczekaj 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 w tym samym czasie.
Nadawcom, którzy powodują problemy, grozi umieszczenie na czarnej liście.
messaging/internal-error Serwer FCM napotkał błąd podczas próby przetworzenia żądania. Możesz spróbować ponownie wykonać to samo żądanie, spełniając wymagania wymienione w powyższym wierszu messaging/server-unavailable . Jeśli błąd będzie się powtarzał, zgłoś problem do naszego kanału wsparcia zgłaszania błędów.
messaging/unknown-error Zwrócono nieznany błąd serwera. Zobacz surową 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 kanału wsparcia zgłaszania błędów.

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

Jeśli wolisz używać starszych protokołów, utwórz żądania komunikatów, 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ń

Aby wysyłać wiadomości do określonych urządzeń, ustaw klucz to tokenu rejestracji dla określonej instancji aplikacji. Zapoznaj się z informacjami o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej o tokenach rejestracyjnych.

Żą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 zapewnia kilka innych opcji odpowiedzi. Zobacz Format odpowiedzi serwera .

Aby zapoznać się z pełną listą opcji komunikatów dostępnych podczas wysyłania komunikatów podrzędnych do aplikacji klienckich, zapoznaj się z informacjami referencyjnymi dotyczącymi 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 do pojedynczego urządzenia lub grupy użytkowników. Serwer aplikacji ustawia klucz to z wartością taką jak /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ć klucz condition (zamiast klucza to ) na warunek logiczny, który określa tematy docelowe. Na przykład, aby wysłać wiadomości do urządzeń, które subskrybował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 go otrzymują:

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

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

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 z subskrybowanymi tematami „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 z subskrybowanymi tematami „psy” lub „koty”:

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


  </gcm>
</message>

Temat odpowiedzi XMPP

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

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

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

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 parametr to na unikatowy klucz powiadomienia dla grupy urządzeń. Zobacz Typy komunikatów, aby uzyskać szczegółowe informacje na temat obsługi ładunku. Przykłady na tej stronie pokazują, jak wysyłać komunikaty danych 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 skojarzone z nim 2 tokeny rejestracji, a wiadomość została pomyślnie wysłana do obu z nich:

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

Oto przykład „częściowego sukcesu” — z notification_key są powiązane 3 tokeny rejestracji. Wiadomość została pomyślnie wysłana tylko do 1 z tokenów rejestracji. Komunikat odpowiedzi zawiera listę tokenów registration_ids ( identyfikatory_rejestracji ), które nie odebrały komunikatu:

{
  "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 między kolejnymi próbami.

Jeśli serwer spróbuje wysłać wiadomość do grupy urządzeń, która nie ma członków, odpowiedź wygląda następująco: 0 sukcesó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 pomyślnie wysłana do dowolnego urządzenia w grupie, serwer połączeń XMPP odpowiada potwierdzeniem. Jeśli wszystkie wiadomości wysłane do wszystkich urządzeń w grupie zakończą się niepowodzeniem, serwer połączeń XMPP odpowie NACK.

Oto przykład „sukcesu” — notification_key ma skojarzone z nim 3 tokeny rejestracji, 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” — z notification_key są powiązane 3 tokeny rejestracji. Wiadomość została pomyślnie wysłana tylko do 1 z tokenów rejestracji. Komunikat odpowiedzi zawiera listę tokenów rejestracji, które nie odebrały komunikatu:

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

Gdy serwer połączenia FCM nie dostarcza do wszystkich urządzeń w grupie. Serwer aplikacji otrzyma odpowiedź nack.

Pełną listę opcji wiadomości można znaleźć w informacjach referencyjnych dotyczących wybranego protokołu serwera połączeń, HTTP lub XMPP .

Starsze metody wysyłania Firebase Admin SDK

Pakiet Firebase Admin Node.js SDK obsługuje metody wysyłania wiadomości (FCM) w oparciu o interfejs API starszego serwera FCM . Metody te akceptują inne argumenty niż metoda send() . W miarę możliwości należy używać metody send() i używać tylko metod opisanych na tej stronie podczas wysyłania wiadomości 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.
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 również wysłać wiadomość multiemisji (czyli wiadomość do wielu urządzeń), przekazując tablicę tokenów rejestracji zamiast tylko jednego 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ę, która jest rozwiązywana 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 przetworzenia 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 problemów, zobacz Błędy interfejsu API Admin FCM .

Wyślij do grupy urządzeń

Wiadomości grupowe urządzeń umożliwiają dodanie wielu urządzeń do jednej grupy. Jest to podobne do wysyłania wiadomości w temacie, ale obejmuje uwierzytelnianie, aby upewnić się, że członkostwo w grupie jest zarządzane tylko przez twoje serwery. Na przykład, jeśli chcesz wysył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. Przesyłanie komunikatów grup urządzeń różni się od przesyłania komunikatów tematycznych tym, że obejmuje zarządzanie grupami urządzeń z serwerów, a nie bezpośrednio w aplikacji.

Możesz używać komunikatów grup urządzeń za pośrednictwem starszych protokołów XMPP lub HTTP na swoim serwerze aplikacji. Starsze wersje Firebase Admin SDK dla Node.js są oparte na starszych protokołach i zapewniają również możliwości przesyłania wiadomości w grupach urządzeń. Maksymalna dozwolona liczba członków dla klucza powiadomień to 20.

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

Metoda sendToDeviceGroup() umożliwia wysł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.
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ę, która jest rozstrzygana za pomocą obiektu MessagingDevicesResponse zawierającego odpowiedź z FCM.

Niektóre przypadki, takie jak błąd uwierzytelniania lub ograniczenie szybkości, powodują niepowodzenie przetworzenia 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 problemów, zobacz Błędy interfejsu API Admin FCM .

Definiowanie ładunku wiadomości

Powyższe metody oparte na starszych protokołach FCM akceptują ładunek komunikatu jako drugi argument i obsługują zarówno powiadomienia, jak i komunikaty 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 komunikatów:

Wiadomość powiadomienia

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ść danych

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

Wiadomość połączona

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ą predefiniowany podzbiór prawidłowych właściwości i różnią się nieznacznie w zależności od docelowego mobilnego systemu operacyjnego. Zobacz dokumentację referencyjną dla NotificationMessagePayload , aby uzyskać pełną listę.

Ł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. Zobacz dokumentację referencyjną dotyczącą DataMessagePayload , aby zapoznać się z pełną listą ograniczeń.

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órego ważność 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);
  });

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