Udostępnij za pośrednictwem

Powiadomienia użytkownika

Platforma Powiadomień użytkowników umożliwia dostarczanie i obsługę powiadomień lokalnych i zdalnych. Korzystając z tej struktury, aplikacja lub rozszerzenie aplikacji może zaplanować dostarczanie powiadomień lokalnych, określając zestaw warunków, takich jak lokalizacja lub godzina dnia.

Ponadto aplikacja lub rozszerzenie może odbierać (i potencjalnie modyfikować) zarówno powiadomienia lokalne, jak i zdalne, ponieważ są dostarczane do urządzenia użytkownika.

Framework interfejsu użytkownika powiadomień umożliwia aplikacji lub jej rozszerzeniu dostosowanie wyglądu powiadomień lokalnych i zdalnych, gdy są one przedstawiane użytkownikowi.

Ta struktura zapewnia następujące sposoby dostarczania powiadomień użytkownikowi przez aplikację:

  • Alerty wizualne: gdzie powiadomienie jest zwijane z góry ekranu jako baner.
  • Dźwięk i wibracje: można skojarzyć z powiadomieniem.
  • Oznaczanie ikon aplikacji: kiedy ikona aplikacji wyświetla wskaźnik pokazujący, że dostępna jest nowa zawartość, na przykład liczba nieprzeczytanych wiadomości e-mail.

Ponadto w zależności od bieżącego kontekstu użytkownika istnieją różne sposoby prezentowania powiadomienia:

  • Jeśli urządzenie zostanie odblokowane, powiadomienie zostanie wyświetlone w górnej części ekranu jako baner.
  • Jeśli urządzenie jest zablokowane, na ekranie blokady użytkownika zostanie wyświetlone powiadomienie.
  • Jeśli użytkownik przegapił powiadomienie, może otworzyć Centrum powiadomień i wyświetlić wszystkie dostępne powiadomienia oczekujące w tym miejscu.

Aplikacja może wysyłać dwa typy powiadomień użytkownika:

  • Powiadomienia lokalne: są one wysyłane przez aplikacje zainstalowane lokalnie na urządzeniu użytkowników.
  • Powiadomienia zdalne: są wysyłane z serwera zdalnego i prezentowane użytkownikowi lub wyzwalają aktualizację w tle zawartości aplikacji.

Informacje o powiadomieniach lokalnych

Powiadomienia lokalne, które aplikacja może wysyłać, mają następujące funkcje i atrybuty:

  • Są one wysyłane przez aplikacje lokalne na urządzeniu użytkownika.
  • Można je skonfigurować do używania wyzwalaczy opartych na czasie lub lokalizacji.
  • Aplikacja ustawia powiadomienie na urządzeniu użytkownika i jest ono wyświetlane po spełnieniu warunku wyzwalacza.
  • Gdy użytkownik wchodzi w interakcję z powiadomieniem, aplikacja otrzyma wywołanie zwrotne.

Oto kilka przykładów powiadomień lokalnych:

  • Alerty kalendarza.
  • Alerty przypomnienia.
  • Wyzwalacze z rozpoznawaniem lokalizacji.

Aby uzyskać więcej informacji, zobacz dokumentację dotyczącą powiadomień użytkowników firmy Apple.

Informacje o powiadomieniach zdalnych

Powiadomienia zdalne, które aplikacja może wysyłać, mają następujące funkcje i atrybuty:

  • Aplikacja ma składnik po stronie serwera, z którą komunikuje się.
  • Usługa Apple Push Notification Service (APNs) służy do przesyłania powiadomień zdalnych w sposób najlepszy z możliwych z serwerów w chmurze dewelopera do urządzenia użytkownika.
  • Gdy aplikacja odbierze powiadomienie zdalne, zostanie wyświetlone użytkownikowi.
  • Gdy użytkownik wchodzi w interakcję z powiadomieniem, aplikacja otrzyma wywołanie zwrotne.

Oto kilka przykładów powiadomień zdalnych:

  • Alerty dotyczące wiadomości.
  • Aktualizacje sportowe.
  • Wiadomości błyskawiczne.

Istnieją dwa typy powiadomień zdalnych dostępnych dla aplikacji:

  • Widoczne dla użytkownika: są one wyświetlane użytkownikowi na urządzeniu.
  • Aktualizacje dyskretne: zapewniają one mechanizm aktualizowania zawartości aplikacji w tle. Po odebraniu aktualizacji dyskretnej aplikacja może skontaktować się z serwerami zdalnymi, aby ściągnąć najnowszą zawartość.

Aby uzyskać więcej informacji, zobacz dokumentację dotyczącą powiadomień użytkowników firmy Apple.

