Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Wiadomości tematyczne na Androidzie

W oparciu o model publikowania/subskrypcji komunikaty tematów FCM umożliwiają wysyłanie wiadomości do wielu urządzeń, które zdecydowały się na określony temat. W razie potrzeby komponujesz komunikaty tematyczne, a FCM niezawodnie obsługuje routing i dostarczanie komunikatów do odpowiednich urządzeń.

Na przykład użytkownicy lokalnej aplikacji do prognozowania pływów mogą wybrać temat „alarmów o prądach pływowych” i otrzymywać powiadomienia o optymalnych warunkach połowów w słonej wodzie w określonych obszarach. Użytkownicy aplikacji sportowych mogą subskrybować automatyczne aktualizacje wyników meczów na żywo swoich ulubionych drużyn.

Kilka rzeczy, o których należy pamiętać w przypadku tematów:

  • Wiadomości tematyczne najlepiej nadają się do treści, takich jak pogoda lub inne publicznie dostępne informacje.
  • Temat wiadomości są zoptymalizowane pod kątem wydajności, a nie opóźnienia. Do szybkiego i bezpiecznego dostarczenia do pojedynczych urządzeń lub małych grup urządzeń, komunikatów cel do tokenów rejestracyjnych , a nie tematy.
  • Jeśli chcesz wysyłać wiadomości do wielu urządzeń za użytkownika, należy rozważyć wiadomości grupowe urządzenie dla tych przypadków użycia.
  • Wiadomości tematyczne obsługują nieograniczoną subskrypcję dla każdego tematu. Jednak FCM wymusza ograniczenia w tych obszarach:
    • Do jednej instancji aplikacji można zasubskrybować nie więcej niż 2000 tematów.
    • Jeśli używasz import wsadowy do subskrybowania instancji aplikacji, każda prośba jest ograniczona do 1000 przypadków aplikacji.
    • Częstotliwość nowych subskrypcji jest ograniczona w zależności od projektu. Jeśli wyślesz zbyt wiele żądań subskrypcji w krótkim okresie czasu, serwery FCM będzie reagować z 429 RESOURCE_EXHAUSTED ( „kwota przekroczyła”) odpowiedź. Spróbuj ponownie z wykładniczym wycofywaniem.

Subskrybuj aplikację kliencką do tematu

Aplikacje klienckie mogą subskrybować dowolny istniejący temat lub mogą tworzyć nowy temat. Gdy aplikacja kliencka zasubskrybuje nową nazwę tematu (taką, która jeszcze nie istnieje w Twoim projekcie Firebase), nowy temat o tej nazwie jest tworzony w FCM, a następnie każdy klient może go subskrybować.

Aby zapisać się do tematu, aplikacja klient zwraca Firebase Cloud Messaging subscribeToTopic() z nazwą tematu FCM. Metoda ta zwraca Task , które mogą być wykorzystane przez słuchacza realizacji w celu ustalenia, czy subskrypcja udało:

Jawa

FirebaseMessaging.getInstance().subscribeToTopic("weather")
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                String msg = getString(R.string.msg_subscribed);
                if (!task.isSuccessful()) {
                    msg = getString(R.string.msg_subscribe_failed);
                }
                Log.d(TAG, msg);
                Toast.makeText(MainActivity.this, msg, Toast.LENGTH_SHORT).show();
            }
        });

Kotlin+KTX

Firebase.messaging.subscribeToTopic("weather")
        .addOnCompleteListener { task ->
            var msg = getString(R.string.msg_subscribed)
            if (!task.isSuccessful) {
                msg = getString(R.string.msg_subscribe_failed)
            }
            Log.d(TAG, msg)
            Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
        }

Aby zrezygnować z subskrypcji, aplikacja klient zwraca Firebase Cloud Messaging unsubscribeFromTopic() z nazwą tematu.

Zarządzaj subskrypcjami tematów na serwerze

Firebase Admin SDK pozwala na wykonywanie podstawowych zadań związanych z zarządzaniem temat od strony serwera. Biorąc pod uwagę ich tokeny rejestracji, możesz zbiorczo subskrybować i anulować subskrypcję wystąpień aplikacji klienckich przy użyciu logiki serwera.

