Samouczek: wysyłanie powiadomień do określonych urządzeń przy użyciu usług Notification Hubs i Google Firebase Cloud Messaging

Artykuł
05/09/2024

Omówienie

Ważne

Od czerwca 2024 r. starsze interfejsy API usługi FCM nie będą już obsługiwane i zostaną wycofane. Aby uniknąć zakłóceń w usłudze powiadomień wypychanych, należy przeprowadzić migrację do protokołu FCM v1 tak szybko, jak to możliwe.

Korzystając z tego samouczka, dowiesz się, jak rozgłaszać powiadomienia z najważniejszymi informacjami do aplikacji systemu Android przy użyciu usługi Azure Notification Hubs. Po zakończeniu pracy z samouczkiem będziesz wiedzieć, jak rejestrować kategorie ważnych wiadomości, które Cię interesują, oraz otrzymywać tylko powiadomienia push dla tych kategorii. Ten scenariusz jest typowym wzorcem dla wielu aplikacji wymagających wysyłania powiadomień do grup użytkowników, które wcześniej zadeklarowały zainteresowanie nimi, na przykład czytników danych RSS, aplikacji dla fanów muzyki itp.

Scenariusze rozgłaszania są włączone w przypadku co najmniej jednego tagu podczas tworzenia rejestracji w centrum powiadomień. W przypadku wysłania powiadomień do tagu wszystkie urządzenia zarejestrowane dla tego tagu otrzymają powiadomienie. Tagi to po prostu ciągi, dlatego nie muszą być aprowizowane z wyprzedzeniem. Aby uzyskać więcej informacji na temat tagów, zobacz Notification Hubs Routing and Tag Expressions (Wyrażenia routingu i tagów w usłudze Notification Hubs).

W tym samouczku wykonasz następujące czynności:

Dodawanie wyboru kategorii do aplikacji mobilnej.
Rejestrowanie w celu otrzymywania powiadomień z tagami.
Wysyłanie powiadomień z tagami.
Testowanie aplikacji

Wymagania wstępne

Ten samouczek bazuje na aplikacji utworzonej w artykule Samouczek: wysyłanie powiadomień wypychanych do urządzeń z systemem Android przy użyciu usług Azure Notification Hubs i Firebase Cloud Messaging. Przed rozpoczęciem tego samouczka ukończ samouczek: wysyłanie powiadomień wypychanych do urządzeń z systemem Android przy użyciu usług Azure Notification Hubs i Firebase Cloud Messaging.

Dodawanie wyboru kategorii do aplikacji

Pierwszym krokiem jest dodanie elementów interfejsu użytkownika do istniejącej strony głównej, co umożliwi użytkownikowi wybranie kategorii do zarejestrowania. Kategorie wybrane przez użytkownika są przechowywane na urządzeniu. Po uruchomieniu aplikacji w centrum powiadomień zostanie utworzona rejestracja urządzenia z wybranymi kategoriami w formie tagów.

Otwórz plik res/layout/activity_main.xml file i zastąp jego zawartość następującą zawartością:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.breakingnews.MainActivity"
    android:orientation="vertical">

        <CheckBox
            android:id="@+id/worldBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_world" />
        <CheckBox
            android:id="@+id/politicsBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_politics" />
        <CheckBox
            android:id="@+id/businessBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_business" />
        <CheckBox
            android:id="@+id/technologyBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_technology" />
        <CheckBox
            android:id="@+id/scienceBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_science" />
        <CheckBox
            android:id="@+id/sportsBox"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/label_sports" />
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:onClick="subscribe"
            android:text="@string/button_subscribe" />
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello World!"
            android:id="@+id/text_hello"
        />
</LinearLayout>

Otwórz plik res/values/strings.xml i dodaj następujące wiersze:

<string name="button_subscribe">Subscribe</string>
<string name="label_world">World</string>
<string name="label_politics">Politics</string>
<string name="label_business">Business</string>
<string name="label_technology">Technology</string>
<string name="label_science">Science</string>
<string name="label_sports">Sports</string>