API UIApplication

Za pomocą interfejsu użytkownikaApplication można zarejestrować powiadomienie w systemie i zaplanować wyzwalanie tego powiadomienia — według czasu lub lokalizacji (był to oryginalny interfejs API udostępniany dla powiadomień użytkowników przez firmę Apple).

Istnieje jednak kilka problemów, które deweloper może napotkać podczas pracy z istniejącym powiadomieniem podanym przez interfejs użytkownikaApplication:

  • Istnieją różne wywołania zwrotne wymagane dla powiadomień lokalnych lub zdalnych, które mogą prowadzić do duplikowania kodu.
  • Aplikacja ma ograniczoną kontrolę nad powiadomieniem po jego zaplanowaniu w systemie.
  • Istnieją różne poziomy obsługi na wszystkich istniejących platformach firmy Apple.

Informacje o strukturze powiadomień użytkowników

Aby ulepszyć środowisko powiadomień, firma Apple wprowadziła strukturę Powiadomień użytkowników, która zastępuje istniejącą metodę UIApplication zanotowaną powyżej.

Platforma Powiadomień użytkowników udostępnia następujące elementy:

  • Znany interfejs API, który zawiera równoważność funkcji z poprzednimi metodami, co ułatwia przenoszenie kodu z istniejącej platformy.
  • Zawiera rozszerzony zestaw opcji zawartości, który umożliwia użytkownikowi wysyłanie bogatszych powiadomień.
  • Zarówno powiadomienia lokalne, jak i zdalne mogą być obsługiwane przez ten sam kod i wywołania zwrotne.
  • Upraszcza proces obsługi wywołań zwrotnych wysyłanych do aplikacji, gdy użytkownik wchodzi w interakcję z powiadomieniem.
  • Ulepszone zarządzanie powiadomieniami oczekującymi i dostarczonymi, w tym możliwość usuwania lub aktualizowania powiadomień.
  • Dodaje możliwość wykonywania prezentacji powiadomień w aplikacji.
  • Dodaje możliwość planowania i obsługi powiadomień z poziomu rozszerzeń aplikacji.
  • Dodaje nowy punkt rozszerzenia dla powiadomień jako takich.

Platforma Powiadomień użytkowników udostępnia ujednolicony interfejs API powiadomień na wielu platformach, które obsługuje firma Apple, w tym:

  • iOS: pełna obsługa zarządzania powiadomieniami i planowania ich.
  • tvOS: dodaje możliwość odznakowania ikon aplikacji dla powiadomień lokalnych i zdalnych.
  • Mac Catalyst: pełna obsługa zarządzania powiadomieniami i planowania ich.
  • macOS: pełna obsługa zarządzania powiadomieniami i planowania ich.

Aby uzyskać więcej informacji, zobacz dokumentację firmy Apple dotyczącą powiadomień użytkownika i interfejsu użytkownika powiadomień użytkownika.

Przygotowywanie do dostarczania powiadomień

Aby aplikacja mogła wysyłać powiadomienia do użytkownika, aplikacja musi zostać zarejestrowana w systemie i, ponieważ powiadomienie jest przerwą w działaniu użytkownika, aplikacja musi jawnie zażądać uprawnień przed ich wysłaniem.

Istnieją trzy różne poziomy żądań powiadomień, które użytkownik może zatwierdzić dla aplikacji:

  • Zostanie wyświetlony baner.
  • Alerty dźwiękowe.
  • Znakowanie ikony aplikacji.

Ponadto te poziomy zatwierdzania muszą być wymagane i ustawione dla powiadomień lokalnych i zdalnych.

Po uruchomieniu aplikacji należy zażądać uprawnienia powiadomień, dodając następujący kod do FinishedLaunching metody AppDelegate i ustawiając żądany typ powiadomienia (UNAuthorizationOptions):

using UserNotifications;

public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
{
    // Request notification permissions from the user
    UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert, (approved, error) => {
        // Handle approval (or disapproval)
    });

    return true;
}

W systemie macOS wykonaj to we wdrożeniu DidFinishLaunching :

using UserNotifications;

public override void DidFinishLaunching (NSNotification notification)
{
    // Request notification permissions from the user
    UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound, (approved, error) => {
        // Handle approval (or disapproval)
    });
}

Uwaga / Notatka

Aplikacje macOS i Mac Catalyst muszą być podpisane, aby okno dialogowe uprawnień było wyświetlane, nawet podczas kompilowania lokalnego w trybie debugowania. Ustaw właściwość EnableCodeSigning w pliku projektu na true, aby wymusić podpisanie aplikacji.

