Rozszerzone powiadomienia użytkownika w środowisku Xamarin.iOS

Nowe w systemie iOS 10 platforma powiadomień użytkownika 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.

Informacje o powiadomieniach użytkowników

Jak wspomniano powyżej, nowa struktura powiadomień użytkownika 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 z systemem iOS użytkownika.

Nowa struktura interfejsu użytkownika powiadomień użytkownika umożliwia aplikacji lub rozszerzeniu aplikacji dostosowywanie wyglądu powiadomień lokalnych i zdalnych, gdy są one prezentowane użytkownikowi.

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

• Alerty wizualne — gdzie powiadomienie jest wyświetlane w górnej części ekranu jako baner.
• Dźwięk i wibracje — może być skojarzony z powiadomieniem.
• Badging Ikona aplikacji — gdzie ikona aplikacji wyświetla wskaźnik pokazujący, że nowa zawartość jest dostępna, 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 platformy Xamarin.iOS ma dwa typy powiadomień użytkownika, które mogą wysyłać:

• 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 systemu iOS 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 planuje powiadomienie z urządzeniem użytkownika i jest wyświetlana 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ę podręcznika programowania powiadomień lokalnych i zdalnych firmy Apple.

Informacje o powiadomieniach zdalnych

Powiadomienia zdalne wysyłane przez aplikację systemu iOS 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 najlepszych starań dotyczących dostarczania powiadomień zdalnych do urządzenia użytkownika z serwerów w chmurze dewelopera.
• Gdy aplikacja otrzyma 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 systemu iOS:

• Użytkownik ma do czynienia — są one wyświetlane użytkownikowi na urządzeniu.
• Aktualizacje dyskretne — zapewniają one mechanizm aktualizowania zawartości aplikacji systemu iOS 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ę podręcznika programowania powiadomień lokalnych i zdalnych firmy Apple.

Informacje o istniejącym interfejsie API powiadomień

Przed systemem iOS 10 aplikacja systemu iOS będzie używać UIApplication do rejestrowania powiadomienia w systemie i planowania sposobu wyzwalania tego powiadomienia (według czasu lub lokalizacji).

Istnieje kilka problemów, które deweloper może napotkać podczas pracy z istniejącym interfejsem API powiadomień:

• W przypadku powiadomień lokalnych lub zdalnych wymagane były różne wywołania zwrotne, co może prowadzić do duplikowania kodu.
• Aplikacja miała ograniczoną kontrolę nad powiadomieniem po jego zaplanowaniu w systemie.
• Na wszystkich istniejących platformach firmy Apple istniały różne poziomy obsługi.

Informacje o nowej strukturze powiadomień użytkownika

W systemie iOS 10 firma Apple wprowadziła nową strukturę powiadomień użytkownika, która zastępuje istniejącą UIApplication metodę zanotowaną powyżej.

Struktura powiadomień użytkownika 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 samych powiadomień.

Nowa struktura powiadomień użytkownika 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.
• watchOS — dodaje możliwość przesyłania dalej powiadomień z sparowanego urządzenia z systemem iOS użytkownika do zegarka Apple Watch i zapewnia aplikacjom zegarka możliwość wykonywania lokalnych powiadomień bezpośrednio na zegarku.
• macOS — pełna obsługa zarządzania powiadomieniami i planowania ich.

Aby uzyskać więcej informacji, zobacz dokumentację dotyczącą struktury UserNotifications i UserNotificationsUI firmy Apple.

Przygotowywanie do dostarczania powiadomień

Aby aplikacja systemu iOS 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.
• Zszyfowanie 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):

Uwaga

UNUserNotificationCenter jest dostępny tylko w systemie iOS 10+. W związku z tym najlepszym rozwiązaniem jest sprawdzenie wersji systemu macOS przed wysłaniem żądania.

using UserNotifications;
...

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

    return true;
}

Ponieważ ten interfejs API jest ujednolicony, a także działa na komputerach Mac 10.14 lub nowszych, jeśli docelowy jest system macOS, musisz również sprawdzić uprawnienia powiadomienia tak szybko, jak to możliwe:

using UserNotifications;
...

public override void DidFinishLaunching (NSNotification notification)
{
    // Check we're at least v10.14
    if (NSProcessInfo.ProcessInfo.IsOperatingSystemAtLeastVersion (new NSOperatingSystemVersion (10, 14, 0))) {
        // Request notification permissions from the user
        UNUserNotificationCenter.Current.RequestAuthorization (UNAuthorizationOptions.Alert | UNAuthorizationOptions.Badge | UNAuthorizationOptions.Sound, (approved, err) => {
            // Handle approval
        });
    }
}

