Benutzerbenachrichtigungen

Das Benutzerbenachrichtigungsframework ermöglicht 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 Gerät des Benutzers übermittelt werden.

Das 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 Warnungen: Wenn die Benachrichtigung als Banner von oben auf dem Bildschirm herunterrollt.
• Sound und Vibrationen: kann einer Benachrichtigung zugeordnet werden.
• App-Symbol-Badge: Wenn das App-Symbol ein Badge zeigt, das darauf hinweist, 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 App kann zwei Arten von Benutzerbenachrichtigungen senden:

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

Informationen zu lokalen Benachrichtigungen

Die lokalen Benachrichtigungen, die eine 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 terminiert die Benachrichtigung mit dem Gerät des Benutzers, und sie wird angezeigt, wenn die Auslösebedingung 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.
• Erinnerungswarnungen.
• Ortsfähiger Auslöser.

Weitere Informationen finden Sie in der Dokumentation zu Apple-Benutzerbenachrichtigungen .

Informationen zu Remotebenachrichtigungen

Die Remotebenachrichtigungen, die eine 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 Lieferung nach bestem Bemühen von Remotebenachrichtigungen an das Gerät des Benutzers von den cloudbasierten Servern des Entwicklers zu ermöglichen.
• 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 App stehen zwei Arten von Remotebenachrichtigungen zur Verfügung:

• Benutzeransicht: Diese Elemente werden dem Benutzer auf dem Gerät angezeigt.
• Stille Updates: Diese bieten einen Mechanismus zum Aktualisieren des Inhalts einer 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 zu Apple-Benutzerbenachrichtigungen .

UIApplication-API

Sie können UIApplication verwenden, um eine Benachrichtigung mit dem System zu registrieren und zu planen, wie diese Benachrichtigung ausgelöst werden soll – entweder nach Zeit oder Ort (dies war die ursprüngliche API, die für Benutzerbenachrichtigungen von Apple bereitgestellt wurde).

Es gibt jedoch mehrere Probleme, die beim Arbeiten mit der vorhandenen Benachrichtigung auftreten können, wie von UIApplication bereitgestellt:

• Für lokale oder Remotebenachrichtigungen sind unterschiedliche Rückrufe erforderlich, die zu einer Duplizierung von Code führen können.
• Die App hat eingeschränkte Kontrolle über die Benachrichtigung, nachdem sie mit dem System geplant wurde.
• Es gibt unterschiedliche Unterstützungsebenen auf allen vorhandenen Apple-Plattformen.

Informationen zum Benutzerbenachrichtigungsframework

Um die Benutzererfahrung mit Benachrichtigungen zu verbessern, hat Apple das Framework "Benutzerbenachrichtigungen" eingeführt, das die vorhandene oben erwähnte 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 Benutzerbenachrichtigungsframework bietet eine einheitliche Benachrichtigungs-API auf den verschiedenen 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.
• Mac Catalyst: Vollständige Unterstützung zum Verwalten und Planen von Benachrichtigungen.
• macOS: Vollständige Unterstützung zum Verwalten und Planen von Benachrichtigungen.

Weitere Informationen finden Sie in der Dokumentation zu Benutzerbenachrichtigungen und Benutzerbenachrichtigungen von Apple.

Vorbereiten der Benachrichtigungsübermittlung

Bevor eine App Benachrichtigungen an den Benutzer senden kann, muss die App beim System registriert sein, und da eine Benachrichtigung eine Unterbrechung des Benutzers darstellt, 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):

using UserNotifications;

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

    return true;
}

Führen Sie unter macOS dies in der Implementierung aus DidFinishLaunching :

using UserNotifications;

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

Darüber hinaus kann ein Benutzer die Benachrichtigungsberechtigungen für eine App jederzeit mithilfe der Einstellungs-App auf dem Gerät ändern. Die App sollte die angeforderten Benachrichtigungsberechtigungen des Benutzers überprüfen, bevor eine Benachrichtigung mithilfe des folgenden Codes präsentiert wird:

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

Aktivieren von Hintergrundbenachrichtigungen