Ponadto użytkownik może zawsze zmieniać uprawnienia powiadomień dla aplikacji w dowolnym momencie przy użyciu aplikacji Ustawienia na urządzeniu. Aplikacja powinna sprawdzić, czy użytkownik zażądał uprawnień powiadomień przed wyświetleniem powiadomienia przy użyciu następującego kodu:

// Get current notification settings
UNUserNotificationCenter.Current.GetNotificationSettings ((settings) => {
    var alertsAllowed = (settings.AlertSetting == UNNotificationSetting.Enabled);
});

Włączanie powiadomień w tle

Aby aplikacja odbierała powiadomienia w tle, musi włączyć tryb w tle powiadomień zdalnych w aplikacji.

Można to zrobić, dodając remote-notifications wpis do UIBackgroundModes tablicy w pliku Info.plist projektu, w następujący sposób:

<key>UIBackgroundModes</key>
<array>
    <string>remote-notification</string>
</array>

Konfigurowanie środowiska powiadomień zdalnych

Deweloper musi poinformować system operacyjny, w jakim środowisku działa powiadomienie push, określając je jako development lub production. Brak podania tych informacji może spowodować odrzucenie aplikacji po przesłaniu do sklepu App Store z powiadomieniem podobnym do następującego:

Brak uprawnień do powiadomienia push — aplikacja zawiera interfejs API dla usługi powiadomień push firmy Apple, ale uprawnienie aps-environment jest brakujące w podpisie aplikacji.

Aby podać wymagane uprawnienie, wykonaj następujące czynności:

  1. Otwórz plik projektu w wybranym edytorze tekstów.

  2. Wprowadź dwa CustomEntitlements elementy w następujący sposób:

    <ItemGroup>
    <CustomEntitlements Include="aps-environment" Type="String" Value="development" Condition="'$(Configuration)' != 'Release'" />
    <CustomEntitlements Include="aps-environment" Type="String" Value="production" Condition="'$(Configuration)' == 'Release'" />
</ItemGroup>

    Uwaga: jeśli używasz innej konfiguracji niż Release do publikowania w sklepie App Store, zaktualizuj odpowiednie warunki.

Uwaga / Notatka

Element aps-environment można również ustawić w pliku Entitlements.plist, co jest historycznym sposobem postępowania. Zaletą korzystania z pliku projektu jest to, że łatwiej jest automatycznie używać poprawnej wartości uprawnień development lub production, w zależności od konfiguracji kompilacji.

Dostarczanie

Uprawnienie aps-environment z poprzedniej sekcji wymaga użycia profilu konfiguracji z Push Notifications funkcją.

  1. Przejdź do sekcji Identyfikatory witryny dla deweloperów firmy Apple :

    Sekcja Identyfikatory

  2. Dodaj nowy identyfikator (Zarejestruj nowy identyfikator):

    Rejestrowanie nowego identyfikatora

  3. Wybierz typ "Aplikacja":

    Wybierz typ

  4. Wprowadź identyfikator pakietu i opis nowego identyfikatora aplikacji:

    Rejestrowanie identyfikatora aplikacji

  5. Włącz możliwość Push Notifications.

    Aktywowana funkcja powiadomień push

  6. Kliknij przycisk , Register aby zapisać nowy identyfikator aplikacji.

Następnym krokiem jest utworzenie profilu aprowizacji dla nowego identyfikatora aplikacji:

  1. Przejdź do sekcji Profile w witrynie Dla deweloperów firmy Apple :

    Sekcja Profile

  2. Dodaj nowy profil tworzenia aplikacji dla systemu iOS:

    Zarejestruj nowy profil wdrażania

  3. Wybierz właśnie utworzony identyfikator aplikacji:

    Wybieranie identyfikatora aplikacji

  4. Wybierz wszystkie certyfikaty uwzględnione w tym profilu prowizji (nowy certyfikat musi być utworzony, jeśli żaden nie został jeszcze utworzony):

    Wybieranie certyfikatów

  5. Wybierz wszystkie urządzenia uwzględnione w tym profilu aprowizacji (aplikację można zainstalować tylko na tych urządzeniach).

    Wybieranie urządzeń

  6. Wybierz nazwę profilu aprowizacji i przejrzyj go:

    Przegląd i nazwa

  7. Wygeneruj i pobierz nowy profil aprowizacji.

    Stworzyć

  8. Otwórz pobrany plik profilu aprowizacji w programie Xcode (klikając go dwukrotnie w programie Finder), aby zainstalować go w systemie.

  9. Skonfiguruj projekt tak, aby używał nowo utworzonego profilu aprowizacji, ustawiając CodesignProvision właściwość na nazwę profilu aprowizacji z kroku 6:

    <PropertyGroup>
    <CodesignProvision>User Notifications Profile</CodesignProvision>