> [!NOTE]
> With MacOS apps, for the permission dialog to appear, you must sign your macOS app, even if building locally in DEBUG mode. Therefore, **Project->Options->Mac Signing->Sign the application bundle** must be checked.

Additionally, a user can always change the notification privileges for an app at any time using the **Settings** app on the device. The app should check for the user's requested notification privileges before presenting a notification using the following code:

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

Konfigurowanie środowiska powiadomień zdalnych

Nowość w systemie iOS 10 deweloper musi poinformować system operacyjny, w którym działają powiadomienia wypychane w środowisku deweloperskim lub produkcyjnym. Brak podania tych informacji może spowodować odrzucenie aplikacji po przesłaniu do sklepu iTune App Store z powiadomieniem podobnym do następującego:

Brak uprawnień do powiadomienia wypychanego — aplikacja zawiera interfejs API dla usługi powiadomień wypychanych firmy Apple, ale aps-environment brakuje uprawnień w podpisie aplikacji.

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

Visual Studio dla komputerów Mac

1. Entitlements.plist Kliknij dwukrotnie plik w okienku rozwiązania, aby otworzyć go do edycji.

2. Przejdź do widoku Źródła :

   

3. Kliknij przycisk , + aby dodać nowy klucz.

4. Wprowadź aps-environment wartość dla właściwości , pozostaw wartość Type (Typ ) String i wprowadź wartość development lub production w polu Value (Wartość):

   

5. Zapisz zmiany w pliku.

Program Visual Studio

1. Entitlements.plist Kliknij dwukrotnie plik w Eksplorator rozwiązań, aby otworzyć go do edycji.

2. Kliknij przycisk , + aby dodać nowy klucz.

3. Wprowadź aps-environment wartość dla właściwości , pozostaw wartość Type (Typ ) String i wprowadź wartość development lub production w polu Value (Wartość):

   

4. Zapisz zmiany w pliku.

Rejestrowanie na potrzeby powiadomień zdalnych

Jeśli aplikacja będzie wysyłać i odbierać powiadomienia zdalne, nadal będzie musiała przeprowadzić rejestrację tokenu przy użyciu istniejącego UIApplication interfejsu API. Ta rejestracja wymaga, aby urządzenie miało dostęp do sieci na żywo 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:

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 w ramach ładunku powiadomień wysyłanego z serwera do usługi APNs podczas wysyłania powiadomienia zdalnego:

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ę podręcznika programowania powiadomień lokalnych i zdalnych firmy Apple.

Dostarczanie powiadomień

Gdy aplikacja jest w pełni zarejestrowana i wymagane uprawnienia żądane od użytkownika i udzielona przez niego, aplikacja jest teraz gotowa do wysyłania i odbierania powiadomień.

Dostarczanie zawartości powiadomień

Nowe w systemie iOS 10 wszystkie powiadomienia zawierają zarówno tytuł, jak i podtytuł, które będą zawsze wyświetlane z treścią powiadomienia. Ponadto nowe jest możliwość dodawania załączników multimedialnych do zawartości powiadomień.

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 po wysłaniu powiadomienia

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

• Powiadomienie wypychane — jest używane wyłącznie z powiadomieniami zdalnymi i jest wyzwalane, gdy usługa APNs wysyła pakiet powiadomień do aplikacji uruchomionej na urządzeniu.
• Interwał czasu — umożliwia zaplanowanie powiadomienia lokalnego z przedziału czasu rozpoczynającego się od teraz i kończącego się pewnym przyszłym punktem. Na przykład var trigger = UNTimeIntervalNotificationTrigger.CreateTrigger (5, false);
• Data kalendarza — umożliwia zaplanowanie powiadomień lokalnych dla określonej daty i godziny.
• Lokalizacja oparta — umożliwia zaplanowanie powiadomień lokalnych, gdy urządzenie z systemem iOS wchodzi do określonej lokalizacji geograficznej lub znajduje się w pobliżu wszystkich sygnałów nawigacyjnych Bluetooth.

Gdy powiadomienie lokalne jest gotowe, aplikacja musi wywołać Add metodę UNUserNotificationCenter obiektu, aby 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.

Łączenie wszystkich elementów może wyglądać następująco:

using UserNotifications;
...

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 != null) {
        // Do something with error...
    }
});

Obsługa powiadomień aplikacji pierwszego planu

Nowość w systemie iOS 10 aplikacja może obsługiwać powiadomienia inaczej, gdy znajduje się na pierwszym planie, a powiadomienie jest wyzwalane. Udostępniając metodę UNUserNotificationCenterDelegate i wdrażając jej WillPresentNotification , aplikacja może przejąć odpowiedzialność za wyświetlanie powiadomienia. Na przykład:

using System;
using UserNotifications;

namespace MonkeyNotification
{
    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ść UNNotification elementu 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ż None do procedury obsługi uzupełniania. Przykład:

completionHandler (UNNotificationPresentationOptions.None);

Po wykonaniu AppDelegate.cs tego kodu otwórz plik do edycji i zmień FinishedLaunching metodę tak, 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 z góry do bieżącego UNUserNotificationCenter elementu, aby aplikacja mogła obsługiwać powiadomienia, gdy jest aktywna i na pierwszym planie.

Zarządzanie powiadomieniami

Nowe w systemie iOS 10 zarządzanie powiadomieniami zapewnia dostęp zarówno do oczekujących, jak i dostarczanych powiadomień oraz dodaje możliwość usuwania, aktualizowania lub podwyższania poziomu tych powiadomień.

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

Identyfikator żądania służy do wybierania powiadomienia, na podstawie którego aplikacja chce wykonać 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 podniesione 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ń

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

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

• Akcja domyślna — jest to, gdy użytkownik naciągnie powiadomienie, aby otworzyć aplikację i wyświetlić szczegóły danego powiadomienia.
• Akcje niestandardowe — zostały one dodane w systemie iOS 8 i umożliwiają użytkownikowi szybkie wykonywanie zadania niestandardowego bezpośrednio z poziomu powiadomienia bez konieczności uruchamiania aplikacji. Można je wyświetlić jako listę przycisków z dostosowywalnymi tytułami lub polem wprowadzania tekstu, które można uruchomić 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). Akcje niestandardowe są dostępne zarówno w systemie iOS, jak i w systemie watchOS.
• Akcja odrzucania — ta akcja jest wysyłana do aplikacji, gdy użytkownik odrzuci określone 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 nowego UNNotificationActionelementu zostanie 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, aby dostosować zachowanie akcji (na przykład ustawienie jej jako akcja pierwszego planu).

Każda utworzona akcja musi być skojarzona z kategorią. Podczas tworzenia nowego UNNotificationCategoryidentyfikatora jest przypisywany unikatowy identyfikator, lista akcji, które może wykonać, lista identyfikatorów intencji w celu udostępnienia 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 SetNotificationCategories metody .

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 polu Powiadomienie zdalne ustaw category wartość w ładunku powiadomienia zdalnego, który pasuje do jednej z utworzonych powyżej kategorii. Na przykład:

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

W obszarze Powiadomienia lokalne ustaw CategoryIdentifier właściwość UNMutableNotificationContent obiektu. Na 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 odrzucania może zostać wysłana do aplikacji, gdy użytkownik odrzuci powiadomienie. Ponieważ nie jest to standardowa akcja, należy ustawić opcję podczas tworzenia kategorii. Na 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 kategoriami utworzonymi powyżej, aplikacja musi spełnić żądane zadanie. W tym celu należy podaniu UNUserNotificationCenterDelegate metody i zaimplementowaniu jej UserNotificationCenter . Na 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 akcja 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 zawiera powiadomienie źródłowe, które zawiera żądanie z zawartością wyzwalacza i powiadomienia. Aplikacja może zdecydować, czy jest to powiadomienie lokalne lub zdalne na podstawie typu wyzwalacza.

Uwaga

System iOS 12 umożliwia niestandardowemu interfejsowi użytkownika powiadomień modyfikowanie przycisków akcji w czasie wykonywania. Aby uzyskać więcej informacji, zapoznaj się z dokumentacją przycisków akcji powiadomień dynamicznych .

Praca z rozszerzeniami usługi

Podczas pracy z powiadomieniami zdalnymi rozszerzenia usługi umożliwiają kompleksowe szyfrowanie wewnątrz ładunku powiadomień. Rozszerzenia usługi to rozszerzenie interfejsu użytkownika (dostępne w systemie iOS 10), które działa w tle z głównym celem rozszerzania lub zastępowania widocznej zawartości powiadomienia przed udostępnieniem użytkownikowi.

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

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

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

