Zbuduj żądania wysyłania serwera aplikacji

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

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

Możesz wysyłać wiadomości z ładunkiem powiadomienia składającym się z predefiniowanych pól, ładunkiem danych z własnych pól zdefiniowanych przez użytkownika lub wiadomością zawierającą oba rodzaje ładunku. Aby uzyskać więcej informacji, zobacz Typy wiadomości .

Przykłady na tej stronie pokazują, jak wysyłać powiadomienia przy użyciu 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 przestarzałych , starszych protokołów HTTP i XMPP .

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

Aby wysłać na pojedyncze, konkretne urządzenie, przekaż token rejestracji urządzenia, jak pokazano. Zobacz informacje o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej o tokenach rejestracyjnych.

Node.js

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

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

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

Jawa

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

// See documentation on defining a message payload.
Message message = Message.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .setToken(registrationToken)
    .build();

// Send a message to the device corresponding to the provided
// registration token.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Pyton

# This registration token comes from the client FCM SDKs.
registration_token = 'YOUR_REGISTRATION_TOKEN'

# See documentation on defining a message payload.
message = messaging.Message(
    data={
        'score': '850',
        'time': '2:45',
    },
    token=registration_token,
)

# Send a message to the device corresponding to the provided
# registration token.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Iść

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

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

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

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

C#

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

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

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

ODPOCZYNEK

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

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

polecenie curl:

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

W przypadku powodzenia każda metoda wysyłania zwraca identyfikator wiadomości. Pakiet SDK administratora Firebase zwraca ciąg identyfikacyjny w formacie projects/{project_id}/messages/{message_id} . Odpowiedzią protokołu HTTP jest pojedynczy klucz JSON:

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

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

Interfejsy API Admin FCM umożliwiają multiemisję wiadomości do listy tokenów rejestracji urządzeń. Na wywołanie można określić maksymalnie 500 tokenów rejestracji urządzeń.

Node.js

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

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

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

Jawa

// Create a list containing up to 500 registration tokens.
// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n"
);

MulticastMessage message = MulticastMessage.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .addAllTokens(registrationTokens)
    .build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");

Pyton

# Create a list containing up to 500 registration tokens.
# These registration tokens come from the client FCM SDKs.
registration_tokens = [
    'YOUR_REGISTRATION_TOKEN_1',
    # ...
    'YOUR_REGISTRATION_TOKEN_N',
]

message = messaging.MulticastMessage(
    data={'score': '850', 'time': '2:45'},
    tokens=registration_tokens,
)
response = messaging.send_multicast(message)
# See the BatchResponse reference documentation
# for the contents of response.
print('{0} messages were sent successfully'.format(response.success_count))

Iść

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

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

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

C#

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

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

Wartość zwracana to lista tokenów odpowiadająca kolejności tokenów wejściowych. Jest to przydatne, gdy chcesz sprawdzić, które tokeny spowodowały błędy.

Node.js

// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'YOUR_REGISTRATION_TOKEN_1',
  // …
  'YOUR_REGISTRATION_TOKEN_N',
];

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

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

Jawa

// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n"
);

MulticastMessage message = MulticastMessage.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .addAllTokens(registrationTokens)
    .build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
if (response.getFailureCount() > 0) {
  List<SendResponse> responses = response.getResponses();
  List<String> failedTokens = new ArrayList<>();
  for (int i = 0; i < responses.size(); i++) {
    if (!responses.get(i).isSuccessful()) {
      // The order of responses corresponds to the order of the registration tokens.
      failedTokens.add(registrationTokens.get(i));
    }
  }

  System.out.println("List of tokens that caused failures: " + failedTokens);
}

Pyton

# These registration tokens come from the client FCM SDKs.
registration_tokens = [
    'YOUR_REGISTRATION_TOKEN_1',
    # ...
    'YOUR_REGISTRATION_TOKEN_N',
]

message = messaging.MulticastMessage(
    data={'score': '850', 'time': '2:45'},
    tokens=registration_tokens,
)
response = messaging.send_multicast(message)
if response.failure_count > 0:
    responses = response.responses
    failed_tokens = []
    for idx, resp in enumerate(responses):
        if not resp.success:
            # The order of responses corresponds to the order of the registration tokens.
            failed_tokens.append(registration_tokens[idx])
    print('List of tokens that caused failures: {0}'.format(failed_tokens))