</PropertyGroup>

Uwaga / Notatka

Jeśli aplikacja ma jakiekolwiek rozszerzenia aplikacji obsługujące powiadomienia, ten proces musi zostać powtórzony dla każdego odpowiedniego projektu rozszerzenia aplikacji — każdy z nich musi mieć własny identyfikator aplikacji i profil aprowizacji.

Rejestrowanie w celu otrzymywania powiadomień zdalnych

Jeśli aplikacja będzie wysyłać i odbierać powiadomienia zdalne, nadal będzie musiała wykonać Rejestrację Tokenu przy użyciu istniejącego interfejsu API UIApplication. Ta rejestracja wymaga, aby urządzenie miało połączenie sieciowe na żywo w celu uzyskania dostępu do sieci APNs, co spowoduje wygenerowanie niezbędnego tokenu, który zostanie wysłany do aplikacji. Aplikacja musi następnie przekazać ten token do aplikacji po stronie serwera dewelopera, aby zarejestrować się w celu otrzymywania powiadomień zdalnych:

Omówienie rejestracji tokenu

Użyj następującego kodu, aby zainicjować wymaganą rejestrację:

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

Token, który zostanie wysłany do aplikacji po stronie serwera dewelopera, będzie musiał zostać uwzględniony jako część ładunku powiadomień wysyłanego z serwera do usługi APNs podczas wysyłania powiadomienia zdalnego:

Token dołączony jako część treści powiadomień

Token działa jako klucz, który łączy ze sobą powiadomienie i aplikację używaną do otwierania lub odpowiadania na powiadomienie.

Aby uzyskać więcej informacji, zobacz dokumentację dotyczącą powiadomień użytkowników firmy Apple.

Dostarczanie powiadomień

Po pełnej rejestracji aplikacji oraz po tym, jak użytkownik zażąda i udzieli wszystkich wymaganych uprawnień, aplikacja jest teraz gotowa do wysyłania i odbierania powiadomień.

Dostarczanie zawartości powiadomień

Wszystkie powiadomienia zawierają zarówno tytuł, jak i podtytuł, który będzie zawsze wyświetlany z treścią zawartości powiadomienia. Istnieje również możliwość dodawania załączników multimedialnych do zawartości powiadomienia.

Aby utworzyć zawartość powiadomienia lokalnego, użyj następującego kodu:

var content = new UNMutableNotificationContent();
content.Title = "Notification Title";
content.Subtitle = "Notification Subtitle";
content.Body = "This is the message body of the notification.";
content.Badge = 1;

W przypadku powiadomień zdalnych proces jest podobny:

{
    "aps":{
        "alert":{
            "title":"Notification Title",
            "subtitle":"Notification Subtitle",
            "body":"This is the message body of the notification."
        },
        "badge":1
    }
}

Planowanie wysyłania powiadomienia

Po utworzeniu zawartości powiadomienia aplikacja musi zaplanować, kiedy powiadomienie zostanie wyświetlone użytkownikowi, ustawiając wyzwalacz. Istnieją cztery różne typy wyzwalaczy:

  • Powiadomienie wypychane — używane wyłącznie z powiadomieniami zdalnymi i jest wyzwalane, gdy usługa APNs wysyła pakiet powiadomień do aplikacji uruchomionej na urządzeniu.
  • Przedział czasu — umożliwia zaplanowanie powiadomienia lokalnego z przedziału czasu rozpoczynającego się od teraz i kończącego pewien przyszły punkt. Przykład: 
    var trigger = UNTimeIntervalNotificationTrigger.CreateTrigger (5, false);
  • Data kalendarza — umożliwia zaplanowanie powiadomień lokalnych dla określonej daty i godziny.
  • Na podstawie lokalizacji — umożliwia zaplanowanie powiadomień lokalnych, gdy urządzenie wchodzi do określonej lokalizacji geograficznej lub opuszcza je lub znajduje się w danej odległości od wszystkich sygnałów nawigacyjnych Bluetooth.

Gdy powiadomienie lokalne jest gotowe, aplikacja musi wywołać polecenie UNUserNotificationCenter.AddNotificationRequest zaplanować jego wyświetlanie użytkownikowi. W przypadku powiadomień zdalnych aplikacja po stronie serwera wysyła ładunek powiadomień do sieci APNs, która następnie wysyła pakiet na urządzenie użytkownika.

Przykładowe powiadomienie lokalne, łączące wszystkie elementy, może wyglądać następująco:

