Google is committed to advancing racial equity for Black communities. See how.
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Zbuduj serwer aplikacji wysyłający żądania

Korzystając z Firebase Admin SDK lub protokołów serwera aplikacji FCM, możesz tworzyć żądania wiadomości i wysyłać je do następujących typów obiektów docelowych:

  • 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 składającym się ze wstępnie zdefiniowanych pól, ładunkiem danych z własnych pól zdefiniowanych przez użytkownika lub wiadomością zawierającą oba typy ładunku. Aby uzyskać więcej informacji, zobacz Typy wiadomości .

Przykłady na tej stronie pokazują, jak wysyłać wiadomości z powiadomieniami 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 za pośrednictwem starszych protokołów HTTP i XMPP .

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

Aby wysłać na jedno, określone urządzenie, 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.
var registrationToken = 'YOUR_REGISTRATION_TOKEN';

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

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

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

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

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 wysyłania zwraca identyfikator wiadomości. Pakiet Firebase Admin SDK zwraca ciąg identyfikatora w formacie projects/{project_id}/messages/{message_id} identyfikator_projektu 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 na wiele urządzeń

REST API i Admin FCM API umożliwiają multiemisję wiadomości na listę tokenów rejestracji urządzeń. Możesz określić do 100 tokenów rejestracji urządzenia (500 dla Java i Node.js) 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,
}

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

Jawa

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

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 sendAll() Admin SDK ta operacja używa interfejsu API sendAll() pod maską, jak pokazano w przykładach. Wartość zwracana to BatchResponse którego 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}");
}

ODPOCZYNEK

Każde wysyłanie podrzędne zwraca odpowiedź. Odpowiedzi są oddzielane ciągiem granicznym 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żna wysyłać komunikaty do tematu. Jeśli tworzysz żądania wysyłania FCM po raz pierwszy, zapoznaj się z przewodnikiem po środowisku serwera i FCM, aby uzyskać ważne informacje ogólne i dotyczące 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/".
var topic = 'highScores';

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

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

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

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

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 wiadomości do urządzeń zasubskrybowanych do TopicA i TopicB lub TopicC :

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

FCM najpierw oblicza warunki w nawiasach, a następnie oblicza wyrażenie od lewej do prawej. W powyższym wyrażeniu użytkownik subskrybujący dowolny pojedynczy temat nie otrzymuje wiadomości. Podobnie użytkownik, który nie subskrybuje TopicA , nie otrzymuje wiadomości. Otrzymują go te kombinacje:

  • TopicA i TopicB
  • TopicA i TopicC

W wyrażeniu warunkowym możesz uwzględnić maksymalnie pięć tematów.

Aby wysłać do stanu:

Node.js

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

// See documentation on defining a message payload.
var message = {
  notification: {
    title: '$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.
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(new Notification(
        "$GOOG up 1.43% on the day",
        "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day."))
    .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);

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

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 pakiet wiadomości

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

Ta funkcja może służyć do tworzenia niestandardowego zestawu wiadomości i wysyłania ich do różnych odbiorców, w tym 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(new Notification("Price drop", "5% off all electronics"))
        .setToken(registrationToken)
        .build(),
    // ...
    Message.builder()
        .setNotification(new Notification("Price drop", "2% off all books"))
        .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 100 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

Utwórz żą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 zapytać o zwróconą odpowiedź 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ść.

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

Możesz wysyłać wiadomości do urządzeń w trybie rozruchu bezpośredniego, korzystając z HTTP v1 lub starszych interfejsów API HTTP. Przed wysłaniem do urządzeń w trybie rozruchu bezpośredniego upewnij się, że wykonano kroki umożliwiające urządzeniom klienckim odbieranie komunikatów FCM w trybie rozruchu bezpośredniego .

Wyślij za pomocą interfejsu API HTTP FCM v1

Żądanie wiadomości musi zawierać klucz "direct_book_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,
    },
}

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

Żądanie wiadomości musi zawierać klucz "direct_book_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_book_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

Zarówno Firebase Admin SDK, jak i protokół FCM v1 HTTP pozwalają żądaniom wiadomości ustawić wszystkie pola dostępne w obiekcie message . To zawiera:

  • wspólny zestaw pól, które mają być interpretowane przez wszystkie wystąpienia aplikacji, które otrzymują komunikat.
  • zestawy pól specyficzne dla platformy, takie jak AndroidConfig i WebpushConfig , interpretowane tylko przez wystąpienia aplikacji uruchomione na określonej platformie.

Bloki specyficzne dla platformy zapewniają elastyczność dostosowywania wiadomości do różnych platform, aby zapewnić ich poprawną 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żyj wspólnych pól, gdy:

  • Kierowanie na wystąpienia aplikacji na wszystkich platformach - iOS, Android i w sieci
  • Wysyłanie wiadomości do tematów