Układ graficzny pliku main_activity.xml powinien wyglądać mniej więcej tak:

Zrzut ekranu przedstawiający emulator przedstawiający wygląd układu graficznego X M L głównego działania.

Utwórz klasę Notifications w tym samym pakiecie co klasa MainActivity.

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import android.content.Context;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.util.Log;
import android.widget.Toast;

import com.google.android.gms.tasks.OnSuccessListener;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.InstanceIdResult;
import com.microsoft.windowsazure.messaging.NotificationHub;

public class Notifications {
    private static final String PREFS_NAME = "BreakingNewsCategories";
    private FirebaseInstanceId fcm;
    private NotificationHub hub;
    private Context context;
    private String senderId;
    public static String FCM_token = "";
    private static final String TAG = "Notifications";

    public Notifications(Context context, String hubName, String listenConnectionString) {
        this.context = context;
        this.senderId = senderId;

        fcm = FirebaseInstanceId.getInstance();
        hub = new NotificationHub(hubName, listenConnectionString, context);
    }

    public void storeCategoriesAndSubscribe(Set<String> categories)
    {
        SharedPreferences settings = context.getSharedPreferences(PREFS_NAME, 0);
        settings.edit().putStringSet("categories", categories).commit();
        subscribeToCategories(categories);
    }

    public Set<String> retrieveCategories() {
        SharedPreferences settings = context.getSharedPreferences(PREFS_NAME, 0);
        return settings.getStringSet("categories", new HashSet<String>());
    }

    public void subscribeToCategories(final Set<String> categories) {
        new AsyncTask<Object, Object, Object>() {
            @Override
            protected Object doInBackground(Object... params) {
                try {
                    FirebaseInstanceId.getInstance().getInstanceId().addOnSuccessListener(new OnSuccessListener<InstanceIdResult>() {
                        @Override
                        public void onSuccess(InstanceIdResult instanceIdResult) {
                            FCM_token = instanceIdResult.getToken();
                            Log.d(TAG, "FCM Registration Token: " + FCM_token);
                        }
                    });

                    TimeUnit.SECONDS.sleep(1);

                    String templateBodyFCM = "{\"data\":{\"message\":\"$(messageParam)\"}}";

                    hub.registerTemplate(FCM_token,"simpleFCMTemplate", templateBodyFCM,
                            categories.toArray(new String[categories.size()]));
                } catch (Exception e) {
                    Log.e("MainActivity", "Failed to register - " + e.getMessage());
                    return e;
                }
                return null;
            }

            protected void onPostExecute(Object result) {
                String message = "Subscribed for categories: "
                        + categories.toString();
                Toast.makeText(context, message,
                        Toast.LENGTH_LONG).show();
            }
        }.execute(null, null, null);
    }

}

Ta klasa używa magazynu lokalnego do przechowywania kategorii wiadomości, które mają być odbierane na tym urządzeniu. Zawiera również metody rejestracji w tych kategoriach.

MainActivity W klasie dodaj pole dla elementu Notifications:
```
private Notifications notifications;
```
Następnie zaktualizuj metodę onCreate , jak pokazano w poniższym kodzie. Rejestrujesz się w usłudze Notification Hubs w metodzie subscribeToCategories klasy Notifications.
```
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mainActivity = this;

    FirebaseService.createChannelAndHandleNotifications(getApplicationContext());
    notifications = new Notifications(this, NotificationSettings.HubName, NotificationSettings.HubListenConnectionString);
    notifications.subscribeToCategories(notifications.retrieveCategories());
}
```
Upewnij się, że nazwa centrum i parametry połączenia są poprawnie ustawione w klasie NotificationSettings.

Uwaga

Ponieważ poświadczenia dystrybuowane przy użyciu aplikacji klienckiej nie są zazwyczaj bezpieczne, należy przy użyciu aplikacji klienckiej dystrybuować wyłącznie klucz dostępu do nasłuchiwania. Dostęp do nasłuchiwania umożliwia aplikacji rejestrowanie powiadomień, ale nie może ona modyfikować istniejących rejestracji ani wysyłać powiadomień. Klucz pełnego dostępu jest używany w zabezpieczonej usłudze zaplecza do wysyłania powiadomień oraz zmiany istniejących rejestracji.