Iść

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

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

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

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

C#

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

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

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

Wysyłaj wiadomości do tematów

Po utworzeniu tematu, subskrybując instancje aplikacji klienckiej do tematu po stronie klienta lub za pośrednictwem interfejsu API serwera , możesz wysyłać wiadomości do tematu. Jeśli tworzysz żądania wysyłania dla FCM po raz pierwszy, zapoznaj się z przewodnikiem po środowisku serwera i FCM , aby uzyskać ważne informacje dotyczące tła i konfiguracji.

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

Node.js

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

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

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

Jawa

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

// See documentation on defining a message payload.
Message message = Message.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .setTopic(topic)
    .build();

// Send a message to the devices subscribed to the provided topic.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Pyton

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

# See documentation on defining a message payload.
message = messaging.Message(
    data={
        'score': '850',
        'time': '2:45',
    },
    topic=topic,
)

# Send a message to the devices subscribed to the provided topic.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Iść

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

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

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

C#

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

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

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

ODPOCZYNEK

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
  "message":{
    "topic" : "foo-bar",
    "notification" : {
      "body" : "This is a Firebase Cloud Messaging Topic Message!",
      "title" : "FCM Message"
      }
   }
}

polecenie curl:

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

Aby wysłać wiadomość do kombinacji tematów, określ warunek , który jest wyrażeniem boolowskim określającym tematy docelowe. Na przykład następujący warunek wyśle ​​wiadomości do urządzeń subskrybujących TopicA oraz 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 subskrybujący dowolny temat nie otrzymuje wiadomości. Podobnie użytkownik, który nie subskrybuje TopicA nie otrzyma wiadomości. Te kombinacje go otrzymują:

  • TopicA i TopicB
  • TopicA i TopicC

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

Aby wysłać do warunku:

Node.js

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

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

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
getMessaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Jawa

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

// See documentation on defining a message payload.
Message message = Message.builder()
    .setNotification(Notification.builder()
        .setTitle("$GOOG up 1.43% on the day")
        .setBody("$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.")
        .build())
    .setCondition(condition)
    .build();

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Pyton

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

# See documentation on defining a message payload.
message = messaging.Message(
    notification=messaging.Notification(
        title='$GOOG up 1.43% on the day',
        body='$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
    ),
    condition=condition,
)

# Send a message to devices subscribed to the combination of topics
# specified by the provided condition.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Iść

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

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

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

C#

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

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

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

ODPOCZYNEK

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
   "message":{
    "condition": "'dogs' in topics || 'cats' in topics",
    "notification" : {
      "body" : "This is a Firebase Cloud Messaging Topic Message!",
      "title" : "FCM Message",
    }
  }
}

polecenie curl:

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

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

Aby wysyłać wiadomości do grup urządzeń, użyj interfejsu API HTTP v1. Jeśli obecnie wysyłasz do grup urządzeń przy użyciu przestarzałych starszych interfejsów API wysyłania dla HTTP lub XMPP albo dowolnej starszej wersji pakietu Firebase Admin SDK dla Node.js opartej na starszych protokołach, zdecydowanie zalecamy migrację do protokołu HTTP v1 API przy najbliższej okazji. Starsze interfejsy API wysyłania zostaną wyłączone i usunięte w czerwcu 2024 r.

Wysyłanie wiadomości do grupy urządzeń jest bardzo podobne do wysyłania wiadomości do pojedynczego urządzenia, przy użyciu tej samej metody autoryzacji żądań wysłania . Ustaw pole token na klucz powiadomienia grupowego:

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

polecenie cURL

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

Wyślij partię wiadomości

Pakiety Admin SDK obsługują wysyłanie wiadomości partiami. Możesz zgrupować do 500 wiadomości w jedną partię i wysłać je wszystkie w ramach jednego wywołania API, co znacznie poprawia wydajność w porównaniu z wysyłaniem oddzielnych żądań HTTP dla każdej wiadomości.

Funkcję tę można wykorzystać do zbudowania spersonalizowanego zestawu wiadomości i wysłania ich do różnych odbiorców, uwzględniając tematy lub tokeny rejestracji konkretnych urządzeń. Skorzystaj z tej funkcji, gdy na przykład chcesz jednocześnie wysłać wiadomości do różnych odbiorców, zawierające nieco inne szczegóły w treści wiadomości.

