Erweiterte Benutzerbenachrichtigungen in Xamarin.iOS

Das Benutzerbenachrichtigungsframework ist noch nicht in iOS 10 verfügbar und ermöglicht die Übermittlung und Verarbeitung von lokalen und Remotebenachrichtigungen. Mithilfe dieses Frameworks kann eine App oder App-Erweiterung die Zustellung lokaler Benachrichtigungen planen, indem sie eine Reihe von Bedingungen wie Standort oder Tageszeit angeben.

Informationen zu Benutzerbenachrichtigungen

Wie oben erwähnt, ermöglicht das neue Benutzerbenachrichtigungsframework die Übermittlung und Verarbeitung von lokalen und Remotebenachrichtigungen. Mithilfe dieses Frameworks kann eine App oder App-Erweiterung die Zustellung lokaler Benachrichtigungen planen, indem sie eine Reihe von Bedingungen wie Standort oder Tageszeit angeben.

Darüber hinaus kann die App oder Erweiterung lokale und Remotebenachrichtigungen empfangen (und möglicherweise ändern), wenn sie an das iOS-Gerät des Benutzers übermittelt werden.

Das neue Benutzerbenachrichtigungs-Ui-Framework ermöglicht es einer App oder App-Erweiterung, die Darstellung von lokalen und Remotebenachrichtigungen anzupassen, wenn sie dem Benutzer angezeigt werden.

Dieses Framework bietet die folgenden Möglichkeiten, wie eine App Benachrichtigungen an einen Benutzer senden kann:

• Visuelle Warnungen : Die Benachrichtigung rollt von oben auf dem Bildschirm als Banner herunter.
• Sound und Vibrationen : Kann einer Benachrichtigung zugeordnet werden.
• App-Symbol badging : Das App-Symbol zeigt ein Signal an, das anzeigt, dass neue Inhalte verfügbar sind, z. B. die Anzahl der ungelesenen E-Mail-Nachrichten.

Darüber hinaus gibt es je nach aktuellem Kontext des Benutzers verschiedene Möglichkeiten, eine Benachrichtigung anzuzeigen:

• Wenn das Gerät entsperrt ist, wird die Benachrichtigung als Banner vom oberen Bildschirmrand heruntergerollt.
• Wenn das Gerät gesperrt ist, wird die Benachrichtigung auf dem Sperrbildschirm des Benutzers angezeigt.
• Wenn der Benutzer eine Benachrichtigung verpasst hat, kann er das Notification Center öffnen und dort alle verfügbaren wartenden Benachrichtigungen anzeigen.

Eine Xamarin.iOS-App verfügt über zwei Arten von Benutzerbenachrichtigungen, die gesendet werden können:

• Lokale Benachrichtigungen : Diese werden von Apps gesendet, die lokal auf dem Benutzergerät installiert sind.
• Remotebenachrichtigungen : Werden von einem Remoteserver gesendet und entweder dem Benutzer angezeigt, oder sie lösen eine Hintergrundaktualisierung des Inhalts der App aus.

Informationen zu lokalen Benachrichtigungen

Die lokalen Benachrichtigungen, die eine iOS-App senden kann, weisen die folgenden Features und Attribute auf:

• Sie werden von Apps gesendet, die sich lokal auf dem Gerät des Benutzers befinden.
• Sie können für die Verwendung zeit- oder standortbasierter Trigger konfiguriert werden.
• Die App plant die Benachrichtigung mit dem Gerät des Benutzers und wird angezeigt, wenn die Triggerbedingung erfüllt ist.
• Wenn der Benutzer mit einer Benachrichtigung interagiert, erhält die App einen Rückruf.

Einige Beispiele für lokale Benachrichtigungen sind:

• Kalenderwarnungen
• Erinnerungswarnungen
• Ortsbezogene Trigger

Weitere Informationen finden Sie in der Dokumentation zum Programmieren von Lokalen und Remotebenachrichtigungen von Apple.

Informationen zu Remotebenachrichtigungen

Die Remotebenachrichtigungen, die eine iOS-App senden kann, weisen die folgenden Features und Attribute auf:

• Die App verfügt über eine serverseitige Komponente, mit der sie kommuniziert.
• Der Apple Push Notification Service (APNs) wird verwendet, um eine bestmögliche Übermittlung von Remotebenachrichtigungen an das Gerät des Benutzers von den cloudbasierten Servern des Entwicklers zu übertragen.
• Wenn die App die Remotebenachrichtigung empfängt, wird sie dem Benutzer angezeigt.
• Wenn der Benutzer mit der Benachrichtigung interagiert, erhält die App einen Rückruf.

Einige Beispiele für Remotebenachrichtigungen sind:

• Nachrichtenwarnungen
• Sport Updates
• Chatnachrichten

Für eine iOS-App stehen zwei Arten von Remotebenachrichtigungen zur Verfügung:

• Benutzerseitig: Diese werden dem Benutzer auf dem Gerät angezeigt.
• Silent Updates: Diese bieten einen Mechanismus zum Aktualisieren des Inhalts einer iOS-App im Hintergrund. Wenn ein unbeaufsichtigtes Update empfangen wird, kann sich die App mit den Remoteservern in Verbindung setzen, um den neuesten Inhalt zu pullen.

Weitere Informationen finden Sie in der Dokumentation zum Programmieren von Lokalen und Remotebenachrichtigungen von Apple.

Informationen zur vorhandenen Benachrichtigungs-API

Vor iOS 10 wurde eine iOS-App verwendet UIApplication , um eine Benachrichtigung beim System zu registrieren und zu planen, wie diese Benachrichtigung ausgelöst werden soll (entweder nach Zeit oder Ort).

Bei der Arbeit mit der vorhandenen Benachrichtigungs-API können mehrere Probleme auftreten:

• Für lokale oder Remotebenachrichtigungen waren verschiedene Rückrufe erforderlich, die zu Duplizierungen von Code führen konnten.
• Die App hatte nur eingeschränkte Kontrolle über die Benachrichtigung, nachdem sie mit dem System geplant wurde.
• Es gab unterschiedliche Supportebenen auf allen vorhandenen Apple-Plattformen.

Informationen zum neuen Benutzerbenachrichtigungsframework

Mit iOS 10 hat Apple das neue Benutzerbenachrichtigungsframework eingeführt, das die oben erwähnte vorhandene UIApplication Methode ersetzt.

Das Benutzerbenachrichtigungsframework bietet Folgendes:

• Eine vertraute API, die featureparität mit den vorherigen Methoden enthält, die das Portieren von Code aus dem vorhandenen Framework vereinfacht.
• Enthält einen erweiterten Satz von Inhaltsoptionen, mit dem umfassendere Benachrichtigungen an den Benutzer gesendet werden können.
• Sowohl lokale Benachrichtigungen als auch Remotebenachrichtigungen können mit demselben Code und rückrufen verarbeitet werden.
• Vereinfacht die Verarbeitung von Rückrufen, die an eine App gesendet werden, wenn der Benutzer mit einer Benachrichtigung interagiert.
• Verbesserte Verwaltung von ausstehenden und übermittelten Benachrichtigungen, einschließlich der Möglichkeit, Benachrichtigungen zu entfernen oder zu aktualisieren.
• Fügt die Möglichkeit hinzu, Benachrichtigungen in der App darzustellen.
• Fügt die Möglichkeit hinzu, Benachrichtigungen in App-Erweiterungen zu planen und zu verarbeiten.
• Fügt einen neuen Erweiterungspunkt für die Benachrichtigungen selbst hinzu.

Das neue Benutzerbenachrichtigungsframework bietet eine einheitliche Benachrichtigungs-API auf mehreren Plattformen, die Apple unterstützt, einschließlich:

• iOS : Vollständige Unterstützung zum Verwalten und Planen von Benachrichtigungen.
• tvOS : Fügt die Möglichkeit hinzu, App-Symbole für lokale und Remotebenachrichtigungen zu signalieren.
• watchOS: Fügt die Möglichkeit hinzu, Benachrichtigungen vom gekoppelten iOS-Gerät des Benutzers an die Apple Watch weiterzuleiten, und gibt watch Apps die Möglichkeit, lokale Benachrichtigungen direkt auf dem watch selbst durchzuführen.
• macOS : Vollständige Unterstützung zum Verwalten und Planen von Benachrichtigungen.