Następnie dodaj następujące instrukcje importu:

import android.widget.CheckBox;
import java.util.HashSet;
import java.util.Set;
import android.view.View;

Dodaj następującą metodę subscribe w celu obsługi zdarzenia kliknięcia przycisku subskrybowania:

public void subscribe(View sender) {
    final Set<String> categories = new HashSet<String>();

    CheckBox world = (CheckBox) findViewById(R.id.worldBox);
    if (world.isChecked())
        categories.add("world");
    CheckBox politics = (CheckBox) findViewById(R.id.politicsBox);
    if (politics.isChecked())
        categories.add("politics");
    CheckBox business = (CheckBox) findViewById(R.id.businessBox);
    if (business.isChecked())
        categories.add("business");
    CheckBox technology = (CheckBox) findViewById(R.id.technologyBox);
    if (technology.isChecked())
        categories.add("technology");
    CheckBox science = (CheckBox) findViewById(R.id.scienceBox);
    if (science.isChecked())
        categories.add("science");
    CheckBox sports = (CheckBox) findViewById(R.id.sportsBox);
    if (sports.isChecked())
        categories.add("sports");

    notifications.storeCategoriesAndSubscribe(categories);
}

Ta metoda tworzy listę kategorii i używa klasy Notifications do przechowywania listy w magazynie lokalnym oraz rejestrowania odpowiednich tagów w centrum powiadomień. Jeśli kategorie zostaną zmienione, rejestracja zostanie ponownie utworzona przy użyciu nowych kategorii.

Aplikacja może teraz przechowywać zestaw kategorii w magazynie lokalnym na urządzeniu i dokonywać rejestracji przy użyciu centrum powiadomień za każdym razem, gdy użytkownik zmieni wybór kategorii.

Rejestrowanie do otrzymywania powiadomień

Te kroki umożliwiają zarejestrowanie przy użyciu centrum powiadomień przy uruchamianiu przy użyciu kategorii przechowywanych w magazynie lokalnym.

Upewnij się, że na końcu onCreate metody w MainActivity klasie znajduje się następujący kod:
```
notifications.subscribeToCategories(notifications.retrieveCategories());
```
Ten kod gwarantuje, że podczas każdego uruchomienia aplikacja pobiera kategorie z magazynu lokalnego oraz żąda rejestracji dla tych kategorii.

Następnie zaktualizuj metodę onStart() klasy MainActivity w następujący sposób:

@Override
protected void onStart() {

    super.onStart();
    isVisible = true;

    Set<String> categories = notifications.retrieveCategories();

    CheckBox world = (CheckBox) findViewById(R.id.worldBox);
    world.setChecked(categories.contains("world"));
    CheckBox politics = (CheckBox) findViewById(R.id.politicsBox);
    politics.setChecked(categories.contains("politics"));
    CheckBox business = (CheckBox) findViewById(R.id.businessBox);
    business.setChecked(categories.contains("business"));
    CheckBox technology = (CheckBox) findViewById(R.id.technologyBox);
    technology.setChecked(categories.contains("technology"));
    CheckBox science = (CheckBox) findViewById(R.id.scienceBox);
    science.setChecked(categories.contains("science"));
    CheckBox sports = (CheckBox) findViewById(R.id.sportsBox);
    sports.setChecked(categories.contains("sports"));
}

Ten kod aktualizuje stronę główną w oparciu o stan poprzednio zapisanych kategorii.

Aplikacja jest teraz zakończona i może przechowywać w magazynie lokalnym na urządzeniu zestaw kategorii używanych do rejestracji w centrum powiadomień za każdym razem, gdy użytkownik zmieni wybór kategorii. Następnie zdefiniuj zaplecze, które może wysyłać powiadomienia dla kategorii do tej aplikacji.

Wysyłanie powiadomień z tagami

