Freigeben über

Erweiterte Benutzerbenachrichtigungen in Xamarin.iOS

  • Artikel

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

Informationen zu Benutzerbenachrichtigungen

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

Darüber hinaus kann die App oder Erweiterung sowohl lokale als auch Remotebenachrichtigungen empfangen (und potenziell ändern), während 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 übermitteln kann:

  • Visuelle Benachrichtigungen – Wenn die Benachrichtigung von oben auf dem Bildschirm als Banner nach unten rollt.
  • Sound und Vibrationen – Kann einer Benachrichtigung zugeordnet werden.
  • App-Symbol badging – Hier zeigt das Symbol der App ein Signal an, das anzeigt, dass neuer Inhalt verfügbar ist, z. B. die Anzahl der ungelesenen E-Mail-Nachrichten.

Je nach aktuellem Kontext des Benutzers gibt es außerdem unterschiedliche Möglichkeiten, wie eine Benachrichtigung angezeigt wird:

  • 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 Benachrichtigungscenter öffnen und dort verfügbare, wartende 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 App-Inhalts 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 lokal auf dem Gerät des Benutzers sind.
  • Sie können so konfiguriert werden, dass zeit- oder standortbasierte Trigger verwendet 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:

  • Kalenderbenachrichtigungen
  • Erinnerungsbenachrichtigungen
  • Ortsfähiger Trigger

Weitere Informationen finden Sie in der Dokumentation zur Lokalen und Remotebenachrichtigungsprogrammierung 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 optimale Ü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:

  • Nachrichtenbenachrichtigungen
  • Sportupdates
  • Chatnachrichten

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

  • Benutzerseite – Diese werden dem Benutzer auf dem Gerät angezeigt.
  • Automatische Updates – Diese bieten einen Mechanismus zum Aktualisieren des Inhalts einer iOS-App im Hintergrund. Wenn ein automatisches Update empfangen wird, kann die App auf die Remoteserver zugreifen, um die neuesten Inhalte abzurufen.

Weitere Informationen finden Sie in der Dokumentation zur Lokalen und Remotebenachrichtigungsprogrammierung von Apple.

Informationen zur vorhandenen Benachrichtigungs-API

Vor iOS 10 würde 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).

Es gibt mehrere Probleme, die beim Arbeiten mit der vorhandenen Benachrichtigungs-API auftreten können:

  • Für lokale oder Remotebenachrichtigungen waren unterschiedliche Rückrufe erforderlich, die zu einer Duplizierung von Code führen könnten.
  • Die App hatte eingeschränkte Kontrolle über die Benachrichtigung, nachdem sie mit dem System geplant wurde.
  • Es gab unterschiedliche Unterstützungsebenen 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 die Featureparität mit den vorherigen Methoden enthält, die das Portieren von Code aus dem vorhandenen Framework vereinfachen.
  • Enthält einen erweiterten Satz von Inhaltsoptionen, mit dem umfassendere Benachrichtigungen an den Benutzer gesendet werden können.
  • Sowohl lokale als auch Remotebenachrichtigungen können mit demselben Code und Rückrufen behandelt werden.
  • Vereinfacht den Prozess der Behandlung von Rückrufen, die an eine App gesendet werden, wenn der Benutzer mit einer Benachrichtigung interagiert.
  • Verbesserte Verwaltung von ausstehenden und zugestellten Benachrichtigungen, einschließlich der Möglichkeit zum Entfernen oder Aktualisieren von Benachrichtigungen.
  • Fügt die Möglichkeit zur In-App-Präsentation von Benachrichtigungen hinzu.
  • Fügt die Möglichkeit hinzu, Benachrichtigungen innerhalb von 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 den verschiedenen Plattformen, die Apple unterstützt, einschließlich:

  • iOS – Vollständiger Support 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 seine Apple Watch weiterzuleiten und ermöglicht Überwachungs-Apps, lokale Benachrichtigungen direkt auf der Uhr selbst durchzuführen.
  • macOS – Vollständiger Support zum Verwalten und Planen von Benachrichtigungen.

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

Vorbereiten der Benachrichtigungsübermittlung

Bevor eine iOS-App Benachrichtigungen an den Benutzer senden kann, muss die App beim System registriert werden. Da eine Benachrichtigung eine Unterbrechung des Benutzers 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.
  • Soundbenachrichtigungen.
  • Badging des App-Symbols.

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

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

Hinweis

UNUserNotificationCenter ist nur in 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+ funktioniert, müssen Sie, wenn Sie macOS als Ziel verwenden, auch so bald wie möglich nach der Benachrichtigungsberechtigung suchen:

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 entweder als Entwicklung oder Produktion ausgeführt werden. Fehler beim Bereitstellen dieser Informationen können dazu führen, dass die App abgelehnt wird, wenn sie an den iTune App Store übermittelt wird, mit einer Benachrichtigung ähnlich der folgenden:

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

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

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

  2. Wechseln Sie zur Ansicht Quelle:

    Die Quellansicht

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

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

    Die Aps-Umgebung-Eigenschaft

  5. 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 APN für den Live-Netzwerkverbindungszugriff verfügt, wodurch das erforderliche Token generiert wird, 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:

Übersicht über die Tokenregistrierung

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 einbezogen werden, die vom Server an APNs gesendet wird, wenn eine Remotebenachrichtigung gesendet wird:

Das Token, das als Teil der Benachrichtigungsnutzlast enthalten ist

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

Weitere Informationen finden Sie in der Dokumentation zur Lokalen und Remotebenachrichtigungsprogrammierung von Apple.

Übermittlung der Benachrichtigungen

Nachdem die App vollständig registriert und die erforderlichen Berechtigungen vom Benutzer angefordert und erteilt wurden, kann die App jetzt Benachrichtigungen senden und empfangen.

Bereitstellen von Benachrichtigungsinhalten

Neu bei iOS 10 enthalten alle Benachrichtigungen sowohl einen Titel als auch einen Untertitel, der immer mit dem Textkörper des Benachrichtigungsinhalts angezeigt wird. Neu ist auch 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;

Bei Remotebenachrichtigungen ist der Prozess ähnlich:

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

Terminplanung beim Senden einer Benachrichtigung

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

  • Pushbenachrichtigung – Wird ausschließlich für Remotebenachrichtigungen verwendet und wird ausgelöst, wenn APNs ein Benachrichtigungspaket an die App sendet, die auf dem Gerät ausgeführt wird.
  • Zeitintervall – Ermöglicht es einer lokalen Benachrichtigung, ab einem Zeitintervall zu planen, mit dem jetzt beginnen und einen zukünftigen Punkt beenden. 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 es, lokale Benachrichtigungen zu planen, wenn das iOS-Gerät einen bestimmten geografischen Standort eingibt 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 dann das Paket an das Gerät des Benutzers sendet.

Wenn Sie alle Teile zusammenführen, könnte eine beispielweise lokale Benachrichtigung 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 bei iOS 10 kann eine App Benachrichtigungen anders behandeln, wenn sie sich im Vordergrund befindet und eine Benachrichtigung ausgelöst wird. Durch die Bereitstellung und UNUserNotificationCenterDelegate Implementierung der WillPresentNotification Methode kann die App die Verantwortung für die Anzeige der Benachrichtigung übernehmen. Zum 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 der UNNotification Anwendungsausgabe aus und fordert das System auf, die Standardbenachrichtigung für die Benachrichtigung anzuzeigen.

Wenn die App die Benachrichtigung selbst anzeigen wollte, als sie sich im Vordergrund befand und nicht die Systemstandardwerte verwendet, übergeben Sie None den Abschlusshandler. Beispiel:

completionHandler (UNNotificationPresentationOptions.None);

Öffnen Sie mit diesem Code die AppDelegate.cs Datei zum Bearbeiten, und ändern Sie die FinishedLaunching Methode so, dass sie wie folgt aussieht:

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 den Benutzerdefinierten UNUserNotificationCenterDelegate von oben an den aktuellen UNUserNotificationCenter Anfügen an, sodass die App Benachrichtigungen verarbeiten kann, während sie aktiv und im Vordergrund ist.

Benachrichtigungsverwaltung

Neu bei iOS 10 bietet die Benachrichtigungsverwaltung Zugriff auf ausstehende und übermittelte 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 beim Erstellen und Planen mit dem System zugewiesen wurde. Für 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 den gewünschten Parametern geändert (z. B. eine neue Triggerzeit), und fügen Sie sie dem System mit demselben Anforderungsbezeichner wie die Benachrichtigung hinzu, die geändert werden muss. 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...
    }
});

Für bereits übermittelte Benachrichtigungen wird die vorhandene Benachrichtigung aktualisiert und an den Anfang der Liste auf den Start- und Sperrbildschirmen und im Benachrichtigungscenter höhergestuft, wenn sie bereits vom Benutzer gelesen wurde.

Arbeiten mit Benachrichtigungsaktionen