Wszystkie wystąpienia aplikacji, niezależnie od platformy, mogą interpretować następujące typowe 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

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

Jeśli 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. Dzieje się tak, ponieważ każda platforma może nieco inaczej interpretować tę wartość - na przykład czas wygaśnięcia jest ustawiany w systemie Android jako czas wygaśnięcia w sekundach, podczas gdy w iOS jest to data wygaśnięcia.

Przykład: powiadomienie z opcjami dostawy specyficznymi dla platformy

Następujące żą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. W szczególności żądanie:

  • Ustawia długi czas życia dla Androida wraz ze specjalną ikoną i kolorem do wyświetlania na urządzeniach z Androidem.
  • Ustawia pole badge tylko dla systemu iOS w ładunku APN w celu dostarczenia na urządzenia z systemem iOS.

Node.js

var message = {
  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: {
    ttl: 3600 * 1000,
    notification: {
      icon: 'stock_ticker_update',
      color: '#f45342',
    },
  },
  apns: {
    payload: {
      aps: {
        badge: 42,
      },
    },
  },
  topic: 'industry-tech'
};

Jawa

Message message = Message.builder()
    .setNotification(new Notification(
        "$GOOG up 1.43% on the day",
        "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day."))
    .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",
};

ODPOCZYNEK

{
  "message":{
     "topic":"industry-tech",
     "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":{
       "ttl":"3600s",
       "notification":{
         "icon":"stock_ticker_update",
         "color":"#f45342"
       }
     },
     "apns":{
       "payload":{
         "aps":{
           "badge":"42"
         }
       }
     },
     "webpush":{
       "headers":{
         "TTL":"86400"
       }
     }
   }
 }

Szczegółowe informacje na temat kluczy dostępnych w blokach specyficznych dla platformy w treści wiadomości można znaleźć w dokumentacji referencyjnej protokołu HTTP v1 .

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 Podano nieprawidłowy argument do metody FCM. Komunikat o błędzie powinien zawierać dodatkowe informacje.
messaging/invalid-recipient Docelowy 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 z danymi zawiera nieprawidłowy klucz. Zobacz dokumentację referencyjną DataMessagePayload dla kluczy zastrzeżonych.
messaging/payload-size-limit-exceeded Podany ładunek wiadomości przekracza limity rozmiaru FCM. Limit wynosi 4096 bajtów dla większości wiadomości. W przypadku wiadomości wysł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 niepoprawny 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 klienta otrzymuje 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 rejestracyjny można wyrejestrować 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 APNS Feedback Service 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ąć na urządzeniach z iOS.
  • 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ń 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 natychmiast ponownie wysyłać ich do tego miejsca docelowego.
messaging/device-message-rate-exceeded Szybkość wysyłania 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 ponownie wysyłać ich 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 ponowić 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 kierowanej na urządzenie z iOS, ponieważ wymagany certyfikat APNs SSL nie został przesłany lub wygasł. Sprawdź ważność swoich certyfikatów rozwoju i produkcji.
messaging/mismatched-credential Dane uwierzytelniające używane do uwierzytelniania tego zestawu SDK nie mają uprawnień do wysyłania wiadomości do urządzenia odpowiadającego podanemu tokenowi rejestracji. Upewnij się, że dane logowania 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ą danych logowania, 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:
  • Retry-After nagłówka Retry-After jeśli jest dołączony do odpowiedzi z serwera połączeń FCM.
  • Zaimplementuj wykładnicze wycofywanie w mechanizmie ponawiania. Na przykład, jeśli czekałeś jedną sekundę przed pierwszą próbą, odczekaj co najmniej dwie sekundy przed następną, następnie 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ą znaleźć się na czarnej liście.
messaging/internal-error Serwer FCM napotkał błąd podczas próby przetworzenia żądania. Możesz ponowić to samo żądanie, postępując 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ócony został nieznany błąd serwera. Więcej informacji można znaleźć w nieprzetworzonej odpowiedzi serwera w komunikacie o błędzie. 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 wiadomości na wiele platform za pośrednictwem protokołu HTTP, protokół v1 może uprościć żądania wiadomości.

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

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 inne opcje odpowiedzi. Zobacz Format odpowiedzi serwera .

Aby zapoznać się z pełną listą opcji wiadomości dostępnych podczas wysyłania wiadomości 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 do grupy użytkowników. Zestawy serwera aplikacji to to klucza o wartości podobnego /topics/yourTopic . Programiści mogą wybrać dowolną nazwę tematu, która pasuje 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 oblicza warunki w nawiasach, a następnie oblicza wyrażenie od lewej do prawej. W powyższym wyrażeniu użytkownik subskrybujący dowolny pojedynczy temat nie otrzymuje wiadomości. Podobnie, użytkownik, który nie subskrybuje tematu TopicA, nie otrzymuje wiadomości. Otrzymują go te kombinacje:

  • TematA i TematB
  • TematA i TematC

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