Damit die App Hintergrundbenachrichtigungen empfängt, muss sie den Hintergrundmodus für Remotebenachrichtigungen für die App aktivieren.

Dazu fügen Sie in der Info.plist-Datei des UIBackgroundModes Projekts einen remote-notifications Eintrag zum Array hinzu, z. B.:

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

Konfigurieren der Remotebenachrichtigungsumgebung

Der Entwickler muss das Betriebssystem darüber informieren, in welcher Umgebung Pushbenachrichtigung ausgeführt wird, entweder development oder production. Fehler beim Bereitstellen dieser Informationen können dazu führen, dass die App abgelehnt wird, wenn sie an den App Store mit einer Benachrichtigung wie folgt übermittelt wird:

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. Öffnen Sie die Projektdatei im Text-Editor Ihrer Wahl.

2. Geben Sie zwei CustomEntitlements Elemente wie folgt ein:

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

   Hinweis: Wenn Sie eine andere Konfiguration Release als für die Veröffentlichung im App Store verwenden, aktualisieren Sie die Bedingungen entsprechend.

Bereitstellung

Die aps-environment Berechtigung aus dem vorherigen Abschnitt erfordert die Verwendung eines Bereitstellungsprofils mit der Push Notifications Funktion:

1. Wechseln Sie zum Abschnitt "Bezeichner" der Apple Developer-Website :

   

2. Hinzufügen eines neuen Bezeichners (Registrieren eines neuen Bezeichners):

   

3. Wählen Sie den Typ "App" aus:

   

4. Geben Sie den Bündelbezeichner und die Beschreibung für den neuen App-Bezeichner ein:

   

5. Aktivieren Sie die Push Notifications Funktion:

   

6. Klicken Sie auf die Register Schaltfläche, um den neuen App-Bezeichner zu speichern.

Der nächste Schritt besteht darin, ein Bereitstellungsprofil für den neuen App-Bezeichner zu erstellen:

1. Wechseln Sie zum Abschnitt "Profile" der Apple Developer-Website :

   

2. Hinzufügen eines neuen Profils für die iOS-App-Entwicklung:

   

3. Wählen Sie die soeben erstellte App-ID aus:

   

4. Wählen Sie alle Zertifikate aus, die in diesem Bereitstellungsprofil enthalten sind (ein neues Zertifikat muss erstellt werden, wenn noch keines erstellt wurde):

   

5. Wählen Sie alle Geräte aus, die in diesem Bereitstellungsprofil enthalten sind (die App kann nur auf diesen Geräten installiert werden).

   

6. Wählen Sie einen Namen für das Bereitstellungsprofil aus, und überprüfen Sie ihn:

   

7. Generieren und herunterladen Sie das neue Bereitstellungsprofil.

   

8. Öffnen Sie die heruntergeladene Bereitstellungsprofildatei in Xcode (indem Sie in Finder darauf doppelklicken), um sie im System zu installieren.

9. Konfigurieren Sie das Projekt so, dass das neu erstellte Bereitstellungsprofil verwendet wird, indem Sie die CodesignProvision Eigenschaft auf den Namen des Bereitstellungsprofils aus Schritt 6 festlegen:

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

Registrieren für Remotebenachrichtigungen

Wenn die App Remotebenachrichtigungen sendet und empfängt, muss die Tokenregistrierung weiterhin mithilfe der vorhandenen UIApplication-API erfolgen. Für diese Registrierung muss das Gerät über eine Live-Netzwerkverbindung für den Zugriff auf APNs verfügen, 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:

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

UIApplication.SharedApplication.RegisterForRemoteNotifications ();

Das Token, das an die serverseitige App des Entwicklers geschickt wird, muss als Teil des Benachrichtigungsinhalts eingefügt werden, der vom Server an die APNs gesendet wird, wenn eine Remotebenachrichtigung verschickt wird.

Das Token fungiert als Schlüssel, der die Benachrichtigung mit der App verbindet, die verwendet wird, um die Benachrichtigung zu öffnen oder darauf zu antworten.

Weitere Informationen finden Sie in der Dokumentation zu Apple-Benutzerbenachrichtigungen .

