Catch up on everthing we announced at this year's Firebase Summit. Learn more

Zbuduj serwer aplikacji wysyłaj żądania

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

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

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

Przykłady na tej stronie pokazują, jak do wysyłania powiadomień za pomocą Firebase Admin SDK (który posiada wsparcie dla węzła , Java , Python , C # i idź ) i protokołu HTTP v1 . Istnieje również wytyczne do wysyłania wiadomości za pośrednictwem protokołu HTTP i starszych protokołów XMPP .

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

Aby wysłać do jednego, konkretnego urządzenia, przekaż token rejestracji urządzenia, jak pokazano. Zobacz informacje o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej o tokenach rejestracji.

Node.js

// This registration token comes from the client FCM SDKs.
const registrationToken = 'YOUR_REGISTRATION_TOKEN';

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

// Send a message to the device corresponding to the provided
// registration token.
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)

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)

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

CURL, polecenie:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
   "notification":{
     "title":"FCM Message",
     "body":"This is an FCM Message"
   },
   "token":"bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send

Po pomyślnym zakończeniu każda metoda send zwraca identyfikator wiadomości. Firebase Admin SDK zwraca ciąg identyfikatora w formacie projects/{project_id}/messages/{message_id} . Odpowiedź protokołu HTTP to pojedynczy klucz JSON:

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

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

Interfejsy API REST i Admin FCM API umożliwiają multiemisję wiadomości do listy tokenów rejestracji urządzeń. Możesz określić do 500 tokenów rejestracji urządzenia na jedno wywołanie.

Node.js

// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'YOUR_REGISTRATION_TOKEN_1',
  // …
  'YOUR_REGISTRATION_TOKEN_N',
];

const message = {
  data: {score: '850', time: '2:45'},
  tokens: registrationTokens,
};

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

Udać się

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

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

Dla Firebase administratora SDK operacja ta wykorzystuje sendAll() API pod maską, jak to pokazano w przykładach. Wartość powrotna jest BatchResponse których odpowiedzi liście odpowiada kolejności elementy wejściowe. 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))

Udać się

// 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 wysłanie podrzędne zwraca odpowiedź. Odpowiedzi są oddzielone przez ciąg reakcji, wychodząc z brzegowym --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, albo poprzez zapisanie instancje aplikacji klient w temacie po stronie klienta lub poprzez API serwera , można wysyłać wiadomości do tematu. Jeśli jest to twój pierwszy raz budowania zapytań Wyślij do FCM, zobacz przewodnik środowiska serwera i FCM dla ważnej tle i informacji o konfiguracji.

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

Node.js

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

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

// Send a message to devices subscribed to the provided topic.
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)

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)

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

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ślić warunek, który jest wyrazem logiczna, która określa tematy docelowych. Na przykład, następujący warunek wyśle wiadomości do urządzeń, które są subskrybowanych TopicA i albo 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 subskrybować TopicA nie otrzyma wiadomość. Te kombinacje otrzymują to:

  • TopicA i TopicB
  • TopicA i TopicC

W wyrażeniu warunkowym możesz zawrzeć do pięciu tematów.

Aby wysłać do warunku:

Node.js

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

// See documentation on defining a message payload.
const message = {
  notification: {
    title: '$FooCorp up 1.43% on the day',
    body: '$FooCorp gained 11.80 points to close at 835.67, up 1.43% on the day.'
  },
  condition: condition
};

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
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)

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)

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

CURL, polecenie:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
  "notification": {
    "title": "FCM Message",
    "body": "This is a Firebase Cloud Messaging Topic Message!",
  },
  "condition": "'dogs' in topics || 'cats' in topics"
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Wyślij partię wiadomości

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

Ta funkcja może służyć do tworzenia spersonalizowanego zestawu wiadomości i wysyłania ich do różnych odbiorców, w tym 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',
});

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

Udać się

// 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
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żna zapytać zwrócony BatchResponse aby sprawdzić, ile wiadomości były przekazywane do FCM pomyślnie. Udostępnia również listę odpowiedzi, których można użyć do sprawdzenia stanu poszczególnych wiadomości. Kolejność odpowiedzi odpowiada kolejności komunikatów na liście wejściowej.

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

