Écouteur de notification : Accéder à toutes les notifications

L’écouteur de notification fournit l’accès aux notifications d’un utilisateur. Les Utilisateurs et d’autres appareils portables peuvent utiliser l’écouteur de notification pour envoyer les notifications du téléphone à l’appareil portable. Les applications d’automatisation d’accueil peuvent utiliser l’écouteur de notification pour effectuer des actions spécifiques lorsque des notifications sont reçues, comme faire clignoter les lumières lorsque vous recevez un appel.

API importantes : classe UserNotificationListener, classe UserNotificationChangedTrigger

Activer l’écouteur en ajoutant la fonctionnalité Notification utilisateur

Pour utiliser l’écouteur de notification, vous devez ajouter la fonctionnalité d’écouteur de notification utilisateur à votre manifeste d’application.

1. Dans Visual Studio, dans le Explorateur de solutions, double-cliquez sur votre Package.appxmanifest fichier pour ouvrir le concepteur de manifeste.
2. Sélectionnez l’onglet Fonctionnalités.
3. Vérifiez la fonctionnalité Écouteur de notification utilisateur.

Vérifier si l’écouteur est pris en charge

Si votre application prend en charge les versions antérieures de Windows 10, vous devez utiliser la classe ApiInformation pour vérifier si l’écouteur est pris en charge. Si l’écouteur n’est pas pris en charge, évitez d’exécuter des appels aux API de l’écouteur.

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

Demande d’accès à l’écouteur

Étant donné que l’écouteur autorise l’accès aux notifications de l’utilisateur, les utilisateurs doivent accorder à votre application l’autorisation d’accéder à leurs notifications. Pendant la première exécution de votre application, vous devez demander l’accès pour utiliser l’écouteur de notification. Si vous le souhaitez, vous pouvez afficher une interface utilisateur préliminaire qui explique pourquoi votre application a besoin d’accéder aux notifications de l’utilisateur avant d’appeler RequestAccessAsync, afin que l’utilisateur comprenne pourquoi il doit autoriser l’accès.

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

L’utilisateur peut révoquer l’accès à tout moment via les paramètres Windows. Par conséquent, votre application doit toujours vérifier l’état d’accès via la méthode GetAccessStatus avant d’exécuter du code qui utilise l’écouteur de notification. Si l’utilisateur révoque l’accès, les API échouent silencieusement plutôt que de lever une exception (par exemple, l’API pour obtenir toutes les notifications retourne simplement une liste vide).

Accéder aux notifications de l’utilisateur

Avec l’écouteur de notification, vous pouvez obtenir la liste des notifications actuelles de l’utilisateur. Appelez simplement la méthode GetNotificationsAsync et spécifiez le type de notifications que vous souhaitez obtenir (actuellement, le seul type de notifications pris en charge est les notifications toast).

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

Affichage des notifications

Chaque notification est représentée sous la forme d’un UserNotification, qui fournit des informations sur l’application à partir de laquelle la notification provient, l’heure de création de la notification, l’ID de la notification et la notification elle-même.

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

La propriété AppInfo fournit les informations dont vous avez besoin pour afficher la notification.

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

Le contenu de la notification proprement dite, tel que le texte de notification, est contenu dans la propriété Notification . Cette propriété contient la partie visuelle de la notification. (Si vous êtes familiarisé avec l’envoi de notifications sur Windows, vous remarquerez que le Les propriétés Visual et Visual.Bindings de l’objet Notification correspondent à ce que les développeurs envoient lors de l’envoi d’une notification.)

Nous voulons rechercher la liaison toast (pour le code de preuve d’erreur, vérifiez que la liaison n’est pas null). À partir de la liaison, vous pouvez obtenir les éléments de texte. Vous pouvez choisir d’afficher autant d’éléments de texte que vous le souhaitez. (Dans l’idéal, vous devez les afficher tous.) Vous pouvez choisir de traiter les éléments de texte différemment ; par exemple, traitez le premier comme texte de titre et les éléments suivants comme du corps du texte.

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