Weitere Informationen finden Sie in der UserNotifications Framework-Referenz von Apple und in der Dokumentation zu UserNotificationsUI .

Vorbereiten der Benachrichtigungsübermittlung

Bevor eine iOS-App Benachrichtigungen an den Benutzer senden kann, muss die App beim System registriert sein. Da eine Benachrichtigung eine Unterbrechung für den Benutzer ist, muss eine App vor dem Senden explizit die Berechtigung anfordern.

Es gibt drei verschiedene Ebenen von Benachrichtigungsanforderungen, die der Benutzer für eine App genehmigen kann:

• Banneranzeigen.
• Soundwarnungen.
• Badging des App-Symbols.

Darüber hinaus müssen diese Genehmigungsstufen sowohl für lokale als auch für Remotebenachrichtigungen angefordert und festgelegt werden.

Die Benachrichtigungsberechtigung sollte angefordert werden, sobald die App gestartet wird, indem Sie der FinishedLaunching Methode des AppDelegate den folgenden Code hinzufügen und den gewünschten Benachrichtigungstyp (UNAuthorizationOptions) festlegen:

Hinweis

UNUserNotificationCenter ist nur ab iOS 10 verfügbar. Daher empfiehlt es sich, die macOS-Version vor dem Senden der Anforderung zu überprüfen.

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

Da diese API vereinheitlicht ist und auch auf Mac 10.14 und höher funktioniert, müssen Sie auch so schnell wie möglich nach der Benachrichtigungsberechtigung suchen, wenn Sie macOS als Ziel verwenden:

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);
});    

Konfigurieren der Remotebenachrichtigungsumgebung

Neu bei iOS 10 muss der Entwickler das Betriebssystem darüber informieren, in welcher Umgebung Pushbenachrichtigungen als Entwicklung oder Produktion ausgeführt werden. Wenn diese Informationen nicht bereitgestellt werden, kann die App abgelehnt werden, wenn sie an die iTune-App Store mit einer Benachrichtigung ähnlich der folgenden übermittelt wird:

Fehlende Pushbenachrichtigungsberechtigung: Ihre App enthält eine API für den Pushbenachrichtigungsdienst von Apple, aber die aps-environment Berechtigung fehlt in der Signatur der App.

Gehen Sie wie folgt vor, um die erforderliche Berechtigung bereitzustellen:

Visual Studio für Mac

1. Doppelklicken Sie auf die Entitlements.plist Datei im Projektmappenpad , um sie zur Bearbeitung zu öffnen.

2. Wechseln Sie zur Quellansicht :

   

3. Klicken Sie auf die + Schaltfläche, um einen neuen Schlüssel hinzuzufügen.

4. Geben Sie aps-environment für die Eigenschaft ein, lassen Sie den Typ als String ein, und geben Sie entweder development oder production für den Wert ein:

   

5. Speichern Sie die Änderungen in der Datei.

Visual Studio

1. Doppelklicken Sie auf die Entitlements.plist Datei im Projektmappen-Explorer, um sie zur Bearbeitung zu öffnen.

2. Klicken Sie auf die + Schaltfläche, um einen neuen Schlüssel hinzuzufügen.

3. Geben Sie aps-environment für die Eigenschaft ein, lassen Sie den Typ als String ein, und geben Sie entweder development oder production für den Wert ein:

   

4. Speichern Sie die Änderungen in der Datei.

Registrieren für Remotebenachrichtigungen

Wenn die App Remotebenachrichtigungen sendet und empfängt, muss sie weiterhin die Tokenregistrierung mithilfe der vorhandenen UIApplication API durchführen. Diese Registrierung erfordert, dass das Gerät über eine Live-Netzwerkverbindungszugriffs-APNs verfügt, die das erforderliche Token generieren, das an die App gesendet wird. Die App muss dieses Token dann an die serverseitige App des Entwicklers weiterleiten, um sich für Remotebenachrichtigungen zu registrieren:

Verwenden Sie den folgenden Code, um die erforderliche Registrierung zu initialisieren:

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

Das Token, das an die serverseitige App des Entwicklers gesendet wird, muss als Teil der Benachrichtigungsnutzlast enthalten sein, die beim Senden einer Remotebenachrichtigung vom Server an APNs gesendet wird:

Das Token fungiert als Schlüssel, der die Benachrichtigung und die App verbindet, die zum Öffnen oder Beantworten der Benachrichtigung verwendet wird.

Weitere Informationen finden Sie in der Dokumentation zur Programmierung lokaler und Remotebenachrichtigungen von Apple.

Zustellung von Benachrichtigungen

Da die App vollständig registriert ist und die vom Benutzer angeforderten und vom Benutzer erteilten Berechtigungen erfüllt sind, kann die App jetzt Benachrichtigungen senden und empfangen.

Bereitstellen von Benachrichtigungsinhalten

Neu in iOS 10, enthalten alle Benachrichtigungen sowohl einen Titel als auch einen Untertitel , die immer mit dem Textkörper des Benachrichtigungsinhalts angezeigt werden. Ebenfalls neu ist die Möglichkeit, dem Benachrichtigungsinhalt Medienanlagen hinzuzufügen.

Verwenden Sie den folgenden Code, um den Inhalt einer lokalen Benachrichtigung zu erstellen:

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;

Für Remotebenachrichtigungen ist der Prozess ähnlich:

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

Planen des Sendens einer Benachrichtigung

Nachdem der Inhalt der Benachrichtigung erstellt wurde, muss die App planen, wann die Benachrichtigung dem Benutzer angezeigt wird, indem sie einen Trigger festlegt. iOS 10 bietet vier verschiedene Triggertypen:

• Pushbenachrichtigung : Wird ausschließlich mit Remotebenachrichtigungen verwendet und wird ausgelöst, wenn APNs ein Benachrichtigungspaket an die auf dem Gerät ausgeführte App senden.
• Zeitintervall : Ermöglicht die Planung einer lokalen Benachrichtigung aus einem Zeitintervall, das mit jetzt beginnt und einen späteren Zeitpunkt beendet. Zum Beispiel, var trigger = UNTimeIntervalNotificationTrigger.CreateTrigger (5, false);
• Kalenderdatum : Ermöglicht die Planung lokaler Benachrichtigungen für ein bestimmtes Datum und eine bestimmte Uhrzeit.
• Standortbasiert : Ermöglicht die Planung lokaler Benachrichtigungen, wenn das iOS-Gerät einen bestimmten geografischen Standort ein- oder verlässt oder sich in einer bestimmten Nähe zu Bluetooth-Beacons befindet.

Wenn eine lokale Benachrichtigung bereit ist, muss die App die Add -Methode des UNUserNotificationCenter -Objekts aufrufen, um die Anzeige für den Benutzer zu planen. Bei Remotebenachrichtigungen sendet die serverseitige App eine Benachrichtigungsnutzlast an die APNs, die das Paket dann an das Gerät des Benutzers sendet.

Eine lokale Benachrichtigung kann wie folgt aussehen:

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...
    }
});

Behandeln von Vordergrund-App-Benachrichtigungen

Neu in iOS 10 kann eine App Benachrichtigungen anders behandeln, wenn sie sich im Vordergrund befindet und eine Benachrichtigung ausgelöst wird. Durch bereitstellen UNUserNotificationCenterDelegate und die WillPresentNotification -Methode implementieren, kann die App die Verantwortung für die Anzeige der Benachrichtigung übernehmen. Beispiel:

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

Dieser Code schreibt einfach den Inhalt von UNNotification in die Anwendungsausgabe aus und fordert das System auf, die Standardwarnung für die Benachrichtigung anzuzeigen.

Wenn die App die Benachrichtigung selbst anzeigen möchte, wenn sie sich im Vordergrund befindet, und nicht die Standardeinstellungen des Systems verwenden möchten, übergeben Sie None an den Vervollständigungshandler. Beispiel:

completionHandler (UNNotificationPresentationOptions.None);

Wenn dieser Code vorhanden ist, öffnen Sie die AppDelegate.cs Datei zur Bearbeitung, und ändern Sie die FinishedLaunching -Methode wie folgt:

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

Dieser Code fügt die benutzerdefinierte UNUserNotificationCenterDelegate von oben an die aktuelle UNUserNotificationCenter an, damit die App Benachrichtigungen verarbeiten kann, während sie aktiv und im Vordergrund ist.