Implementowanie rozszerzenia usługi

Aby zaimplementować rozszerzenie usługi w aplikacji platformy Xamarin.iOS, wykonaj następujące czynności:

Visual Studio dla komputerów Mac

1. Otwórz rozwiązanie aplikacji w Visual Studio dla komputerów Mac.

2. Kliknij prawym przyciskiem myszy nazwę rozwiązania w okienku rozwiązania i wybierz polecenie Dodaj>nowy projekt.

3. Wybierz pozycję Rozszerzenia usługi powiadomień dla> systemu iOS>i kliknij przycisk Dalej:

   

4. Wprowadź nazwę rozszerzenia i kliknij przycisk Dalej:

   

5. Dostosuj nazwę projektu i/lub nazwę rozwiązania, jeśli jest to wymagane, a następnie kliknij przycisk Utwórz:

   

Program Visual Studio

1. Otwórz rozwiązanie aplikacji w programie Visual Studio.

2. Kliknij prawym przyciskiem myszy nazwę rozwiązania w Eksplorator rozwiązań i wybierz pozycję Dodaj > nowy projekt....

3. Wybierz pozycję Rozszerzenie usługi powiadomień rozszerzeń > systemu iOS w języku Visual C#>:

   

4. Wprowadź nazwę rozszerzenia i kliknij przycisk OK.

Ważne

Identyfikator pakietu rozszerzenia usługi powinien być zgodny z identyfikatorem pakietu głównej aplikacji z .appnameserviceextension dołączonym na końcu. Jeśli na przykład główna aplikacja miała identyfikator com.xamarin.monkeynotifypakietu , rozszerzenie usługi powinno mieć identyfikator com.xamarin.monkeynotify.monkeynotifyserviceextensionpakietu . Ta wartość powinna być ustawiana automatycznie po dodaniu rozszerzenia do rozwiązania.

Istnieje jedna główna klasa w rozszerzeniu usługi powiadomień, która będzie musiała zostać zmodyfikowana, aby zapewnić wymagane funkcje. Na przykład:

using System;
using Foundation;
using UIKit;
using UserNotifications;

namespace MonkeyChatServiceExtension
{
    [Register ("NotificationService")]
    public class NotificationService : UNNotificationServiceExtension
    {
        #region Computed Properties
        public Action<UNNotificationContent> ContentHandler { get; set; }
        public UNMutableNotificationContent BestAttemptContent { get; set; }
        #endregion

        #region Constructors
        protected NotificationService (IntPtr handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic.
        }
        #endregion

        #region Override Methods
        public override void DidReceiveNotificationRequest (UNNotificationRequest request, Action<UNNotificationContent> contentHandler)
        {
            ContentHandler = contentHandler;
            BestAttemptContent = (UNMutableNotificationContent)request.Content.MutableCopy ();

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

            ContentHandler (BestAttemptContent);
        }

        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.

            ContentHandler (BestAttemptContent);
        }
        #endregion
    }
}

Pierwsza metoda , DidReceiveNotificationRequestzostanie przekazana identyfikator powiadomień, a także zawartość powiadomień za pośrednictwem request obiektu . Przekazany element contentHandler musi zostać wywołany, aby przedstawić użytkownikowi powiadomienie.

Druga metoda , TimeWillExpirezostanie wywołana tuż przed upływem czasu, aby rozszerzenie usługi przetworzyło żądanie. Jeśli nie można wywołać contentHandler rozszerzenia usługi w przydzielonym czasie, oryginalna zawartość zostanie wyświetlona użytkownikowi.

Wyzwalanie rozszerzenia usługi

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

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

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

Zapoznaj się z następującym przykładem rozszerzenia usługi:

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 nowy UNMutableNotificationContentelement , ustawia Body właściwość na odszyfrowaną zawartość i używa elementu , contentHandler aby przedstawić użytkownikowi powiadomienie.

Podsumowanie

W tym artykule opisano wszystkie sposoby rozszerzania powiadomień użytkowników przez system iOS 10. Przedstawiono nową strukturę powiadomień użytkownika i sposób jej używania w aplikacji Xamarin.iOS lub rozszerzeniu aplikacji.

Linki powiązane

• Dokumentacja platformy UserNotifications
• UserNotificationsUI
• Przewodnik programowania powiadomień lokalnych i zdalnych