Możesz zasubskrybować wystąpienia aplikacji klienckiej do dowolnego istniejącego tematu lub utworzyć nowy temat. Gdy używasz interfejsu API do subskrybowania aplikacji klienckiej do nowego tematu (takiego, który nie istnieje jeszcze w Twoim projekcie Firebase), nowy temat o tej nazwie jest tworzony w FCM i każdy klient może go następnie subskrybować.

Możesz przekazać listę tokenów rejestracji do metody subskrypcji pakietu Firebase Admin SDK, aby zasubskrybować odpowiednie urządzenia do tematu:

Node.js

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

// Subscribe the devices corresponding to the registration tokens to the
// topic.
getMessaging().subscribeToTopic(registrationTokens, topic)
  .then((response) => {
    // See the MessagingTopicManagementResponse reference documentation
    // for the contents of response.
    console.log('Successfully subscribed to topic:', response);
  })
  .catch((error) => {
    console.log('Error subscribing to topic:', error);
  });

Jawa

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

// Subscribe the devices corresponding to the registration tokens to the
// topic.
TopicManagementResponse response = FirebaseMessaging.getInstance().subscribeToTopic(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " tokens were subscribed successfully");

Pyton

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

# Subscribe the devices corresponding to the registration tokens to the
# topic.
response = messaging.subscribe_to_topic(registration_tokens, topic)
# See the TopicManagementResponse reference documentation
# for the contents of response.
print(response.success_count, 'tokens were subscribed successfully')

Udać się

// These registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}

// Subscribe the devices corresponding to the registration tokens to the
// topic.
response, err := client.SubscribeToTopic(ctx, registrationTokens, topic)
if err != nil {
	log.Fatalln(err)
}
// See the TopicManagementResponse reference documentation
// for the contents of response.
fmt.Println(response.SuccessCount, "tokens were subscribed successfully")

C#

// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};

// Subscribe the devices corresponding to the registration tokens to the
// topic
var response = await FirebaseMessaging.DefaultInstance.SubscribeToTopicAsync(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} tokens were subscribed successfully");

Interfejs Admin FCM API umożliwia również anulowanie subskrypcji urządzeń z tematu poprzez przekazanie tokenów rejestracji do odpowiedniej metody:

Node.js

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

// Unsubscribe the devices corresponding to the registration tokens from
// the topic.
getMessaging().unsubscribeFromTopic(registrationTokens, topic)
  .then((response) => {
    // See the MessagingTopicManagementResponse reference documentation
    // for the contents of response.
    console.log('Successfully unsubscribed from topic:', response);
  })
  .catch((error) => {
    console.log('Error unsubscribing from topic:', error);
  });

Jawa

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

// Unsubscribe the devices corresponding to the registration tokens from
// the topic.
TopicManagementResponse response = FirebaseMessaging.getInstance().unsubscribeFromTopic(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " tokens were unsubscribed successfully");

Pyton

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

# Unubscribe the devices corresponding to the registration tokens from the
# topic.
response = messaging.unsubscribe_from_topic(registration_tokens, topic)
# See the TopicManagementResponse reference documentation
# for the contents of response.
print(response.success_count, 'tokens were unsubscribed successfully')

Udać się

// These registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}

// Unsubscribe the devices corresponding to the registration tokens from
// the topic.
response, err := client.UnsubscribeFromTopic(ctx, registrationTokens, topic)
if err != nil {
	log.Fatalln(err)
}
// See the TopicManagementResponse reference documentation
// for the contents of response.
fmt.Println(response.SuccessCount, "tokens were unsubscribed successfully")

C#

// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};

// Unsubscribe the devices corresponding to the registration tokens from the
// topic
var response = await FirebaseMessaging.DefaultInstance.UnsubscribeFromTopicAsync(
    registrationTokens, topic);
// See the TopicManagementResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} tokens were unsubscribed successfully");

W subscribeToTopic() i unsubscribeFromTopic() metodach, prowadzi do obiektu zawierającego odpowiedź FCM. Zwracany typ ma ten sam format, niezależnie od liczby tokenów rejestracji określonych w żądaniu.

W przypadku błędu (nieudane uwierzytelnienie, nieprawidłowy token lub temat itp.) metody te powodują błąd. Pełną listę kodów błędów, w tym opisy i etapów rozwiązywania zobacz Admin FCM Błędy API .