Benachrichtigungsverwaltung

Neu in iOS 10, bietet die Benachrichtigungsverwaltung Zugriff auf ausstehende und bereitgestellte Benachrichtigungen und fügt die Möglichkeit hinzu, diese Benachrichtigungen zu entfernen, zu aktualisieren oder höher zu stufen.

Ein wichtiger Bestandteil der Benachrichtigungsverwaltung ist der Anforderungsbezeichner , der der Benachrichtigung zugewiesen wurde, als sie erstellt und mit dem System geplant wurde. Bei Remotebenachrichtigungen wird dies über das neue apps-collapse-id Feld im HTTP-Anforderungsheader zugewiesen.

Der Anforderungsbezeichner wird verwendet, um die Benachrichtigung auszuwählen, für die die App die Benachrichtigungsverwaltung ausführen möchte.

Entfernen von Benachrichtigungen

Verwenden Sie den folgenden Code, um eine ausstehende Benachrichtigung aus dem System zu entfernen:

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

Verwenden Sie den folgenden Code, um eine bereits übermittelte Benachrichtigung zu entfernen:

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

Aktualisieren einer vorhandenen Benachrichtigung

Um eine vorhandene Benachrichtigung zu aktualisieren, erstellen Sie einfach eine neue Benachrichtigung mit geänderten gewünschten Parametern (z. B. einer neuen Triggerzeit), und fügen Sie sie dem System mit demselben Anforderungsbezeichner wie die zu ändernde Benachrichtigung hinzu. Beispiel:

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...
    }
});

Bei bereits übermittelten Benachrichtigungen wird die vorhandene Benachrichtigung aktualisiert und an den Anfang der Liste auf den Start- und Sperrbildschirmen sowie im Info-Center heraufgestuft, wenn sie vom Benutzer bereits gelesen wurde.

Arbeiten mit Benachrichtigungsaktionen

In iOS 10 sind Benachrichtigungen, die an den Benutzer übermittelt werden, nicht statisch und bieten mehrere Möglichkeiten, wie der Benutzer mit ihnen interagieren kann (von integrierten bis hin zu benutzerdefinierten Aktionen).

Es gibt drei Arten von Aktionen, auf die eine iOS-App reagieren kann:

• Standardaktion : Dies ist der Fall, wenn der Benutzer auf eine Benachrichtigung tippt, um die App zu öffnen und die Details der angegebenen Benachrichtigung anzuzeigen.
• Benutzerdefinierte Aktionen : Diese Aktionen wurden in iOS 8 hinzugefügt und bieten dem Benutzer eine schnelle Möglichkeit, eine benutzerdefinierte Aufgabe direkt über die Benachrichtigung auszuführen, ohne die App starten zu müssen. Sie können entweder als Liste von Schaltflächen mit anpassbaren Titeln oder als Texteingabefeld angezeigt werden, das entweder im Hintergrund (wo der App eine geringe Zeit zur Erfüllung der Anforderung eingeräumt wird) oder im Vordergrund (wo die App im Vordergrund gestartet wird, um die Anforderung zu erfüllen) ausgeführt werden kann. Benutzerdefinierte Aktionen sind sowohl unter iOS als auch unter watchOS verfügbar.
• Aktion verwerfen : Diese Aktion wird an die App gesendet, wenn der Benutzer eine bestimmte Benachrichtigung verwirf.

Erstellen benutzerdefinierter Aktionen

Verwenden Sie den folgenden Code, um eine benutzerdefinierte Aktion zu erstellen und beim System zu registrieren:

// 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)); 

Beim Erstellen eines neuen UNNotificationActionwird ihm eine eindeutige ID und der Titel zugewiesen, der auf der Schaltfläche angezeigt wird. Standardmäßig wird die Aktion als Hintergrundaktion erstellt, es können jedoch Optionen bereitgestellt werden, um das Verhalten der Aktion anzupassen (z. B. als Vordergrundaktion festlegen).