Możesz wysyłać wiadomości do urządzeń w trybie rozruchu bezpośredniego przy użyciu interfejsu API HTTP v1 lub starszego interfejsu HTTP. Przed wysłaniem do urządzeń w trybie rozruchowym bezpośredniego, upewnij się, że zakończono czynności umożliwiające urządzenia klienckie do odbierania wiadomości FCM w trybie rozruchowym bezpośredniego .

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

Żądanie wiadomość musi zawierać klucz "direct_boot_ok" : true w AndroidConfig opcji ciała żą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ść musi zawierać klucz "direct_boot_ok" : true na poziomie górnej części ciała żądania. Na przykład:

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

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

Wiadomości wysyłane z tym kluczem w treści żądania mogą być obsługiwane przez aplikacje na urządzeniach znajdujących się obecnie w trybie rozruchu bezpośredniego (a także wtedy, gdy nie są w tym trybie).

Dostosuj wiadomości na różnych platformach

Firebase Admin SDK i protokół HTTP FCM v1 zarówno umożliwić wnioski wiadomość ustawić wszystkie pola dostępne w message obiektu. To zawiera:

  • wspólny zestaw pól powinny być interpretowane przez wszystkich instancji aplikacji, które otrzymują wiadomość.
  • Zestawy danej platformy dziedzinach, takich jak AndroidConfig i WebpushConfig , interpretowane wyłącznie przez instancje aplikacji uruchomionych na określonym platformy.

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

Kiedy używać wspólnych pól

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

  • Kierowanie instancje aplikacji na wszystkich platformach - Apple, Android, i internetowych
  • Wysyłanie wiadomości do tematów

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

Kiedy używać pól specyficznych dla platformy

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

  • Wysyłaj pola tylko do określonych platform
  • Wyślij platformy konkretnych pól oprócz wspólnych pól

Gdy chcesz wysłać wartości tylko do konkretnych platform, nie używać wspólnych pól; użyj pól specyficznych dla platformy. Na przykład, aby wysłać powiadomienie tylko do platform Apple i Internetu, ale nie do systemu Android, musisz użyć dwóch oddzielnych zestawów pól, jednego dla Apple i jednego dla Internetu.

Podczas wysyłania wiadomości z konkretnych opcji dostawy , pola platformy szczególne zastosowanie do ich ustawiania. 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. To dlatego, że każda platforma może zinterpretować wartość nieco inaczej, na przykład, czas do zamieszkania jest ustawiony na Androida jako czas ważności w sekundach, podczas gdy na Apple jest ustawiony jako daty ważności.

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

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

W przypadku systemu Android żądanie ustawia specjalną ikonę i kolor, które będą wyświetlane na urządzeniach z systemem Android. Jak zauważono w odniesieniu do AndroidNotification , kolor jest określony w formacie #rrggbb, a obraz musi być odkształcalne ikona zasobu lokalnego do aplikacji na Androida.

Oto przybliżenie efektu wizualnego 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',
)

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

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

Zobacz HTTP v1 dokumentację referencyjną dla pełnego szczegółów na temat klawiszy dostępnych w danej platformy bloków w treści wiadomości.

Przykład: wiadomość z powiadomieniem z niestandardowym obrazem

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

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

Zobacz HTTP v1 dokumentację referencyjną dla pełnego szczegółów na temat klawiszy dostępnych w danej platformy bloków w treści wiadomości.

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

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

Prosty rysunek użytkownika otwierającego 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"
       }
     }
   }
 }

Zobacz HTTP v1 dokumentację referencyjną dla pełnego szczegółów na temat klawiszy dostępnych w danej platformy bloków w treści wiadomości.

Przykład: powiadomienie z opcjami lokalizacji

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

Prosty rysunek dwóch urządzeń wyświetlających tekst w języku angielskim i hiszpańskim

Node.js

var topicName = 'industry-tech';