Benachrichtigungsübermittlung

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

Alle Benachrichtigungen enthalten sowohl einen Titel als auch einen Untertitel , der immer mit dem Textkörper des Benachrichtigungsinhalts angezeigt wird. Es besteht auch die Möglichkeit, Medienanhänge zum Benachrichtigungsinhalt 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
    }
}

Planen, wann eine Benachrichtigung gesendet wird

Nachdem der Inhalt der Benachrichtigung erstellt wurde, muss die App planen, wann die Benachrichtigung dem Benutzer angezeigt wird, indem er einen Trigger festlegt. Es gibt 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 die Planung lokaler Benachrichtigungen, wenn das Gerät einen bestimmten geografischen Standort betritt oder verlässt oder sich in der Nähe von Bluetooth-Beacons befindet.

Wenn eine lokale Benachrichtigung bereit ist, muss die App UNUserNotificationCenter.AddNotificationRequest auslösen, um die Anzeige für den Benutzer einzuplanen. 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 lokale Beispielbenachrichtigung wie folgt aussehen:

using UserNotifications;

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

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

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

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

Auslösen einer Remotebenachrichtigung

Es gibt mehrere Möglichkeiten, eine Remotebenachrichtigung während der Entwicklung für Tests auszulösen:

• Apples Pushbenachrichtigungskonsole
• Befehlszeilentools
• Andere Drittanbieterlösungen.

Sobald die App freigegeben wurde, werden Remotebenachrichtigungen in der Regel von serverseitigen Apps ausgelöst.

Benachrichtigungen von Vordergrund-Apps bearbeiten

Eine App kann Benachrichtigungen anders behandeln, wenn sie sich im Vordergrund befindet und eine Benachrichtigung ausgelöst wird. Durch die Bereitstellung eines UNUserNotificationCenterDelegate und der Implementierung der WillPresentNotification-Methode kann die App die Verantwortung für die Anzeige der Benachrichtigung übernehmen. Beispiel:

using System;
using UserNotifications;

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

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

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

Dieser Code schreibt einfach den Inhalt der UNNotification in die Ausgabe der Anwendung und fordert das System auf, die Standardwarnung 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" an 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 das benutzerdefinierte UNUserNotificationCenterDelegate von oben an das aktuelle UNUserNotificationCenter an, sodass die App Benachrichtigungen verarbeiten kann, während sie aktiv und im Vordergrund ist.

Benachrichtigungsverwaltung

Die Benachrichtigungsverwaltung bietet Zugriff auf ausstehende und zugestellte 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 apps-collapse-id Feld im HTTP-Anforderungsheader zugewiesen.

Der Anforderungsbezeichner wird verwendet, um die Benachrichtigung auszuwählen, für die die App die Benachrichtigungsverwaltung durchfü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 Auslösezeit), 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

Benachrichtigungen, die an den Benutzer übermittelt werden, sind nicht statisch und bieten mehrere Möglichkeiten, mit denen der Benutzer interagieren kann (von integrierten zu benutzerdefinierten Aktionen).

Es gibt drei Arten von Aktionen, auf die eine 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 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).
• Aktion schließen – Diese Aktion wird an die App gesendet, wenn der Benutzer eine bestimmte Benachrichtigung schließt.

Erstellen von benutzerdefinierten 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 einer neuen UNNotificationAction wird ein eindeutiger Bezeichner 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. festlegen, dass sie eine Vordergrundaktion ist).

Jede der erstellten Aktionen muss einer Kategorie zugeordnet werden. Beim Erstellen einer neuen UNNotificationCategory wird ein eindeutiger Bezeichner zugewiesen, eine Liste von Aktionen, die ausgeführt werden können, eine Liste mit Absichtsbezeichnern, 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 mithilfe der SetNotificationCategories-Methode beim System registriert.

Präsentieren von benutzerdefinierten Aktionen

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

Legen Sie für Remotebenachrichtigungen eine category in der Remotebenachrichtigungsnutzlast fest, die 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 dieser Bezeichner mit einer der oben erstellten Kategorien übereinstimmen.

Behandeln von Verwerfenaktionen