using UserNotifications;

public void SendLocalNotification ()
{
    var content = new UNMutableNotificationContent ();
    content.Title = "Notification Title";
    content.Subtitle = "Notification Subtitle";
    content.Body = "This is the message body of the notification.";
    content.Badge = 1;

    var trigger =  UNTimeIntervalNotificationTrigger.CreateTrigger (5, false);

    var requestId = "sampleRequest";
    var request = UNNotificationRequest.FromIdentifier (requestId, content, trigger);

    UNUserNotificationCenter.Current.AddNotificationRequest (request, (err) => {
        if (err is not null) {
            // Do something with error
        }
    });
}

Wyzwalanie powiadomienia zdalnego

Istnieje wiele sposobów wyzwalania powiadomienia zdalnego podczas programowania na potrzeby testowania:

Po wydaniu aplikacji powiadomienia zdalne są zwykle wyzwalane z aplikacji po stronie serwera.

Obsługa powiadomień aplikacji pierwszego planu

Aplikacja może obsługiwać powiadomienia inaczej, gdy znajduje się na pierwszym planie, a powiadomienie jest wyzwalane. Dostarczając metodę UNUserNotificationCenterDelegate i wdrażając metodę WillPresentNotification , aplikacja może przejąć odpowiedzialność za wyświetlanie powiadomienia. Przykład:

using System;
using UserNotifications;

public class UserNotificationCenterDelegate : UNUserNotificationCenterDelegate
{
    #region Constructors
    public UserNotificationCenterDelegate ()
    {
    }
    #endregion

    #region Override Methods
    public override void WillPresentNotification (UNUserNotificationCenter center, UNNotification notification, Action<UNNotificationPresentationOptions> completionHandler)
    {
        // Do something with the notification
        Console.WriteLine ("Active notification: {0}", notification);

        // Tell system to display the notification anyway or use
        // `None` to say we have handled the display locally.
        completionHandler (UNNotificationPresentationOptions.Alert);
    }
    #endregion
}

Ten kod po prostu zapisuje zawartość powiadomienia UNNotification w danych wyjściowych aplikacji i prosi system o wyświetlenie standardowego alertu dla powiadomienia.

Jeśli aplikacja chciała wyświetlić samo powiadomienie, gdy znajdowało się na pierwszym planie, a nie używać domyślnych ustawień systemowych, przekaż wartość None do procedury obsługi uzupełniania. Przykład:

completionHandler (UNNotificationPresentationOptions.None);

Po umieszczeniu tego kodu otwórz plik AppDelegate.cs do edycji i zmień metodę FinishedLaunching, aby wyglądała następująco:

public override bool FinishedLaunching (UIApplication application, NSDictionary launchOptions)
{
    // Request notification permissions from the user
    UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert, (approved, err) => {
        // Handle approval
    });

    // Watch for notifications while the app is active
    UNUserNotificationCenter.Current.Delegate = new UserNotificationCenterDelegate ();

    return true;
}

Ten kod dołącza niestandardowy UNUserNotificationCenterDelegate do bieżącego UNUserNotificationCenter, aby aplikacja mogła obsługiwać powiadomienia, gdy jest aktywna i na pierwszym planie.

Zarządzanie powiadomieniami

Zarządzanie powiadomieniami zapewnia dostęp do powiadomień oczekujących i dostarczanych oraz dodaje możliwość usuwania, aktualizowania lub podwyższania poziomu tych powiadomień.

Ważną częścią zarządzania powiadomieniami jest identyfikator żądania , który został przypisany do powiadomienia podczas jego tworzenia i planowania w systemie. W przypadku powiadomień zdalnych jest to przypisywane za pośrednictwem apps-collapse-id pola w nagłówku żądania HTTP.

Identyfikator żądania służy do wybierania powiadomienia, na podstawie którego aplikacja chce wykonywać zarządzanie powiadomieniami.

Usuwanie powiadomień

Aby usunąć oczekujące powiadomienie z systemu, użyj następującego kodu:

var requests = new string [] { "sampleRequest" };
UNUserNotificationCenter.Current.RemovePendingNotificationRequests (requests);

Aby usunąć już dostarczone powiadomienie, użyj następującego kodu:

var requests = new string [] { "sampleRequest" };
UNUserNotificationCenter.Current.RemoveDeliveredNotifications (requests);

Aktualizowanie istniejącego powiadomienia

Aby zaktualizować istniejące powiadomienie, po prostu utwórz nowe powiadomienie z zmodyfikowanymi żądanymi parametrami (np. nowy czas wyzwalacza) i dodaj je do systemu przy użyciu tego samego identyfikatora żądania, co powiadomienie, które należy zmodyfikować. Przykład:

using UserNotifications;

// Rebuild notification
var content = new UNMutableNotificationContent ();
content.Title = "Notification Title";
content.Subtitle = "Notification Subtitle";
content.Body = "This is the message body of the notification.";
content.Badge = 1;

// New trigger time
var trigger = UNTimeIntervalNotificationTrigger.CreateTrigger (10, false);

// Id of notification to be updated
var requestId = "sampleRequest";
var request = UNNotificationRequest.FromIdentifier (requestId, content, trigger);

// Add to system to modify existing Notification
UNUserNotificationCenter.Current.AddNotificationRequest (request, (err) => {
    if (err != null) {
        // Do something with error...
    }
});

W przypadku już dostarczonych powiadomień istniejące powiadomienie zostanie zaktualizowane i awansowane do górnej części listy na ekranach Narzędzia główne i Blokada oraz w Centrum powiadomień, jeśli zostało ono już odczytane przez użytkownika.

Praca z akcjami powiadomień

Powiadomienia dostarczane do użytkownika nie są statyczne i zapewniają kilka sposobów interakcji z nimi (od wbudowanych do akcji niestandardowych).

Istnieją trzy typy akcji, na które aplikacja może reagować:

  • Akcja domyślna — to jest, gdy użytkownik stuknie w powiadomienie, aby otworzyć aplikację i wyświetlić szczegóły danego powiadomienia.
  • Akcje niestandardowe — zapewniają one szybki sposób na wykonanie zadania niestandardowego bezpośrednio z powiadomienia bez konieczności uruchamiania aplikacji. Można je przedstawić jako listę przycisków z dostosowywalnymi tytułami lub polem wprowadzania tekstu, które może być uruchamiane w tle (w przypadku gdy aplikacja otrzymuje niewielką ilość czasu na wypełnienie żądania) lub pierwszego planu (gdzie aplikacja jest uruchamiana na pierwszym planie w celu spełnienia żądania).
  • Akcja odrzucania — ta akcja jest wysyłana do aplikacji, gdy użytkownik odrzuci podane powiadomienie.

Tworzenie akcji niestandardowych

Aby utworzyć i zarejestrować akcję niestandardową w systemie, użyj następującego kodu:

// Create action
var actionId = "reply";
var title = "Reply";
var action = UNNotificationAction.FromIdentifier (actionId, title, UNNotificationActionOptions.None);

// Create category
var categoryId = "message";
var actions = new UNNotificationAction [] { action };
var intentIds = new string [] { };
var categoryOptions = new UNNotificationCategoryOptions [] { };
var category = UNNotificationCategory.FromIdentifier (categoryId, actions, intentIds, UNNotificationCategoryOptions.None);
    
// Register category
var categories = new UNNotificationCategory [] { category };
UNUserNotificationCenter.Current.SetNotificationCategories (new NSSet<UNNotificationCategory>(categories));

Podczas tworzenia nowej funkcji UNNotificationAction jest przypisany unikatowy identyfikator i tytuł, który będzie wyświetlany na przycisku. Domyślnie akcja zostanie utworzona jako akcja w tle, jednak można podać opcje w celu dostosowania zachowania akcji (na przykład ustawienie jej jako akcji pierwszego planu).

Każda utworzona akcja musi być skojarzona z kategorią. Podczas tworzenia nowej akcji UNNotificationCategory jest przypisany unikatowy identyfikator, lista akcji, które może wykonać, lista identyfikatorów intencji w celu dostarczenia dodatkowych informacji o intencji akcji w kategorii oraz niektóre opcje kontrolowania zachowania kategorii.

Na koniec wszystkie kategorie są rejestrowane w systemie przy użyciu metody SetNotificationCategories .

Prezentowanie akcji niestandardowych

Po utworzeniu i zarejestrowaniu zestawu akcji niestandardowych i kategorii w systemie można je przedstawić za pomocą powiadomień lokalnych lub zdalnych.

W przypadku powiadomień zdalnych ustaw element category w ładunku powiadomień zdalnych zgodny z jedną z kategorii utworzonych powyżej. Przykład:

{
    aps: {
        alert:"Hello world!",
        category:"message"
    }
}

W przypadku powiadomień lokalnych ustaw właściwość CategoryIdentifier obiektu UNMutableNotificationContent. Przykład:

var content = new UNMutableNotificationContent ();
content.Title = "Notification Title";
content.Subtitle = "Notification Subtitle";
content.Body = "This is the message body of the notification.";
content.Badge = 1;
content.CategoryIdentifier = "message";

