Benachrichtigungslistener: Zugriff auf alle Benachrichtigungen

Artikel
06/02/2023

Der Benachrichtigungslistener bietet Zugriff auf die Benachrichtigungen eines Benutzers. Smartwatches und andere Wearables können den Benachrichtigungslistener verwenden, um die Benachrichtigungen des Telefons an das tragbare Gerät zu senden. Heimautomatisierungs-Apps können den Benachrichtigungslistener verwenden, um bestimmte Aktionen auszuführen, wenn Benachrichtigungen empfangen werden, z. B. dass die Lichter blinken, wenn Sie einen Anruf erhalten.

Wichtig

Erfordert Anniversary Update: Sie müssen das SDK 14393 als Ziel verwenden und Build 14393 oder höher ausführen, um den Benachrichtigungslistener verwenden zu können.

Wichtige APIs: UserNotificationListener-Klasse, UserNotificationChangedTrigger-Klasse

Aktivieren des Listeners durch Hinzufügen der Funktion "Benutzerbenachrichtigung"

Um den Benachrichtigungslistener verwenden zu können, müssen Sie ihrem App-Manifest die Funktion Benutzerbenachrichtigungslistener hinzufügen.

Doppelklicken Sie in Visual Studio im Projektmappen-Explorer auf Ihre Package.appxmanifest Datei, um den Manifest-Designer zu öffnen.
Öffnen Sie die Registerkarte Funktionen.
Überprüfen Sie die Funktion Benutzerbenachrichtigungslistener .

Überprüfen, ob der Listener unterstützt wird

Wenn Ihre App ältere Versionen von Windows 10 unterstützt, müssen Sie die ApiInformation-Klasse verwenden, um zu überprüfen, ob der Listener unterstützt wird. Wenn der Listener nicht unterstützt wird, vermeiden Sie das Ausführen von Aufrufen der Listener-APIs.

if (ApiInformation.IsTypePresent("Windows.UI.Notifications.Management.UserNotificationListener"))
{
    // Listener supported!
}
 
else
{
    // Older version of Windows, no Listener
}

Anfordern des Zugriffs auf den Listener

Da der Listener den Zugriff auf die Benachrichtigungen des Benutzers zulässt, müssen Benutzer Ihrer App die Berechtigung für den Zugriff auf ihre Benachrichtigungen erteilen. Während der ersten Ausführung Ihrer App sollten Sie den Zugriff anfordern, um den Benachrichtigungslistener zu verwenden. Wenn Sie möchten, können Sie eine vorläufige Benutzeroberfläche anzeigen, die erläutert, warum Ihre App Zugriff auf die Benachrichtigungen des Benutzers benötigt, bevor Sie RequestAccessAsync aufrufen, damit der Benutzer versteht, warum er den Zugriff zulassen sollte.

// Get the listener
UserNotificationListener listener = UserNotificationListener.Current;
 
// And request access to the user's notifications (must be called from UI thread)
UserNotificationListenerAccessStatus accessStatus = await listener.RequestAccessAsync();
 
switch (accessStatus)
{
    // This means the user has granted access.
    case UserNotificationListenerAccessStatus.Allowed:
 
        // Yay! Proceed as normal
        break;
 
    // This means the user has denied access.
    // Any further calls to RequestAccessAsync will instantly
    // return Denied. The user must go to the Windows settings
    // and manually allow access.
    case UserNotificationListenerAccessStatus.Denied:
 
        // Show UI explaining that listener features will not
        // work until user allows access.
        break;
 
    // This means the user closed the prompt without
    // selecting either allow or deny. Further calls to
    // RequestAccessAsync will show the dialog again.
    case UserNotificationListenerAccessStatus.Unspecified:
 
        // Show UI that allows the user to bring up the prompt again
        break;
}