Wie oben erwähnt, kann eine Verwerfen-Aktion an die App gesendet werden, wenn der Benutzer eine Benachrichtigung verwirft. Da dies keine Standardaktion ist, 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. Um dies zu erreichen, wird ein [UNUserNotificationCenterDelegate][unnsernotificationcenterdelegate] bereitgestellt, und die Methode DidReceiveNotificationResponse wird implementiert. 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 Abbrechen-Aktion sein kann. Verwenden Sie response.Notification.Request.Identifier, um 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.

Arbeit mit Erweiterungen des Benachrichtigungsdienstes

Beim Arbeiten mit Remotebenachrichtigungen bietet eine Benachrichtigungsdiensterweiterung eine Möglichkeit, die End-to-End-Verschlüsselung innerhalb der Benachrichtigungsnutzlast zu aktivieren. Eine Erweiterung des Benachrichtigungsdiensts ist eine Erweiterung ohne Benutzeroberfläche, die im Hintergrund ausgeführt wird, um den sichtbaren Inhalt einer Benachrichtigung zu erweitern oder zu ersetzen, bevor sie dem Benutzer angezeigt wird.

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

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

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

Implementieren einer Benachrichtigungsdienst-Erweiterung

Gehen Sie wie folgt vor, um eine Benachrichtigungsdiensterweiterung in einer App zu implementieren:

1. Erstellen Sie einen neuen Ordner für das Erweiterungsprojekt neben dem Ordner des Hauptprojekts. In den folgenden Anweisungen wird davon ausgegangen, dass der neue Ordner benannt MyNotificationServiceExtensionist.

2. Öffnen Sie ein Terminal, und führen Sie Folgendes aus:

   dotnet new ios-notification-service-extension
   

3. Öffnen Sie die Projektdatei des Hauptprojekts, und fügen Sie Folgendes hinzu:

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

4. Erstellen Sie nun das Hauptprojekt, und das Erweiterungsprojekt wird auch erstellt und im endgültigen App-Bündel enthalten sein.

Es gibt eine Hauptklasse in der Benachrichtigungsdienst-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
    {
        protected NotificationServiceClass (NativeHandle handle) : base (handle)
        {
            // Note: this .ctor should not contain any initialization logic,
            // it only exists so that the OS can instantiate an instance of this class.
        }

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

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

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

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

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

Die erste Methode , DidReceiveNotificationRequest, wird den Benachrichtigungsbezeichner sowie den Benachrichtigungsinhalt über das request Objekt übergeben. Die übergebene contentHandler Datei muss aufgerufen werden, um dem Benutzer die Benachrichtigung zu präsentieren.

Die zweite Methode, TimeWillExpire, wird aufgerufen, kurz bevor die Zeit abläuft, damit die Benachrichtigungsdiensterweiterung die Anfrage bearbeiten kann. Wenn es der Erweiterung des Benachrichtigungsdiensts nicht gelingt, den contentHandler innerhalb des zugewiesenen Zeitraums aufzurufen, wird der ursprüngliche Inhalt dem Benutzer angezeigt.

Auslösen einer Benachrichtigungsdienst-Erweiterung

Wenn eine Erweiterung des Benachrichtigungsdiensts 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 Erweiterung des Benachrichtigungsdiensts gestartet werden muss, um den Remotebenachrichtigungsinhalt zu aktualisieren. Der encrypted-content Schlüssel enthält die verschlüsselten Daten, die die Erweiterung des Benachrichtigungsdiensts entschlüsseln kann, bevor sie dem Benutzer präsentiert wird.

Sehen Sie sich die folgende Beispielerweiterung des Benachrichtigungsdiensts 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 ein neues UNMutableNotificationContent, legt die Body-Eigenschaft auf den entschlüsselten Inhalt fest und verwendet contentHandler um die Benachrichtigung dem Benutzer zu präsentieren.

Siehe auch

• iOS-Beispiel-
• UserNotifications Framework-Referenz
• UserNotificationsUI
• Programmierhandbuch für lokale und Remotebenachrichtigungen
• Anpassen der Darstellung von Benachrichtigungen