Node.js

// Create a list containing up to 500 messages.
const messages = [];
messages.push({
  notification: { title: 'Price drop', body: '5% off all electronics' },
  token: registrationToken,
});
messages.push({
  notification: { title: 'Price drop', body: '2% off all books' },
  topic: 'readers-club',
});

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

Jawa

// Create a list containing up to 500 messages.
List<Message> messages = Arrays.asList(
    Message.builder()
        .setNotification(Notification.builder()
            .setTitle("Price drop")
            .setBody("5% off all electronics")
            .build())
        .setToken(registrationToken)
        .build(),
    // ...
    Message.builder()
        .setNotification(Notification.builder()
            .setTitle("Price drop")
            .setBody("2% off all books")
            .build())
        .setTopic("readers-club")
        .build()
);

BatchResponse response = FirebaseMessaging.getInstance().sendAll(messages);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");

Pyton

# Create a list containing up to 500 messages.
messages = [
    messaging.Message(
        notification=messaging.Notification('Price drop', '5% off all electronics'),
        token=registration_token,
    ),
    # ...
    messaging.Message(
        notification=messaging.Notification('Price drop', '2% off all books'),
        topic='readers-club',
    ),
]

response = messaging.send_all(messages)
# See the BatchResponse reference documentation
# for the contents of response.
print('{0} messages were sent successfully'.format(response.success_count))

Iść

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

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

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

C#

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

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

Wysyłaj wiadomości z możliwością bezpośredniego rozruchu (tylko Android)

Możesz wysyłać wiadomości do urządzeń w trybie rozruchu bezpośredniego, korzystając z interfejsu API protokołu HTTP v1 lub starszego protokołu 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_boot_ok" : true w opcjach AndroidConfig w treści żądania. Na przykład:

https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send
Content-Type:application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

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

Wyślij, korzystając ze starszego interfejsu API HTTP FCM

Żądanie wiadomości musi zawierać klucz "direct_boot_ok" : true na najwyższym poziomie treści żądania. Na przykład:

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

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

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

Dostosuj wiadomości na różnych platformach

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

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

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

Kiedy używać typowych pól

Używaj typowych pól, gdy:

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

Wszystkie instancje aplikacji, niezależnie od platformy, mogą interpretować 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 na określone platformy
  • Oprócz typowych pól wysyłaj pola specyficzne dla platformy

Jeśli chcesz wysyłać wartości tylko do określonych platform, nie używaj wspólnych pól; użyj pól specyficznych dla platformy. Na przykład, aby wysłać powiadomienie tylko do platform 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.

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 dlatego, że każda platforma może nieco inaczej interpretować tę wartość — na przykład czas wygaśnięcia w systemie Android jest ustawiany jako czas wygaśnięcia w sekundach, natomiast w Apple jako data wygaśnięcia.

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

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

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

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

Prosty rysunek dwóch urządzeń, z których jedno wyświetla niestandardową ikonę i kolor

Node.js

const topicName = 'industry-tech';

const message = {
  notification: {
    title: '`$FooCorp` up 1.43% on the day',
    body: 'FooCorp gained 11.80 points to close at 835.67, up 1.43% on the day.'
  },
  android: {
    notification: {
      icon: 'stock_ticker_update',
      color: '#7e55c3'
    }
  },
  topic: topicName,
};

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

Jawa

Message message = Message.builder()
    .setNotification(Notification.builder()
        .setTitle("$GOOG up 1.43% on the day")
        .setBody("$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.")
        .build())
    .setAndroidConfig(AndroidConfig.builder()
        .setTtl(3600 * 1000)
        .setNotification(AndroidNotification.builder()
            .setIcon("stock_ticker_update")
            .setColor("#f45342")
            .build())
        .build())
    .setApnsConfig(ApnsConfig.builder()
        .setAps(Aps.builder()
            .setBadge(42)
            .build())
        .build())
    .setTopic("industry-tech")
    .build();

Pyton

message = messaging.Message(
    notification=messaging.Notification(
        title='$GOOG up 1.43% on the day',
        body='$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
    ),
    android=messaging.AndroidConfig(
        ttl=datetime.timedelta(seconds=3600),
        priority='normal',
        notification=messaging.AndroidNotification(
            icon='stock_ticker_update',
            color='#f45342'
        ),
    ),
    apns=messaging.APNSConfig(
        payload=messaging.APNSPayload(
            aps=messaging.Aps(badge=42),
        ),
    ),
    topic='industry-tech',
)