Der Benutzer kann den Zugriff jederzeit über die Windows-Einstellungen widerrufen. Daher sollte Ihre App immer den Zugriff status über die GetAccessStatus-Methode überprüfen, bevor Code ausgeführt wird, der den Benachrichtigungslistener verwendet. Wenn der Benutzer den Zugriff widerruft, schlagen die APIs im Hintergrund fehl, anstatt eine Ausnahme auszulösen (beispielsweise gibt die API zum Abrufen aller Benachrichtigungen einfach eine leere Liste zurück).

Zugreifen auf die Benachrichtigungen des Benutzers

Mit dem Benachrichtigungslistener können Sie eine Liste der aktuellen Benachrichtigungen des Benutzers abrufen. Rufen Sie einfach die GetNotificationsAsync-Methode auf, und geben Sie den Typ der Benachrichtigungen an, die Sie erhalten möchten (derzeit werden nur Popupbenachrichtigungen unterstützt).

// Get the toast notifications
IReadOnlyList<UserNotification> notifs = await listener.GetNotificationsAsync(NotificationKinds.Toast);

Anzeigen der Benachrichtigungen

Jede Benachrichtigung wird als UserNotification dargestellt, die Informationen über die App, von der die Benachrichtigung stammt, den Zeitpunkt, zu dem die Benachrichtigung erstellt wurde, die Benachrichtigungs-ID und die Benachrichtigung selbst enthält.

public sealed class UserNotification
{
    public AppInfo AppInfo { get; }
    public DateTimeOffset CreationTime { get; }
    public uint Id { get; }
    public Notification Notification { get; }
}

Die AppInfo-Eigenschaft stellt die Informationen bereit, die Sie zum Anzeigen der Benachrichtigung benötigen.

Hinweis

Es wird empfohlen, ihren gesamten Code für die Verarbeitung einer einzelnen Benachrichtigung in einem try/catch-Element einzuschließen, falls beim Erfassen einer einzelnen Benachrichtigung eine unerwartete Ausnahme auftritt. Sie sollten andere Benachrichtigungen nicht vollständig anzeigen, nur aufgrund eines Problems mit einer bestimmten Benachrichtigung.

// Select the first notification
UserNotification notif = notifs[0];
 
// Get the app's display name
string appDisplayName = notif.AppInfo.DisplayInfo.DisplayName;
 
// Get the app's logo
BitmapImage appLogo = new BitmapImage();
RandomAccessStreamReference appLogoStream = notif.AppInfo.DisplayInfo.GetLogo(new Size(16, 16));
await appLogo.SetSourceAsync(await appLogoStream.OpenReadAsync());

Der Inhalt der Benachrichtigung selbst, z. B. der Benachrichtigungstext, ist in der Notification-Eigenschaft enthalten. Diese Eigenschaft enthält den visuellen Teil der Benachrichtigung. (Wenn Sie mit dem Senden von Benachrichtigungen unter Windows vertraut sind, werden Sie feststellen, dass die Eigenschaften Visual und Visual.Bindings im Notification-Objekt dem entsprechen, was Entwickler beim Senden einer Benachrichtigung senden.)

Wir möchten nach der Popupbindung suchen (bei fehlersicherem Code sollten Sie überprüfen, ob die Bindung nicht NULL ist). Aus der Bindung können Sie die Textelemente abrufen. Sie können beliebig viele Textelemente anzeigen. (Idealerweise sollten Sie sie alle anzeigen.) Sie können die Textelemente unterschiedlich behandeln. Behandeln Sie z. B. das erste als Titeltext und die nachfolgenden Elemente als Textkörper.

// Get the toast binding, if present
NotificationBinding toastBinding = notif.Notification.Visual.GetBinding(KnownNotificationBindings.ToastGeneric);
 
if (toastBinding != null)
{
    // And then get the text elements from the toast binding
    IReadOnlyList<AdaptiveNotificationText> textElements = toastBinding.GetTextElements();
 
    // Treat the first text element as the title text
    string titleText = textElements.FirstOrDefault()?.Text;
 
    // We'll treat all subsequent text elements as body text,
    // joining them together via newlines.
    string bodyText = string.Join("\n", textElements.Skip(1).Select(t => t.Text));
}