Odbieraj i obsługuj wiadomości tematyczne

FCM dostarcza komunikaty tematu w taki sam sposób, jak inne komunikaty podrzędne.

Aby odbierać wiadomości, skorzystać z usługi, która rozciąga FirebaseMessagingService . Usługa powinna przesłonić onMessageReceived i onDeletedMessages zwrotnych. Powinien obsłużyć każdą wiadomość w ciągu 20 sekund od otrzymania (10 sekund na Androidzie Marshmallow). Okno czasowe może być krótszy w zależności od systemu operacyjnego opóźnień naprzód nazywać onMessageReceived . Po tym czasie, różne zachowania, takie jak Android OS ö w granicach realizacji tło może zaburzać zdolność do zakończenia pracy. Aby uzyskać więcej informacji, zobacz nasz przegląd priorytetu wiadomości .

onMessageReceived jest dla większości typów komunikatów, z następującymi wyjątkami:

  • Powiadomienia dostarczone, gdy aplikacja znajduje się w tle. W takim przypadku powiadomienie jest dostarczane do zasobnika systemowego urządzenia. Kliknięcie powiadomienia przez użytkownika domyślnie otwiera program uruchamiający aplikację.

  • Wiadomości z obu powiadomienia i ładunku danych, gdy otrzymał w tle. W takim przypadku powiadomienie jest dostarczane do zasobnika systemowego urządzenia, a ładunek danych jest dostarczany w dodatkach zgodnie z intencją działania programu uruchamiającego.

W podsumowaniu:

Stan aplikacji Notyfikacja Dane Obie
Pierwszoplanowy onMessageReceived onMessageReceived onMessageReceived
Tło Taca systemowa onMessageReceived Powiadomienie: taca systemowa
Dane: w dodatkach intencji.
Aby uzyskać więcej informacji na temat typów wiadomości, patrz powiadomień i danych wiadomości .

Edytuj manifest aplikacji

Aby korzystać FirebaseMessagingService , należy dodać następujące w app manifeście:

<service
    android:name=".java.MyFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

Ponadto zaleca się ustawienie wartości domyślnych, aby dostosować wygląd powiadomień. Można określić niestandardową domyślną ikonę i niestandardowy domyślny kolor, które są stosowane, gdy równoważne wartości nie są ustawione w ładunku powiadomienia.

Dodaj te linie wewnątrz application tagu ustawić domyślną ikonę zwyczaj i kolor niestandardowy:

<!-- Set custom default icon. This is used when no icon is set for incoming notification messages.
     See README(https://goo.gl/l4GJaQ) for more. -->
<meta-data
    android:name="com.google.firebase.messaging.default_notification_icon"
    android:resource="@drawable/ic_stat_ic_notification" />
<!-- Set color used with incoming notification messages. This is used when no color is set for the incoming
     notification message. See README(https://goo.gl/6BKBk7) for more. -->
<meta-data
    android:name="com.google.firebase.messaging.default_notification_color"
    android:resource="@color/colorAccent" />

Android wyświetla niestandardową domyślną ikonę dla

  • Wszystkie powiadomienia wysyłane z kompozytorem powiadomień .
  • Każda wiadomość z powiadomieniem, która nie ustawia jawnie ikony w ładunku powiadomienia.

Android używa niestandardowego domyślnego koloru dla

  • Wszystkie powiadomienia wysyłane z kompozytorem powiadomień .
  • Dowolny komunikat z powiadomieniem, który nie określa jawnie koloru w ładunku powiadomienia.

Jeśli nie ustawiono niestandardowej ikony domyślnej i nie ustawiono żadnej ikony w ładunku powiadomienia, system Android wyświetla ikonę aplikacji renderowaną na biało.

Przestawianie onMessageReceived

Nadrzędnymi metoda FirebaseMessagingService.onMessageReceived można wykonywać działania w oparciu o otrzymane RemoteMessage obiektu i uzyskać dane wiadomość:

Jawa

@Override
public void onMessageReceived(RemoteMessage remoteMessage) {
    // ...

    // TODO(developer): Handle FCM messages here.
    // Not getting messages here? See why this may be: https://goo.gl/39bRNJ
    Log.d(TAG, "From: " + remoteMessage.getFrom());

    // Check if message contains a data payload.
    if (remoteMessage.getData().size() > 0) {
        Log.d(TAG, "Message data payload: " + remoteMessage.getData());

        if (/* Check if data needs to be processed by long running job */ true) {
            // For long-running tasks (10 seconds or more) use WorkManager.
            scheduleJob();
        } else {
            // Handle message within 10 seconds
            handleNow();
        }

    }

    // Check if message contains a notification payload.
    if (remoteMessage.getNotification() != null) {
        Log.d(TAG, "Message Notification Body: " + remoteMessage.getNotification().getBody());
    }

    // Also if you intend on generating your own notifications as a result of a received FCM
    // message, here is where that should be initiated. See sendNotification method below.
}

Kotlin+KTX

override fun onMessageReceived(remoteMessage: RemoteMessage) {
    // ...

    // TODO(developer): Handle FCM messages here.
    // Not getting messages here? See why this may be: https://goo.gl/39bRNJ
    Log.d(TAG, "From: ${remoteMessage.from}")

    // Check if message contains a data payload.
    if (remoteMessage.data.isNotEmpty()) {
        Log.d(TAG, "Message data payload: ${remoteMessage.data}")

        if (/* Check if data needs to be processed by long running job */ true) {
            // For long-running tasks (10 seconds or more) use WorkManager.
            scheduleJob()
        } else {
            // Handle message within 10 seconds
            handleNow()
        }
    }

    // Check if message contains a notification payload.
    remoteMessage.notification?.let {
        Log.d(TAG, "Message Notification Body: ${it.body}")
    }

    // Also if you intend on generating your own notifications as a result of a received FCM
    // message, here is where that should be initiated. See sendNotification method below.
}

nadpisywania onDeletedMessages

W niektórych sytuacjach FCM może nie dostarczyć wiadomości. Dzieje się tak, gdy jest zbyt wiele wiadomości (>100) oczekujących na aplikację na określonym urządzeniu w momencie łączenia się lub jeśli urządzenie nie łączyło się z FCM przez ponad miesiąc. W takich przypadkach może pojawić się oddzwanianie do FirebaseMessagingService.onDeletedMessages() Gdy instancja aplikacja odbiera ten zwrotnego, należy przeprowadzić pełną synchronizację z serwerem aplikacji. Jeśli nie wysłał wiadomość do aplikacji na tym urządzeniu w ciągu ostatnich 4 tygodni, FCM nie zadzwoni onDeletedMessages() .

Obsługuj powiadomienia w aplikacji działającej w tle

Gdy Twoja aplikacja działa w tle, Android kieruje powiadomienia do zasobnika systemowego. Dotknięcie powiadomienia przez użytkownika domyślnie otwiera program uruchamiający aplikację.

Obejmuje to wiadomości zawierające zarówno powiadomienia, jak i ładunek danych (oraz wszystkie wiadomości wysyłane z konsoli powiadomień). W takich przypadkach powiadomienie jest dostarczane do zasobnika systemowego urządzenia, a ładunek danych jest dostarczany w dodatkach zgodnie z intencją działania programu uruchamiającego.

Dla wgląd dostarczania wiadomości do swojej aplikacji, zobacz pulpit raportowania FCM , który rejestruje liczbę wiadomości wysłanych i otwarte na urządzeniach z systemem iOS i Android, wraz z danymi dla „wrażeń” (zgłoszenia widziane przez użytkowników) dla Android.

Aplikacje z ograniczonym dostępem w tle (Android P lub nowszy)

FCM nie może dostarczyć wiadomości do aplikacji, które zostały wprowadzone do ograniczenia tła przez użytkownika (na przykład poprzez: Ustawienia -> Aplikacje i Notification -> [appname] -> baterii). Gdy aplikacja zostanie usunięta z ograniczenia w tle, nowe wiadomości do aplikacji będą dostarczane tak jak poprzednio. W celu uniknięcia utraconych wiadomości i innych skutków restrykcyjnych tło, upewnij się, aby uniknąć złych zachowań wymienione przez Android Vitals wysiłku. Takie zachowania mogą spowodować, że urządzenie z Androidem zaleci użytkownikowi ograniczenie aplikacji w tle. Twoja aplikacja może sprawdzić, czy jest to tło ograniczony przy użyciu: isBackgroundRestricted () .

Zbuduj wyślij żądania

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

Następne kroki