W tej sekcji wyślesz najważniejsze wiadomości w formie oznaczonych tagami powiadomień szablonu z aplikacji konsoli .NET.

W programie Visual Studio utwórz nową aplikację konsoli języka Visual C#:
1. W menu wybierz pozycję Plik>nowy>projekt.
2. W obszarze Utwórz nowy projekt wybierz pozycję Aplikacja konsolowa (.NET Framework) dla języka C# na liście szablonów, a następnie wybierz pozycję Dalej.
3. Wprowadź nazwę aplikacji.
4. W polu Rozwiązanie wybierz pozycję Dodaj do rozwiązania, a następnie wybierz pozycję Utwórz, aby utworzyć projekt.
Wybierz pozycję Narzędzia NuGet>Menedżer pakietów> Menedżer pakietów Konsola, a następnie w oknie konsoli uruchom następujące polecenie:
```
Install-Package Microsoft.Azure.NotificationHubs
```
Ta akcja dodaje odwołanie do zestawu SDK usługi Azure Notification Hubs przy użyciu pakietu Microsoft.Azure.NotificationHubs .
Otwórz plik Program.cs i dodaj następującą using instrukcję:
```
using Microsoft.Azure.NotificationHubs;
```

W klasie Program dodaj następującą metodę lub zastąp ją, jeśli już istnieje:

private static async void SendTemplateNotificationAsync()
{
    // Define the notification hub.
    NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<connection string with full access>", "<hub name>");

    // Apple requires the apns-push-type header for all requests
    var headers = new Dictionary<string, string> {{"apns-push-type", "alert"}};

    // Create an array of breaking news categories.
    var categories = new string[] { "World", "Politics", "Business", "Technology", "Science", "Sports"};

    // Send the notification as a template notification. All template registrations that contain
    // "messageParam" and the proper tags will receive the notifications.
    // This includes APNS, GCM/FCM, WNS, and MPNS template registrations.

    Dictionary<string, string> templateParams = new Dictionary<string, string>();

    foreach (var category in categories)
    {
        templateParams["messageParam"] = "Breaking " + category + " News!";
        await hub.SendTemplateNotificationAsync(templateParams, category);
    }
}

Ten kod wysyła powiadomienie szablonu dla każdego z sześciu tagów w tablicy ciągów. Użycie tagów pozwala zagwarantować, że urządzenia otrzymają powiadomienia tylko dla zarejestrowanych kategorii.

W poprzednim kodzie zastąp symbole zastępcze <hub name> i <connection string with full access> wartościami: nazwą centrum powiadomień i parametrami połączenia DefaultFullSharedAccessSignature z pulpitu nawigacyjnego centrum powiadomień.

W metodzie Main() dodaj następujące wiersze:

 SendTemplateNotificationAsync();
 Console.ReadLine();

Skompiluj aplikację konsoli.

Testowanie aplikacji

W programie Android Studio uruchom aplikację w urządzeniu z systemem Android lub emulatorze systemu Android. Interfejs użytkownika aplikacji udostępnia zestaw przełączników pozwalających wybrać kategorie do zasubskrybowania.
Włącz co najmniej jeden przełącznik kategorii, a następnie kliknij przycisk Subscribe (Subskrybuj). Aplikacja konwertuje wybrane kategorie na tagi i żąda nowej rejestracji urządzenia dla wybranych tagów z centrum powiadomień. Zarejestrowane kategorie są zwracane i wyświetlane w wyskakującym powiadomieniu.
Uruchom aplikację konsolową .NET, która wysyła powiadomienia dla każdej kategorii. Powiadomienia dla wybranych kategorii będą wyświetlane jako powiadomienia wyskakujące.

Następne kroki

W tym samouczku wysłano rozgłoszone powiadomienia do określonych urządzeń z systemem Android zarejestrowanych dla kategorii. Aby dowiedzieć się, jak wysyłać powiadomienia push do konkretnych użytkowników, przejdź do następującego samouczka:

Wysyłanie powiadomień push do konkretnych użytkowników

Udostępnij za pośrednictwem