In iOS 10 sind Benachrichtigungen, die an den Benutzer übermittelt werden, nicht statisch und stellen mehrere Möglichkeiten bereit, mit denen der Benutzer interagieren kann (von integrierten 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 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 Eine Liste von Schaltflächen mit anpassbaren Titeln oder einem Texteingabefeld angezeigt werden, das entweder im Hintergrund ausgeführt werden kann (wobei die App eine geringe Zeit für die Erfüllung der Anforderung erhält) oder im Vordergrund (wo die App im Vordergrund gestartet wird, um die Anforderung zu erfüllen). Benutzerdefinierte Aktionen sind sowohl für iOS als auch für watchOS verfügbar.
  • Aktion schließen – Diese Aktion wird an die App gesendet, wenn der Benutzer eine bestimmte Benachrichtigung schließt.

Erstellen benutzerdefinierter Aktionen

Verwenden Sie den folgenden Code, um eine benutzerdefinierte Aktion mit dem System zu erstellen und 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 UNNotificationActionElements wird eine eindeutige ID und der Titel zugewiesen, der auf der Schaltfläche angezeigt wird. Standardmäßig wird die Aktion als Hintergrundaktion erstellt. Optionen können jedoch bereitgestellt werden, um das Verhalten der Aktion anzupassen (z. B. festlegen, dass es sich um eine Vordergrundaktion handelt).

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

Schließlich werden alle Kategorien mit der SetNotificationCategories Methode mit dem 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 dargestellt werden.

Legen Sie für Remotebenachrichtigung eine category in der Remotebenachrichtigungsnutzlast fest, die mit einer der oben erstellten Kategorien übereinstimmt. Zum Beispiel:

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

Legen Sie für lokale Benachrichtigungen die CategoryIdentifier Eigenschaft des UNMutableNotificationContent Objekts fest. Zum 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 oben erwähnt, kann eine Verwerfenaktion an die App gesendet werden, wenn der Benutzer eine Benachrichtigung schließt. Da dies keine Standardaktion ist, muss beim Erstellen der Kategorie eine Option festgelegt werden. Zum 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. Dazu wird eine UNUserNotificationCenterDelegate Methode bereitgestellt und implementiert UserNotificationCenter . Zum 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 Schließen-Aktion sein kann. Wird response.Notification.Request.Identifier verwendet, 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 entscheiden, ob es sich um eine lokale oder Remotebenachrichtigung basierend auf dem Triggertyp handelt.

Hinweis

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

Arbeiten mit Diensterweiterungen

Wenn Sie mit Remotebenachrichtigungen arbeiten, bieten Diensterweiterungen eine Möglichkeit, die End-to-End-Verschlüsselung innerhalb der Benachrichtigungsnutzlast zu aktivieren. Diensterweiterungen sind eine Erweiterung ohne Benutzeroberfläche (verfügbar in iOS 10), die im Hintergrund mit dem Standard Zweck ausgeführt wird, den sichtbaren Inhalt einer Benachrichtigung zu erweitern oder zu ersetzen, bevor sie dem Benutzer präsentiert wird.

Übersicht über die Diensterweiterung

Diensterweiterungen sollen schnell ausgeführt werden und erhalten nur einen kurzen Zeitraum für die Ausführung durch das System. Wenn die Diensterweiterung ihre Aufgabe in der zugewiesenen Zeitspanne nicht abschließen kann, wird eine Fallbackmethode aufgerufen. Wenn der Fallback fehlschlägt, wird dem Benutzer der ursprüngliche Benachrichtigungsinhalt angezeigt.

Zu den potenziellen Verwendungsmöglichkeiten von Diensterweiterungen gehören:

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

Implementieren einer Diensterweiterung

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

  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 Sie "Neues Projekt hinzufügen">aus.

  3. Wählen Sie die Benachrichtigungsdiensterweiterungen für iOS-Erweiterungen>> aus, und klicken Sie auf die Schaltfläche "Weiter":

    Auswählen von Benachrichtigungsdiensterweiterungen

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

    Geben Sie einen Namen für die Erweiterung ein.

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

    Anpassen des Projektnamens und/oder des Projektmappennamens

Wichtig

Der Bündelbezeichner für die Diensterweiterung sollte mit dem Bundlebezeichner der Standard-App übereinstimmen, .appnameserviceextension die am Ende angefügt ist. Wenn die Standard-App z. B. einen Bündelbezeichner aufweistcom.xamarin.monkeynotify, sollte die Diensterweiterung über einen Bundlebezeichner verfügencom.xamarin.monkeynotify.monkeynotifyserviceextension. Dies sollte automatisch festgelegt werden, wenn die Erweiterung der Lösung hinzugefügt wird.

Es gibt eine Standard Klasse in der Erweiterung des Benachrichtigungsdiensts, die geändert werden muss, um die erforderliche Funktionalität bereitzustellen. Zum 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, DidReceiveNotificationRequestwird den Benachrichtigungsbezeichner sowie den Benachrichtigungsinhalt über das request Objekt übergeben. Die übergebene contentHandler Benachrichtigung muss aufgerufen werden, um dem Benutzer die Benachrichtigung zu präsentieren.

Die zweite Methode TimeWillExpire, wird kurz vor der Zeit aufgerufen, damit die Diensterweiterung die Anforderung verarbeitet. Wenn die Diensterweiterung den contentHandler zugewiesenen Zeitraum nicht aufruft, wird der ursprüngliche Inhalt dem Benutzer angezeigt.

Auslösen einer Diensterweiterung

Wenn eine Diensterweiterung erstellt und mit der App bereitgestellt wird, kann sie ausgelöst werden, indem die remotebenachrichtigungsnutzlast geändert wird, die an das Gerät gesendet wird. Zum 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 Remotebenachrichtigungsinhalt 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 eine neue UNMutableNotificationContent, legt die Body Eigenschaft auf den entschlüsselten Inhalt fest und verwendet die contentHandler Benachrichtigung für den Benutzer.

Zusammenfassung

In diesem Artikel werden alle Möglichkeiten behandelt, wie Benutzerbenachrichtigungen durch iOS 10 verbessert wurden. Es präsentierte das neue Benutzerbenachrichtigungsframework und die Verwendung in einer Xamarin.iOS-App oder App-Erweiterung.