!('TopicA' in topics)

Za pomocą tego wyrażenia wszystkie wystąpienia aplikacji, które nie są subskrybowane do tematu TopicA, w tym wystąpienia aplikacji, które nie są subskrybowane do żadnego tematu, otrzymują komunikat.

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 protokole HTTP i XMPP.

Temat żądania HTTP POST

Wyślij do jednego tematu:

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


Wyślij na urządzenia subskrybowane 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>

Wyślij na urządzenia subskrybowane w tematach „psy” lub „koty”:

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


  </gcm>
</message>

Temat odpowiedzi XMPP

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

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

Należy spodziewać się do 30 sekund opóźnienia, zanim serwer FCM 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, zapoznaj się z informacjami referencyjnymi dotyczącymi 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ć komunikaty 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” - do notification_key są skojarzone 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ą skojarzone 3 tokeny rejestracji. Wiadomość została pomyślnie wysłana tylko do 1 z tokenów rejestracji. Wiadomość z odpowiedzią zawiera tokeny rejestracji, które nie otrzymały wiadomości:

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

Gdy wiadomość nie zostanie dostarczona do co najmniej jednego tokenów rejestracji skojarzonych z notification_key , serwer aplikacji powinien ponawiać próby z wycofywaniem 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 wynikiem 0 powodzeń 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 ACK. Jeśli wszystkie wiadomości wysłane do wszystkich urządzeń w grupie nie powiodą się, serwer połączeń XMPP odpowie komunikatem NACK.

Oto przykład „sukcesu” - do notification_key są skojarzone 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ą skojarzone 3 tokeny rejestracji. Wiadomość została pomyślnie wysłana tylko do 1 z tokenów rejestracji. Wiadomość z odpowiedzią zawiera tokeny 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łączenia FCM nie dostarcza do wszystkich urządzeń w grupie. Serwer aplikacji otrzyma odpowiedź nack.

Aby uzyskać pełną listę opcji wiadomości, zapoznaj się z informacjami referencyjnymi dotyczącymi wybranego protokołu serwera połączeń, HTTP lub XMPP .

Starsze metody wysyłania pakietu Firebase Admin SDK

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

Wyślij na poszczególne urządzenia

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

Node.js

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

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

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

Metoda sendToDevice() może również wysyłać wiadomość multiemisji (to znaczy wiadomość do wielu urządzeń), przekazując tablicę tokenów rejestracji zamiast tylko jednego tokenu rejestracji:

Node.js

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

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

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

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ą, że cała wiadomość nie jest przetwarzana. 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ązania, zobacz Błędy interfejsu API administratora FCM .

Wyślij do grupy urządzeń

Obsługa wiadomości grupowych urządzeń umożliwia dodanie wielu urządzeń do jednej grupy. Jest to podobne do przesyłania wiadomości tematycznych, ale obejmuje uwierzytelnianie zapewniające, że członkostwem w grupie zarządzają tylko 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. Wiadomości grupowe różnią się od wiadomości tematycznych tym, że obejmują zarządzanie grupami urządzeń z serwerów, a nie bezpośrednio z 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ż możliwość przesyłania wiadomości grupowych urządzeń. Maksymalna liczba członków dozwolona 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.
var notificationKey = 'some-notification-key';

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

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

Metoda sendToDeviceGroup() zwraca obietnicę, która jest rozwiązywana za pomocą obiektu MessagingDeviceGroupResponse zawierającego odpowiedź z FCM.

Niektóre przypadki, takie jak błąd uwierzytelniania lub ograniczenie szybkości, powodują, że cała wiadomość nie jest przetwarzana. 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ązania, zobacz Błędy interfejsu API administratora FCM .

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

var payload = {
  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.'
  }
};

Wiadomość z danymi

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

Połączona wiadomość

var payload = {
  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.'
  },
  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 tego, na który mobilny system operacyjny jest kierowany. Zobacz dokumentację referencyjną dotyczącą NotificationMessagePayload aby uzyskać pełną listę.

Ładunki komunikatów danych składają się z niestandardowych par klucz-wartość z kilkoma ograniczeniami, w tym z faktem, że wszystkie wartości muszą być ciągami. Zobacz dokumentację referencyjną dotyczącą DataMessagePayload aby uzyskać 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 wiadomości. 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.
var registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';

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

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

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

Zobacz dokumenty referencyjne MessagingOptions aby uzyskać pełną listę dostępnych opcji.