Iść

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

C#

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

ODPOCZYNEK

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
  "message":{
     "topic":"industry-tech",
     "notification":{
       "title":"`$FooCorp` up 1.43% on the day",
       "body":"FooCorp gained 11.80 points to close at 835.67, up 1.43% on the day."
     },
     "android":{
       "notification":{
         "icon":"stock_ticker_update",
         "color":"#7e55c3"
       }
     }
   }
 }

Pełne 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 .

Przykład: wiadomość powiadamiająca z niestandardowym obrazem

Poniższe przykładowe żądanie wysyłania wysyła wspólny tytuł powiadomienia do wszystkich platform, ale wysyła również obraz. Oto przybliżony efekt wizualny na urządzeniu użytkownika:

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

Pełne 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 .

Przykład: powiadomienie z powiązaną akcją kliknięcia

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

Prosty rysunek przedstawiający kliknięcie 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"
       }
     }
   }
 }

Pełne 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 .

Przykład: powiadomienie z opcjami lokalizacji

Poniższe przykładowe żądanie wysyłania wysyła opcje lokalizacji do klienta w celu wyświetlenia zlokalizowanych wiadomości. Oto przybliżony efekt wizualny 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"],
                    },
                 },
               },
             },
  },
}'

Pełne 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 API FCM administratora Firebase i ich opisy, w tym zalecane kroki rozwiązywania.

Kod błędu Opis i kroki rozwiązywania
messaging/invalid-argument Do metody FCM podano nieprawidłowy argument. Komunikat o błędzie powinien zawierać dodatkowe informacje.
messaging/invalid-recipient Zamierzony odbiorca wiadomości jest nieprawidłowy. Komunikat o błędzie powinien zawierać dodatkowe informacje.
messaging/invalid-payload Podano nieprawidłowy obiekt ładunku komunikatu. Komunikat o błędzie powinien zawierać dodatkowe informacje.
messaging/invalid-data-payload-key Ładunek komunikatu danych zawiera nieprawidłowy klucz. Zobacz dokumentację referencyjną DataMessagePayload dla kluczy z ograniczeniami.
messaging/payload-size-limit-exceeded Podany ładunek komunikatu przekracza limity rozmiaru FCM. W przypadku większości wiadomości limit 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 rejestracyjny. Upewnij się, że jest zgodny z tokenem rejestracji, który aplikacja kliencka otrzymuje podczas rejestracji w FCM. Nie obcinaj ani nie dodawaj do niego dodatkowych znaków.
messaging/registration-token-not-registered Podany token rejestracyjny nie jest zarejestrowany. Wcześniej ważny token rejestracyjny może zostać wyrejestrowany z różnych powodów, w tym:
  • Aplikacja kliencka wyrejestrowała się z FCM.
  • Aplikacja kliencka została automatycznie wyrejestrowana. Może się to zdarzyć, jeśli użytkownik odinstaluje aplikację lub, na platformach Apple, jeśli usługa opinii APNs zgłosi, że token APNs jest nieprawidłowy.
  • Token rejestracyjny wygasł. Na przykład Google może zdecydować o odświeżeniu tokenów rejestracyjnych lub token APNs mógł wygasnąć dla urządzeń Apple.
  • Aplikacja kliencka została zaktualizowana, ale nowa wersja nie jest skonfigurowana do odbierania wiadomości.