Jede der erstellten Aktionen muss einer Kategorie zugeordnet werden. Beim Erstellen eines neuen UNNotificationCategorywird ihm eine eindeutige ID, eine Liste der Aktionen zugewiesen, die er ausführen kann, eine Liste der Absichts-IDs, um weitere Informationen zur Absicht der Aktionen in der Kategorie bereitzustellen, und einige Optionen zum Steuern des Verhaltens der Kategorie.

Schließlich werden alle Kategorien mithilfe SetNotificationCategories der -Methode beim System registriert.

Präsentieren von benutzerdefinierten Aktionen

Nachdem eine Reihe von benutzerdefinierten Aktionen und Kategorien erstellt und beim System registriert wurden, können sie entweder über lokale oder Remotebenachrichtigungen angezeigt werden.

Legen Sie für Remotebenachrichtigung einen in der Remotebenachrichtigungsnutzlast category fest, der einer der oben erstellten Kategorien entspricht. Beispiel:

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

Legen Sie für Lokale Benachrichtigungen die CategoryIdentifier -Eigenschaft des UNMutableNotificationContent -Objekts fest. Beispiel:

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";
...

Auch hier muss diese ID mit einer der oben erstellten Kategorien übereinstimmen.

Behandeln von Verwerfensaktionen

Wie bereits erwähnt, kann eine Verwerfensaktion an die App gesendet werden, wenn der Benutzer eine Benachrichtigung verwirf. Da es sich nicht um eine Standardaktion handelt, muss beim Erstellen der Kategorie eine Option festgelegt werden. Beispiel:

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);

Behandeln von Aktionsantworten

Wenn der Benutzer mit den oben erstellten benutzerdefinierten Aktionen und Kategorien interagiert, muss die App die angeforderte Aufgabe erfüllen. Dies erfolgt durch Bereitstellen eines UNUserNotificationCenterDelegate und Implementieren der UserNotificationCenter -Methode. Beispiel:

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

Die übergebene - UNNotificationResponse Klasse verfügt über eine ActionIdentifier -Eigenschaft, die entweder die Standardaktion oder die Verwerfen-Aktion sein kann. Verwenden Sie response.Notification.Request.Identifier , um auf benutzerdefinierte Aktionen zu testen.

Die UserText -Eigenschaft enthält den Wert jeder Benutzertexteingabe. Die Notification -Eigenschaft enthält die ursprüngliche Benachrichtigung, die die Anforderung mit dem Trigger- und Benachrichtigungsinhalt enthält. Die App kann basierend auf dem Typ des Triggers entscheiden, ob es sich um eine lokale oder Remotebenachrichtigung handelt.

Hinweis

iOS 12 ermöglicht es einer benutzerdefinierten Benachrichtigungsbenutzeroberfläche, ihre Aktionsschaltflächen zur Laufzeit zu ändern. Weitere Informationen finden Sie in der Dokumentation zu Aktionsschaltflächen für dynamische Benachrichtigungen .

Arbeiten mit Diensterweiterungen

Bei der Arbeit mit Remotebenachrichtigungen bieten Diensterweiterungen eine Möglichkeit, die End-to-End-Verschlüsselung innerhalb der Benachrichtigungsnutzlast zu aktivieren. Diensterweiterungen sind eine Nicht-Benutzeroberflächenerweiterung (verfügbar in iOS 10), die im Hintergrund ausgeführt wird, mit dem Standard Zweck, den sichtbaren Inhalt einer Benachrichtigung zu erweitern oder zu ersetzen, bevor sie dem Benutzer angezeigt wird.

Diensterweiterungen sollen schnell ausgeführt werden und haben nur eine kurze Zeit für die Ausführung durch das System. Für den Fall, dass die Diensterweiterung ihre Aufgabe in der zugewiesenen Zeit nicht abschließen kann, wird eine Fallbackmethode aufgerufen. Wenn der Fallback fehlschlägt, wird dem Benutzer der ursprüngliche Benachrichtigungsinhalt angezeigt.

Zu den möglichen Verwendungsmöglichkeiten von Diensterweiterungen gehören:

• Bereitstellen der End-to-End-Verschlüsselung des Remotebenachrichtigungsinhalts.
• Hinzufügen von Anlagen zu Remotebenachrichtigungen, um sie anzureichern.

Implementieren einer Diensterweiterung