Entfernen einer bestimmten Benachrichtigung

Wenn Ihr Wearable oder Dienst es dem Benutzer ermöglicht, Benachrichtigungen zu schließen, können Sie die eigentliche Benachrichtigung entfernen, damit sie dem Benutzer später nicht mehr auf dem Smartphone oder PC angezeigt wird. Geben Sie einfach die Benachrichtigungs-ID (abgerufen aus dem UserNotification-Objekt ) der Benachrichtigung an, die Sie entfernen möchten:

// Remove the notification
listener.RemoveNotification(notifId);

Löschen aller Benachrichtigungen

Die UserNotificationListener.ClearNotifications-Methode löscht alle Benachrichtigungen des Benutzers. Verwenden Sie diese Methode mit Vorsicht. Sie sollten alle Benachrichtigungen nur löschen, wenn Ihr Wearable oder Dienst ALLE Benachrichtigungen anzeigt. Wenn Ihr Wearable oder Dienst nur bestimmte Benachrichtigungen anzeigt und der Benutzer auf Ihre Schaltfläche "Benachrichtigungen löschen" klickt, erwartet der Benutzer nur, dass diese spezifischen Benachrichtigungen entfernt werden. Der Aufruf der ClearNotifications-Methode würde jedoch dazu führen, dass alle Benachrichtigungen entfernt werden, einschließlich der Benachrichtigungen, die ihr Wearable oder Dienst nicht anzeigte.

// Clear all notifications. Use with caution.
listener.ClearNotifications();

Hintergrundaufgabe für Benachrichtigung hinzugefügt/verworfen

Eine gängige Möglichkeit, einer App das Lauschen auf Benachrichtigungen zu ermöglichen, besteht darin, eine Hintergrundaufgabe einzurichten, sodass Sie wissen können, wann eine Benachrichtigung hinzugefügt oder geschlossen wurde, unabhängig davon, ob Ihre App gerade ausgeführt wird.

Dank des einzelnen Prozessmodells , das im Anniversary Update hinzugefügt wurde, ist das Hinzufügen von Hintergrundaufgaben ziemlich einfach. Nachdem Sie im Code Ihrer Standard App Zugriff des Benutzers auf den Benachrichtigungslistener erhalten und Zugriff zum Ausführen von Hintergrundaufgaben erhalten haben, indem Sie UserNotificationListener.Current.RequestAccessAsync bzw. BackgroundExecutionManager.RequestAccessAsync aufrufen, registrieren Sie einfach eine neue Hintergrundaufgabe, und legen Sie userNotificationChangedTrigger mithilfe der Popupbenachrichtigungsart fest.

// TODO: Request/check Listener access via UserNotificationListener.Current.RequestAccessAsync
 
// TODO: Request/check background task access via BackgroundExecutionManager.RequestAccessAsync
 
// If background task isn't registered yet
if (!BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name.Equals("UserNotificationChanged")))
{
    // Specify the background task
    var builder = new BackgroundTaskBuilder()
    {
        Name = "UserNotificationChanged"
    };
 
    // Set the trigger for Listener, listening to Toast Notifications
    builder.SetTrigger(new UserNotificationChangedTrigger(NotificationKinds.Toast));
 
    // Register the task
    builder.Register();
}

Überschreiben Sie dann in Ihrer App.xaml.cs die OnBackgroundActivated-Methode , falls noch nicht geschehen, und verwenden Sie eine switch-Anweisung für den Aufgabennamen, um zu bestimmen, welcher Ihrer vielen Hintergrundaufgabentrigger aufgerufen wurde.

protected override async void OnBackgroundActivated(BackgroundActivatedEventArgs args)
{
    var deferral = args.TaskInstance.GetDeferral();
 
    switch (args.TaskInstance.Task.Name)
    {
        case "UserNotificationChanged":
            // Call your own method to process the new/removed notifications
            // The next section of documentation discusses this code
            await MyWearableHelpers.SyncNotifications();
            break;
    }
 
    deferral.Complete();
}