We wszystkich tych przypadkach usuń ten token rejestracyjny i przestań go używać do wysyłania wiadomości.
messaging/invalid-package-name Wiadomość została skierowana do tokena rejestracyjnego, którego nazwa pakietu nie jest zgodna z podaną restrictedPackageName .
messaging/message-rate-exceeded Liczba wiadomości kierowanych do określonego celu jest zbyt wysoka. Zmniejsz liczbę wiadomości wysyłanych na to urządzenie lub temat i nie próbuj natychmiast wysyłać wiadomości do tego celu.
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 ponawiać wysyłania na to urządzenie.
messaging/topics-message-rate-exceeded Liczba wiadomości do subskrybentów na dany temat jest zbyt wysoka. Zmniejsz liczbę wiadomości wysyłanych w tym temacie i nie próbuj od razu ponawiać wysyłania wiadomości w tym temacie.
messaging/too-many-topics Token rejestracyjny 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 do urządzenia Apple, ponieważ wymagany certyfikat SSL APNs nie został przesłany lub wygasł. Sprawdź ważność swoich certyfikatów rozwojowych i produkcyjnych.
messaging/mismatched-credential Dane uwierzytelniające użyte do uwierzytelnienia tego pakietu SDK nie mają uprawnień do wysyłania wiadomości do urządzenia odpowiadającego podanemu tokenowi rejestracji. Upewnij się, że dane uwierzytelniające i token rejestracyjny należą do tego samego projektu Firebase. Dokumentację dotyczącą uwierzytelniania zestawów SDK administratora Firebase znajdziesz w artykule Dodaj Firebase do swojej aplikacji .
messaging/authentication-error Zestaw SDK nie mógł uwierzytelnić się na serwerach FCM. Upewnij się, że uwierzytelniasz pakiet SDK administratora Firebase za pomocą poświadczeń, które mają odpowiednie uprawnienia do wysyłania wiadomości FCM. Dokumentację dotyczącą uwierzytelniania zestawów SDK administratora Firebase znajdziesz w artykule Dodaj Firebase do swojej aplikacji .
messaging/server-unavailable Serwer FCM nie mógł przetworzyć żądania na czas. Powinieneś ponowić tę samą prośbę, ale musisz:
  • Honoruj ​​nagłówek Retry-After , jeśli jest on zawarty w odpowiedzi z serwera połączeń FCM.
  • Zaimplementuj wykładnicze wycofywanie w mechanizmie ponawiania prób. Na przykład, jeśli odczekałeś jedną sekundę przed pierwszą ponowną 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ą kwotę, aby uniknąć jednoczesnego wysyłania nowego żądania dla wszystkich wiadomości.
Nadawcy powodujący problemy mogą zostać umieszczeni na czarnej liście.
messaging/internal-error Serwer FCM napotkał błąd podczas próby przetworzenia żądania. Możesz ponowić tę samą prośbę, spełniając wymagania wymienione w wierszu dotyczącym messaging/server-unavailable powyżej. Jeśli błąd będzie się powtarzał, zgłoś problem do naszego kanału pomocy Raportu o błędach .
messaging/unknown-error Został zwrócony nieznany błąd serwera. Więcej szczegółów 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 kanału pomocy Raport o błędach .

Wysyłaj wiadomości, korzystając ze starszych protokołów serwera aplikacji

Jeśli obecnie używasz starszych protokołów, utwórz żądania wiadomości, jak pokazano w tej sekcji. Pamiętaj, że jeśli wysyłasz na wiele platform za pośrednictwem protokołu HTTP, protokół v1 może znacznie uprościć żądania wiadomości.

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

Aby wysyłać wiadomości do określonych urządzeń, ustaw to to na token rejestracji dla konkretnej instancji aplikacji. Zobacz informacje o konfiguracji klienta dla swojej platformy, aby dowiedzieć się więcej o tokenach rejestracyjnych.

Żądanie HTTP POST

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

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

Odpowiedź HTTP

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

Komunikat XMPP

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

Odpowiedź XMPP

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

Serwer połą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, zobacz informacje referencyjne dotyczące wybranego protokołu serwera połączeń, HTTP lub XMPP .

Wysyłaj wiadomości do tematów

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

Aby wysyłać do kombinacji wielu tematów, serwer aplikacji musi ustawić klucz condition (zamiast klawisza to ) na warunek logiczny określający tematy docelowe. Na przykład, aby wysłać wiadomości do urządzeń, które subskrybują TopicA oraz 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 subskrybujący dowolny temat nie otrzymuje wiadomości. Podobnie użytkownik, który nie subskrybuje TopicA, nie otrzyma wiadomości. Te kombinacje go otrzymują:

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

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

Temat Żądanie HTTP POST

Wyślij do jednego tematu:

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


Wyślij do urządzeń subskrybowanych w tematach „psy” lub „koty”:

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


Temat Odpowiedź HTTP

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

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

Temat Wiadomość XMPP

Wyślij do jednego tematu:

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


  </gcm>
</message>

Wyślij do urządzeń subskrybowanych w tematach „psy” lub „koty”:

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


  </gcm>