Supprimer une notification spécifique

Si votre portable ou service permet à l’utilisateur d’ignorer les notifications, vous pouvez supprimer la notification réelle afin que l’utilisateur ne le voit plus tard sur son téléphone ou son PC. Indiquez simplement l’ID de notification (obtenu à partir de l’objet UserNotification ) de la notification que vous souhaitez supprimer :

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

Effacer toutes les notifications

La méthode UserNotificationListener.ClearNotifications efface toutes les notifications de l’utilisateur. Utilisez cette méthode avec précaution. Vous ne devez effacer toutes les notifications que si votre portable ou votre service affiche toutes les notifications. Si votre service ou votre portable affiche uniquement certaines notifications, lorsque l’utilisateur clique sur votre bouton « Effacer les notifications », l’utilisateur s’attend à ce que ces notifications spécifiques soient supprimées ; Toutefois, l’appel de la méthode ClearNotifications entraînerait en fait la suppression de toutes les notifications, y compris celles que votre portable ou votre service n’affichait pas, à supprimer.

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

Tâche en arrière-plan pour la notification ajoutée/ignorée

Une méthode courante pour permettre à une application d’écouter les notifications consiste à configurer une tâche en arrière-plan, afin que vous puissiez savoir quand une notification a été ajoutée ou ignorée, que votre application soit en cours d’exécution.

Grâce au modèle de processus unique ajouté dans la mise à jour anniversaire, l’ajout de tâches en arrière-plan est assez simple. Dans le code de votre application principale, après avoir obtenu l’accès de l’utilisateur à Notification Listener et obtenu l’accès pour exécuter des tâches en arrière-plan en appelant UserNotificationListener.Current.RequestAccessAsync et BackgroundExecutionManager.RequestAccessAsync respectivement, inscrivez simplement une nouvelle tâche en arrière-plan et définissez UserNotificationChangedTrigger à l’aide du type de notification Toast.

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

Ensuite, dans votre App.xaml.cs, remplacez la méthode OnBackgroundActivated si vous ne l’avez pas encore fait et utilisez une instruction switch sur le nom de la tâche pour déterminer lequel de vos nombreux déclencheurs de tâche en arrière-plan a été appelé.

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

La tâche en arrière-plan est simplement un « appui sur l’épaule » : elle ne fournit aucune information sur la notification spécifique ajoutée ou supprimée. Lorsque votre tâche en arrière-plan est déclenchée, vous devez synchroniser les notifications sur votre portable afin qu’elles reflètent les notifications dans la plateforme. Cela garantit que si votre tâche en arrière-plan échoue, les notifications sur votre portable peuvent toujours être récupérées la prochaine fois que votre tâche en arrière-plan s’exécute.

SyncNotifications est une méthode que vous implémentez ; la section suivante montre comment procéder.

Détermination des notifications ajoutées et supprimées

Dans votre SyncNotifications méthode, pour déterminer quelles notifications ont été ajoutées ou supprimées (synchronisation des notifications avec votre portable), vous devez calculer le delta entre votre collection de notifications actuelle et les notifications dans la plateforme.

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

Événement de premier plan pour la notification ajoutée/ignorée

Vous pouvez également écouter les notifications à partir d’un gestionnaire d’événements en mémoire...

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

Comment résoudre les retards dans la tâche en arrière-plan

Lorsque vous testez votre application, vous remarquerez peut-être que la tâche en arrière-plan est parfois retardée et ne se déclenche pas pendant plusieurs minutes. Pour résoudre le délai, invitez l’utilisateur à accéder aux paramètres système -> Système -> Batterie -> Utilisation de la batterie par application, recherchez votre application dans la liste, sélectionnez-la et définissez-la sur « Toujours autorisé en arrière-plan ». Après cela, la tâche en arrière-plan doit toujours être déclenchée à l’intérieur d’une seconde de la notification reçue.