Gehen Sie wie folgt vor, um eine Diensterweiterung in einer Xamarin.iOS-App zu implementieren:

Visual Studio für Mac

1. Öffnen Sie die App-Lösung in Visual Studio für Mac.

2. Klicken Sie mit der rechten Maustaste auf den Projektmappennamen im Projektmappenpad, und wählen SieNeues Projekt hinzufügen> aus.

3. Wählen Sie iOS-Erweiterungen>>Notification Service-Erweiterungen aus, und klicken Sie auf die Schaltfläche Weiter:

   

4. Geben Sie einen Namen für die Erweiterung ein, und klicken Sie auf die Schaltfläche Weiter :

   

5. Passen Sie bei Bedarf den Projektnamen und/oder projektmappennamen an, und klicken Sie auf die Schaltfläche Erstellen :

   

Visual Studio

1. Öffnen Sie die Lösung der App in Visual Studio.

2. Klicken Sie mit der rechten Maustaste auf den Projektmappennamen im Projektmappen-Explorer, und wählen Sie Neues Projekt hinzufügen>... aus.

3. Wählen Sie Visual C#- > iOS-Erweiterungen > notification Service-Erweiterung aus:

   

4. Geben Sie einen Namen für die Erweiterung ein, und klicken Sie auf die Schaltfläche OK .

Wichtig

Der Bundle-Bezeichner für die Diensterweiterung sollte mit dem Bundle-Bezeichner der Standard-App mit .appnameserviceextension dem an das Ende angefügten übereinstimmen. Wenn die Standard-App beispielsweise über einen Bundle-Bezeichner von com.xamarin.monkeynotifyverfügt, sollte die Diensterweiterung den Bundle-Bezeichner aufweisencom.xamarin.monkeynotify.monkeynotifyserviceextension. Dies sollte automatisch festgelegt werden, wenn die Erweiterung der Lösung hinzugefügt wird.

Es gibt eine Standard Klasse in der Notification Service-Erweiterung, die geändert werden muss, um die erforderliche Funktionalität bereitzustellen. Beispiel:

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

Die erste Methode, DidReceiveNotificationRequest, wird sowohl der Benachrichtigungsbezeichner als auch der Benachrichtigungsinhalt über das request -Objekt übergeben. Das übergebene contentHandler muss aufgerufen werden, um dem Benutzer die Benachrichtigung anzuzeigen.

Die zweite Methode, , wird aufgerufen, TimeWillExpirebevor die Zeit für die Diensterweiterung zur Verarbeitung der Anforderung ausläuft. Wenn die Diensterweiterung in der contentHandler zugewiesenen Zeit nicht aufruft, wird dem Benutzer der ursprüngliche Inhalt angezeigt.

Auslösen einer Diensterweiterung

Wenn eine Diensterweiterung erstellt und mit der App bereitgestellt wird, kann sie ausgelöst werden, indem die an das Gerät gesendete Remotebenachrichtigungsnutzlast geändert wird. Beispiel:

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

Der neue mutable-content Schlüssel gibt an, dass die Diensterweiterung gestartet werden muss, um den Inhalt der Remotebenachrichtigung zu aktualisieren. Der encrypted-content Schlüssel enthält die verschlüsselten Daten, die die Diensterweiterung entschlüsseln kann, bevor sie dem Benutzer präsentiert wird.

Sehen Sie sich das folgende Beispiel für die Diensterweiterung an:

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

Dieser Code entschlüsselt den verschlüsselten Inhalt aus dem encrypted-content Schlüssel, erstellt einen neuen UNMutableNotificationContent, legt die Body Eigenschaft auf den entschlüsselten Inhalt fest und verwendet den contentHandler , um die Benachrichtigung dem Benutzer anzuzeigen.

Zusammenfassung

In diesem Artikel wurden alle Möglichkeiten behandelt, wie benutzerbenachrichtigungen durch iOS 10 verbessert wurden. Es wurde das neue Benutzerbenachrichtigungsframework und die Verwendung in einer Xamarin.iOS-App oder App-Erweiterung vorgestellt.

Ähnliche Themen

• Beispiele für iOS 10
• Referenz zum UserNotifications-Framework
• UserNotificationsUI
• Programmierhandbuch für lokale und Remotebenachrichtigungen