</message>

Temat Odpowiedź XMPP

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

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

Należy spodziewać się opóźnienia do 30 sekund, 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.

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

Wysyłanie wiadomości do grupy urządzeń przy użyciu przestarzałych starszych interfejsów API jest bardzo podobne do wysyłania wiadomości do pojedynczego urządzenia. Ustaw to to na unikalny klucz powiadomienia dla grupy urządzeń. Przykłady w tej sekcji pokazują, jak wysyłać wiadomości z danymi do grup urządzeń w starszych protokołach HTTP i XMPP.

Żądanie HTTP POST grupy urządzeń

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

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

Odpowiedź HTTP grupy urządzeń

Oto przykład „sukcesu” — notification_key ma powiązane z nim 2 tokeny rejestracji i wiadomość została pomyślnie wysłana do obu z nich:

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

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

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

Jeśli wiadomość nie zostanie dostarczona do co najmniej jednego tokenu rejestracji powiązanego z notification_key , serwer aplikacji powinien ponowić próbę z wycofywaniem prób.

Jeśli serwer spróbuje wysłać wiadomość do grupy urządzeń, która nie ma członków, odpowiedź będzie wyglądać następująco (0 sukcesów i 0 niepowodzeń):

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

Komunikat XMPP grupy urządzeń

<message id="">
  <gcm xmlns="google:mobile:data">
  {
      "to": "aUniqueKey",
      "message_id": "m-1366082849205" ,
      "data": {
          "hello":"This is a Firebase Cloud Messaging Device Group Message!"
      }
  }
  </gcm>
</message>

Odpowiedź XMPP grupy urządzeń

Jeśli wiadomość zostanie pomyślnie wysłana do dowolnego urządzenia w grupie, serwer połączeń XMPP odpowie potwierdzeniem. 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” — notification_key ma powiązane z nim 3 tokeny rejestracyjne i wiadomość została pomyślnie wysłana do nich wszystkich:

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

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

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

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

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

Metody wysyłania starszych wersji pakietu Firebase Admin SDK

Zestaw SDK Firebase Admin Node.js obsługuje metody wysyłania wiadomości (FCM) w oparciu o interfejs API serwera Legacy FCM . Metody te akceptują inne argumenty w porównaniu z metodą send() . Jeśli to możliwe, powinieneś używać metody send() , a podczas wysyłania wiadomości do poszczególnych urządzeń lub grup urządzeń używaj wyłącznie metod opisanych na tej stronie.

Wyślij do poszczególnych urządzeń

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.
const registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';

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

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

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

Node.js

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

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

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

Metoda sendToDevice() zwraca obietnicę, która jest rozwiązywana za pomocą obiektu MessagingDevicesResponse zawierającego odpowiedź z FCM. Typ zwracany ma ten sam format podczas przekazywania pojedynczego tokenu rejestracji lub tablicy tokenów rejestracji.

Niektóre przypadki, takie jak błąd uwierzytelnienia 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ązywania, zobacz Błędy interfejsu API administratora FCM .

Wyślij do grupy urządzeń

Metoda sendToDeviceGroup() umożliwia wysłanie wiadomości do grupy urządzeń poprzez określenie klucza powiadomienia dla tej grupy urządzeń:

Node.js

// See the "Managing device groups" link above on how to generate a
// notification key.
const notificationKey = 'some-notification-key';

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

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

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

Niektóre przypadki, takie jak błąd uwierzytelnienia 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ązywania, zobacz Błędy interfejsu API administratora FCM .

Definiowanie ładunku wiadomości

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

Wiadomość powiadamiająca

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

Wiadomość danych

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

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ą predefiniowany podzbiór prawidłowych właściwości i różnią się nieznacznie w zależności od docelowego mobilnego systemu operacyjnego. Pełną listę można znaleźć w dokumentach referencyjnych NotificationMessagePayload .

Ładunki komunikatów danych składają się z niestandardowych par klucz-wartość z kilkoma ograniczeniami, takimi jak fakt, że wszystkie wartości muszą być ciągami. Pełną listę ograniczeń można znaleźć w dokumentach referencyjnych DataMessagePayload .

Definiowanie opcji wiadomości

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

Node.js

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

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

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

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

Pełną listę dostępnych opcji można znaleźć w dokumentacji referencyjnej opcji MessagingOptions .