var message = {
  android: {
    ttl: 3600000,
    notification: {
      bodyLocKey: 'STOCK_NOTIFICATION_BODY',
      bodyLocArgs: ['FooCorp', '11.80', '835.67', '1.43']
    }
  },
  apns: {
    payload: {
      aps: {
        alert: {
          locKey: 'STOCK_NOTIFICATION_BODY',
          locArgs: ['FooCorp', '11.80', '835.67', '1.43']
        }
      }
    }
  },
  topic: topicName,
};

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

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

Zobacz HTTP v1 dokumentację referencyjną dla pełnego szczegółów na temat klawiszy dostępnych w danej platformy bloków w treści wiadomości.

Kody błędów administratora

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

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

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

Wysyłanie wiadomości do konkretnych urządzeń, ustawić to kluczu do rejestracji token instancji konkretnej aplikacji. Zobacz informacje o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej o tokenach rejestracji.

Żądanie HTTP POST

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

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

Odpowiedź HTTP

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

Wiadomość XMPP

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

Odpowiedź XMPP

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

Serwer połączeń XMPP udostępnia kilka innych opcji odpowiedzi. Zobacz formatu odpowiedzi serwera .

Dla pełnej listy dostępnych opcji wiadomości podczas wysyłania wiadomości dalszych aplikacjach klienckich, zapoznaj się z informacjami odniesienia dla wybranego połączenia, serwer protokołu HTTP lub XMPP .

Wysyłaj wiadomości do tematów

Wysyłanie wiadomości do tematu Firebase Cloud Messaging jest bardzo podobne do wysyłania wiadomości na pojedyncze urządzenie lub do grupy użytkowników. Zestawy serwera aplikacji to to klucza o wartości podobnego /topics/yourTopic . Programiści mogą wybrać dowolną nazwę tematu, który 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 subskrybowanych TopicA i albo TopicB lub TopicC :

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

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

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

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

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

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


Temat odpowiedzi HTTP

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

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

Temat wiadomości XMPP

Wyślij do jednego tematu:

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


  </gcm>
</message>

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

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


  </gcm>
</message>

Odpowiedź XMPP na temat

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

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

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

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 typów komunikatów Szczegółowe informacje na temat wsparcia ładunku. Przykłady na tej stronie pokazują, jak wysyłać wiadomości z danymi do grup urządzeń w protokołach HTTP i XMPP.

Żądanie POST HTTP grupy urządzeń

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

{
  "to": "aUniqueKey",
  "data": {
    "hello": "This is a Firebase Cloud Messaging Device Group Message!",
   }
}

Odpowiedź HTTP grupy urządzeń

Oto przykład z „sukcesu” - w notification_key ma 2 znaki rejestracyjne związane z nim, a wiadomość została wysłana do obu z nich:

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

Oto przykład z „częściowy sukces” - w notification_key ma 3 Rejestracja żetony z nim związane. Wiadomość została pomyślnie wysłana tylko do jednego z tokenów rejestracji. Wykazy wiadomość odpowiedź tokenów rejestracyjne ( registration_ids ), które nie otrzymały wiadomość:

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

Gdy wiadomość nie być dostarczane do jednego lub więcej z rejestracją żetony związany z notification_key , serwer aplikacji należy powtórzyć z backoff między próbami.

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

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

Oto przykład z „sukcesu” - w notification_key ma 3 znaki rejestracyjne związane z nim, a wiadomość została wysłana do wszystkich z nich:

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

Oto przykład z „częściowy sukces” - w notification_key ma 3 Rejestracja żetony z nim związane. Wiadomość została pomyślnie wysłana tylko do jednego z tokenów rejestracji. Komunikat odpowiedzi zawiera listę tokenów rejestracji, które nie otrzymały wiadomości:

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

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

Pełen wykaz opcji wiadomości, zapoznaj się z informacjami odniesienia dla wybranego połączenia, serwer protokołu HTTP lub XMPP .

Starsze metody wysyłania pakietu Firebase Admin SDK