Ponownie ten identyfikator musi być zgodny z jedną z kategorii utworzonych powyżej.

Obsługa akcji odrzucania

Jak wspomniano powyżej, akcja odrzucenia może zostać wysłana do aplikacji, gdy użytkownik odrzuci powiadomienie. Ponieważ nie jest to akcja standardowa, należy ustawić opcję podczas tworzenia kategorii. Przykład:

var categoryId = "message";
var actions = new UNNotificationAction [] { action };
var intentIds = new string [] { };
var categoryOptions = new UNNotificationCategoryOptions [] { };
var category = UNNotificationCategory.FromIdentifier (categoryId, actions, intentIds, UNNotificationCategoryOptions.CustomDismissAction);

Obsługa odpowiedzi akcji

Gdy użytkownik wchodzi w interakcję z akcjami niestandardowymi i utworzonymi powyżej kategoriami, aplikacja musi spełnić żądane zadanie. W tym celu należy podaniu metody [UNUserNotificationCenterDelegate][unnsernotificationcenterdelegate] i zaimplementowaniu metody DidReceiveNotificationResponse . Przykład:

using System;
using UserNotifications;

namespace MonkeyNotification
{
    public class UserNotificationCenterDelegate : UNUserNotificationCenterDelegate
    {
        ...

        #region Override methods
        public override void DidReceiveNotificationResponse (UNUserNotificationCenter center, UNNotificationResponse response, Action completionHandler)
        {
            // Take action based on Action ID
            switch (response.ActionIdentifier) {
            case "reply":
                // Do something
                break;
            default:
                // Take action based on identifier
                if (response.IsDefaultAction) {
                    // Handle default action...
                } else if (response.IsDismissAction) {
                    // Handle dismiss action
                }
                break;
            }

            // Inform caller it has been handled
            completionHandler();
        }
        #endregion
    }
}

Przekazana klasa UNNotificationResponse ma właściwość , która może być akcją domyślną ActionIdentifier lub akcją odrzucania. Użyj response.Notification.Request.Identifier polecenia , aby przetestować dowolne akcje niestandardowe.

Właściwość UserText przechowuje wartość dowolnego tekstu wejściowego użytkownika. Właściwość Notification przechowuje oryginalne powiadomienie, które zawiera żądanie z wyzwalaczem i treścią powiadomienia. Aplikacja może zdecydować, czy jest to lokalne lub zdalne powiadomienie na podstawie typu wyzwalacza.

Praca z rozszerzeniami usługi powiadomień

Podczas pracy z powiadomieniami zdalnymi rozszerzenie usługi powiadomień zapewnia sposób włączania kompleksowego szyfrowania wewnątrz ładunku powiadomień. Rozszerzenie usługi powiadomień to rozszerzenie interfejsu użytkownika, które działa w tle z głównym celem rozszerzania lub zastępowania widocznej zawartości powiadomienia, zanim zostanie wyświetlone użytkownikowi.

Omówienie rozszerzenia usługi powiadomień

Rozszerzenia usługi powiadomień mają być uruchamiane szybko i mają tylko krótki czas na wykonanie przez system. W przypadku, gdy rozszerzenie usługi powiadomień nie może ukończyć zadania w przydzielonym czasie, zostanie wywołana metoda rezerwowa. Jeśli powrót nie powiedzie się, oryginalna zawartość powiadomienia zostanie wyświetlona użytkownikowi.

Niektóre potencjalne zastosowania rozszerzeń usługi powiadomień obejmują:

  • Zapewnienie kompleksowego szyfrowania zawartości powiadomień zdalnych.
  • Dodawanie załączników do powiadomień zdalnych w celu ich wzbogacania.

Implementowanie rozszerzenia usługi powiadomień

Aby zaimplementować rozszerzenie usługi powiadomień w aplikacji, wykonaj następujące czynności:

  1. Utwórz nowy folder dla projektu rozszerzenia obok folderu głównego projektu. W poniższych instrukcjach założono, że nowy folder ma nazwę MyNotificationServiceExtension.

  2. Otwórz terminal i wykonaj następujące polecenie:

    dotnet new ios-notification-service-extension

  3. Otwórz plik projektu głównego i dodaj:

    <ItemGroup>
    <ProjectReference Include="..\MyNotificationServiceExtension\MyNotificationServiceExtension.csproj">
        <IsAppExtension>true</IsAppExtension>
    </ProjectReference>
</ItemGroup>

  4. Teraz skompiluj główny projekt, a projekt rozszerzenia zostanie również skompilowany i uwzględniony w końcowym pakiecie aplikacji.