Die Hintergrundaufgabe ist einfach ein "Schulterkippen": Sie enthält keine Informationen darüber, welche bestimmte Benachrichtigung hinzugefügt oder entfernt wurde. Wenn Ihre Hintergrundaufgabe ausgelöst wird, sollten Sie die Benachrichtigungen auf Ihrem Wearable synchronisieren, damit sie die Benachrichtigungen auf der Plattform widerspiegeln. Dadurch wird sichergestellt, dass Benachrichtigungen auf Ihrem Wearable bei der nächsten Ausführung der Hintergrundaufgabe weiterhin wiederhergestellt werden können, wenn Ihre Hintergrundaufgabe fehlschlägt.

SyncNotifications ist eine Methode, die Sie implementieren; Im nächsten Abschnitt wird gezeigt, wie das geht.

Bestimmen, welche Benachrichtigungen hinzugefügt und entfernt wurden

SyncNotifications Um zu bestimmen, welche Benachrichtigungen hinzugefügt oder entfernt wurden (Synchronisieren von Benachrichtigungen mit Ihrem Wearable), müssen Sie das Delta zwischen Ihrer aktuellen Benachrichtigungssammlung und den Benachrichtigungen auf der Plattform berechnen.

// Get all the current notifications from the platform
IReadOnlyList<UserNotification> userNotifications = await listener.GetNotificationsAsync(NotificationKinds.Toast);
 
// Obtain the notifications that our wearable currently has displayed
IList<uint> wearableNotificationIds = GetNotificationsOnWearable();
 
// Copy the currently displayed into a list of notification ID's to be removed
var toBeRemoved = new List<uint>(wearableNotificationIds);
 
// For each notification in the platform
foreach (UserNotification userNotification in userNotifications)
{
    // If we've already displayed this notification
    if (wearableNotificationIds.Contains(userNotification.Id))
    {
        // We want to KEEP it displayed, so take it out of the list
        // of notifications to remove.
        toBeRemoved.Remove(userNotification.Id);
    }
 
    // Otherwise it's a new notification
    else
    {
        // Display it on the Wearable
        SendNotificationToWearable(userNotification);
    }
}
 
// Now our toBeRemoved list only contains notification ID's that no longer exist in the platform.
// So we will remove all those notifications from the wearable.
foreach (uint id in toBeRemoved)
{
    RemoveNotificationFromWearable(id);
}

Vordergrundereignis für Benachrichtigung hinzugefügt/verworfen

Wichtig

Bekanntes Problem: In Builds vor Build 17763/Oktober 2018 Update/Version 1809 führt das Vordergrundereignis zu einer CPU-Schleife und/oder funktionierte nicht. Wenn Sie Unterstützung für diese früheren Builds benötigen, verwenden Sie stattdessen die Hintergrundaufgabe.

Sie können auch auf Benachrichtigungen von einem In-Memory-Ereignishandler lauschen...

// Subscribe to foreground event
listener.NotificationChanged += Listener_NotificationChanged;
 
private void Listener_NotificationChanged(UserNotificationListener sender, UserNotificationChangedEventArgs args)
{
    // Your code for handling the notification
}

Beheben von Verzögerungen in der Hintergrundaufgabe

Wenn Sie Ihre App testen, stellen Sie möglicherweise fest, dass die Hintergrundaufgabe manchmal verzögert ist und nicht mehrere Minuten lang ausgelöst wird. Um die Verzögerung zu beheben, fordern Sie den Benutzer auf, zu den Systemeinstellungen –> System –> Akku –> Akkunutzung nach App zu wechseln. Suchen Sie Ihre App in der Liste, wählen Sie sie aus, und legen Sie sie auf "Immer im Hintergrund zulässig" fest. Danach sollte die Hintergrundaufgabe immer innerhalb von etwa einer Sekunde der empfangenen Benachrichtigung ausgelöst werden.

Freigeben über