Firebase Admin node.js SDK obsługuje metody wysyłania wiadomości (FCM) w oparciu o serwer API Legacy FCM . Metody te akceptują różne argumenty porównaniu do send() metody. Należy używać send() metoda w miarę możliwości 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żna przejść rejestrację token do sendToDevice() metody, 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);
  });

sendToDevice() metoda może również wysłać wiadomość multicast (to jest wiadomość do wielu urządzeń) przekazując tablicę rejestracji żetony zamiast tylko jednej rejestracji tokena:

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

sendToDevice() sposób wraca do obiecujące, który można rozwiązać za pomocą MessagingDevicesResponse przedmiotu zawierającego odpowiedź FCM. Zwracany typ ma ten sam format podczas przekazywania pojedynczego tokenu rejestracji lub tablicy tokenów rejestracji.

Niektóre przypadki, takie jak błąd uwierzytelniania lub ograniczenie szybkości, powodują niepowodzenie przetwarzania całej wiadomości. W tych przypadkach, obietnica zwrócony przez sendToDevice() zostaje odrzucona z powodu błędu. Pełną listę kodów błędów, w tym opisy i etapów rozwiązywania zobacz Admin FCM Błędy API .

Wyślij do grupy urządzeń

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

Można korzystać z wiadomości za pośrednictwem grupy urządzeń starszego XMPP lub HTTP protokołów na serwerze aplikacji. Firebase Admin SDK dla node.js na podstawie protokołów starszych również zapewniają możliwości komunikatorów grupy urządzeń. Maksymalna liczba członków dozwolonych dla klucza powiadomienia to 20.

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

sendToDeviceGroup() metoda pozwala na wysyłanie wiadomości do grupy urządzeń, określając klucz 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);
  });

sendToDeviceGroup() sposób wraca do obiecujące, który można rozwiązać za pomocą MessagingDevicesResponse przedmiotu zawierającego odpowiedź FCM.

Niektóre przypadki, takie jak błąd uwierzytelniania lub ograniczenie szybkości, powodują niepowodzenie przetwarzania całej wiadomości. W tych przypadkach, obietnica zwrócony przez sendToDeviceGroup() zostaje odrzucona z powodu błędu. Pełną listę kodów błędów, w tym opisy i etapów rozwiązywania zobacz Admin FCM Błędy API .

Definiowanie ładunku wiadomości

Powyższe metody oparte na protokołach FCM starszych przyjąć ładunek wiadomość jako drugi argument i obsługiwać zarówno powiadomień i danych . Można określić typy jeden lub oba wiadomość poprzez utworzenie obiektu z data i / lub notification kluczy. Na przykład, oto jak zdefiniować różne typy ładunków wiadomości:

Wiadomość z powiadomieniem

const payload = {
  notification: {
    title: '$FooCorp up 1.43% on the day',
    body: '$FooCorp gained 11.80 points to close at 835.67, up 1.43% on the day.'
  }
};

Wiadomość z danymi

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

Połączona wiadomość

const payload = {
  notification: {
    title: '$FooCorp up 1.43% on the day',
    body: '$FooCorp gained 11.80 points to close at 835.67, up 1.43% on the day.'
  },
  data: {
    stock: 'GOOG',
    open: '829.62',
    close: '635.67'
  }
};

Ładunki wiadomości powiadomień mają wstępnie zdefiniowany podzbiór prawidłowych właściwości i różnią się nieznacznie w zależności od docelowego mobilnego systemu operacyjnego. Zobacz docs odniesienia dla NotificationMessagePayload do pełnej listy.

Ładunki wiadomości danych składają się z niestandardowych par klucz-wartość z kilkoma ograniczeniami, w tym faktem, że wszystkie wartości muszą być ciągami. Zobacz docs odniesienia dla 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 komunikatu. Na przykład poniższy przykład wysyła wiadomość o wysokim priorytecie do urządzenia, która wygasa po 24 godzinach:

Node.js

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

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

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

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

Zobacz docs odniesienia dla MessagingOptions aby uzyskać pełną listę dostępnych opcji.