Ważne

Ze względu na zmiany w sposobie obsługi interakcji między komputerem Mac a dowolnymi podłączonymi urządzeniami, obecnie nie można debugować rozszerzenia aplikacji za pomocą debugera. Zobacz również https://github.com/xamarin/xamarin-macios/issues/19484 , aby uzyskać więcej informacji datowanych up-to.

Oznacza to, że najbardziej niezawodnym sposobem debugowania rozszerzenia aplikacji jest niestety dodanie instrukcji Console.WriteLine do kodu, a następnie wyszukanie tych instrukcji w dzienniku urządzenia.

Ważne

Identyfikator pakietu (ApplicationId) rozszerzenia usługi musi być poprzedzony identyfikatorem pakietu głównej aplikacji. Jeśli na przykład główna aplikacja miała identyfikator com.xamarin.monkeynotifypakietu , rozszerzenie usługi powinno mieć identyfikator com.xamarin.monkeynotify.monkeynotifyserviceextensionpakietu .

Istnieje jedna główna klasa w rozszerzeniu usługi powiadomień, która będzie musiała zostać zmodyfikowana, aby zapewnić wymaganą funkcjonalność. Przykład:

using System;

using Foundation;
using UIKit;
using UserNotifications;

namespace MonkeyChatServiceExtension
{
    [Register ("NotificationService")]
    public class NotificationService : UNNotificationServiceExtension
    {
        protected NotificationServiceClass (NativeHandle handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic,
            // it only exists so that the OS can instantiate an instance of this class.
        }

        public override void DidReceiveNotificationRequest (UNNotificationRequest request, Action<UNNotificationContent> contentHandler)
        {
            // Called when the OS receives a notification that can be muteated

            // Create a mutable copy of the notification
            var mutableRequest = (UNMutableNotificationContent) request.Content.MutableCopy ();

            // Modify the notification content here...
            mutableRequest.Title = $"[modified] {mutableRequest.Title}";

            // Call the contentHandler callback to let the OS know about the modified notification.
            contentHandler (mutableRequest);
        }

        public override void TimeWillExpire ()
        {
            // Called just before the extension will be terminated by the system.
            // Use this as an opportunity to deliver your "best attempt" at modified content, otherwise the original push payload will be used.
        }
    }
}

Pierwszej metodzie DidReceiveNotificationRequest dostanie przekazane identyfikator powiadomienia, a także zawartość powiadomienia za pośrednictwem obiektu request. Przekazany element contentHandler należy wywołać, aby przedstawić użytkownikowi powiadomienie.

Druga metoda , TimeWillExpire, zostanie wywołana tuż przed upływem czasu, aby rozszerzenie usługi powiadomień przetworzyło żądanie. Jeśli rozszerzenie usługi powiadomień nie wykona wywołania contentHandler w przydzielonym czasie, oryginalna zawartość zostanie wyświetlona użytkownikowi.

Wyzwalanie rozszerzenia usługi powiadomień

Za pomocą rozszerzenia usługi powiadomień utworzonego i dostarczonego z aplikacją można go wyzwolić, modyfikując ładunek powiadomień zdalnych wysyłany do urządzenia. Przykład:

{
    aps : {
        alert : "New Message Available",
        mutable-content: 1
    },
    encrypted-content : "#theencryptedcontent"
}

Nowy mutable-content klucz określa, że rozszerzenie usługi powiadomień musi zostać uruchomione, aby zaktualizować zawartość powiadomienia zdalnego. Klucz encrypted-content przechowuje zaszyfrowane dane, które rozszerzenie usługi powiadomień może odszyfrować przed przedstawieniem użytkownikowi.

Spójrz na następujące przykładowe rozszerzenie usługi powiadomień:

using UserNotification;

namespace myApp {
    public class NotificationService : UNNotificationServiceExtension {
    
        public override void DidReceiveNotificationRequest(UNNotificationRequest request, contentHandler) {
            // Decrypt payload
            var decryptedBody = Decrypt(Request.Content.UserInfo["encrypted-content"]);
            
            // Modify notification body
            var newContent = new UNMutableNotificationContent();
            newContent.Body = decryptedBody;
            
            // Present to user
            contentHandler(newContent);
        }
        
        public override void TimeWillExpire() {
            // Handle out-of-time fallback event
        }
        
    }
}

Ten kod odszyfrowuje zaszyfrowaną zawartość z encrypted-content klucza, tworzy nową właściwość UNMutableNotificationContent, ustawia właściwość Body na odszyfrowaną zawartość i używa elementu , contentHandler aby przedstawić użytkownikowi powiadomienie.

Zobacz także