Notifications par vignette pouvant être suivies

Les notifications de vignette pouvant être suivies vous permettent de déterminer quelles notifications de vignette la vignette dynamique de votre application a affichées lorsque l’utilisateur a cliqué sur la vignette. Par exemple, une application d’actualités pourrait utiliser cette fonctionnalité pour déterminer quel article de presse sa vignette dynamique affichait lorsque l’utilisateur l’a lancée. Elle pourrait s’assurer que l’article est affiché de manière bien visible afin que l’utilisateur puisse le trouver.

API importantes : Propriété LaunchActivatedEventArgs.TileActivatedInfo, classe TileActivatedInfo

Fonctionnement

Pour activer les notifications de vignette pouvant être suivies, vous utilisez la propriété Arguments sur la charge utile de notification de vignette, similaire à la propriété de lancement sur la charge utile de notification toast, pour incorporer des informations sur le contenu de la notification de vignette.

Lorsque votre application est lancée par le biais de la vignette dynamique, le système retourne une liste d’arguments à partir des notifications de vignette actuelles/récemment affichées.

Quand utiliser les notifications de vignette pouvant être suivies

Les notifications de vignette pouvant être suivies sont généralement utilisées lorsque vous utilisez la file d’attente de notifications sur votre vignette dynamique (ce qui signifie que vous parcourez jusqu’à 5 notifications différentes). Ils sont également utiles lorsque le contenu de votre vignette dynamique est potentiellement non synchronisé avec le contenu le plus récent de l’application. Par exemple, l’application Actualités actualise sa vignette dynamique toutes les 30 minutes, mais lorsque l’application est lancée, elle charge les dernières actualités (qui peuvent ne pas inclure un élément qui se trouvait sur la vignette lors de la dernière fréquence d’interrogation). Dans ce cas, l’utilisateur peut être frustré de ne pas pouvoir trouver l’article qu’il a vu sur sa vignette dynamique. C’est là que les notifications de vignette pouvant être suivies peuvent vous aider, en vous permettant de vous assurer que ce que l’utilisateur a vu sur sa vignette est facilement détectable.

Que faire avec une notification de vignette pouvant être suivie

La chose la plus importante à noter est que dans la plupart des scénarios, vous ne devez PAS accéder directement à la notification spécifique qui était sur la vignette lorsque l’utilisateur a cliqué dessus. Votre vignette dynamique est utilisée comme point d’entrée pour votre application. Deux raisons peuvent expliquer qu’un utilisateur clique sur votre vignette dynamique : (1) il voulait lancer votre application normalement, ou (2) il voulait en savoir plus sur une notification spécifique qui se trouvait sur la vignette. Étant donné que l’utilisateur n’a aucun moyen d’indiquer explicitement le comportement qu’il souhaite, l’idéal est de lancer l’application normalement, tout en veillant à ce que la notification que l’utilisateur a vue soit facilement détectable.

Par exemple, un clic sur la vignette dynamique de l’application MSN News lance l’application normalement : elle affiche la page d’accueil ou l’article que l’utilisateur était en train de lire. Cependant, sur la page d’accueil, l’application veille à ce que l’article de la vignette dynamique soit facilement accessible. Les deux scénarios sont ainsi pris en charge : celui où vous souhaitez simplement lancer/reprendre l’application, et celui où vous souhaitez consulter l’article en question.

Comment inclure la propriété Arguments dans votre charge utile de notification de vignette

Dans une charge utile de notification, la propriété arguments permet à votre application de fournir des données que vous pouvez utiliser pour identifier ultérieurement la notification. Par exemple, vos arguments peuvent inclure l’identifiant de l’article, de sorte qu’une fois lancé, vous puissiez récupérer et afficher l’article. La propriété accepte une chaîne, qui peut être sérialisée comme vous le souhaitez (chaîne de requête, JSON, etc.), mais nous recommandons généralement le format chaîne de requête, car il est léger et s’encode bien en XML.

La propriété peut être définie à la fois sur les éléments TileVisual et TileBinding, et se présente sous forme de cascade. Si vous souhaitez disposer des mêmes arguments pour chaque taille de vignette, il vous suffit de définir les arguments dans le TileVisual. Si vous avez besoin d’arguments spécifiques pour des tailles de vignettes spécifiques, vous pouvez définir les arguments sur des éléments TileBinding individuels.

Cet exemple crée une charge utile de notification qui utilise la propriété arguments afin que la notification puisse être identifiée ultérieurement.

// Uses the following NuGet packages
// - Microsoft.Toolkit.Uwp.Notifications
// - QueryString.NET
 
TileContent content = new TileContent()
{
    Visual = new TileVisual()
    {
        // These arguments cascade down to Medium and Wide
        Arguments = new QueryString()
        {
            { "action", "storyClicked" },
            { "story", "201c9b1" }
        }.ToString(),
 
 
        // Medium tile
        TileMedium = new TileBinding()
        {
            Content = new TileBindingContentAdaptive()
            {
                // Omitted
            }
        },
 
 
        // Wide tile is same as Medium
        TileWide = new TileBinding() { /* Omitted */ },
 
 
        // Large tile is an aggregate of multiple stories
        // and therefore needs different arguments
        TileLarge = new TileBinding()
        {
            Arguments = new QueryString()
            {
                { "action", "storiesClicked" },
                { "story", "43f939ag" },
                { "story", "201c9b1" },
                { "story", "d9481ca" }
            }.ToString(),
 
            Content = new TileBindingContentAdaptive() { /* Omitted */ }
        }
    }
};

Guide de vérification de la propriété arguments au lancement de l’application

La plupart des applications ont un fichier App.xaml.cs qui contient un remplacement pour la méthode OnLaunched. Comme son nom l’indique, votre application appelle cette méthode lorsqu’elle est lancée. Elle prend un seul argument, un objet LaunchActivatedEventArgs.

L’objet LaunchActivatedEventArgs a une propriété qui permet des notifications pouvant être suivies : la propriété TileActivatedInfo, qui fournit l’accès à un objet TileActivatedInfo. Lorsque l’utilisateur lance votre application à partir de sa vignette (plutôt qu’à partir de la liste des applications, de la recherche ou de tout autre point d’entrée), votre application initialise cette propriété.

L’objet TileActivatedInfo contient une propriété appelée RecentlyShownNotifications, qui contient une liste de notifications affichées sur la vignette au cours des 15 dernières minutes. Le premier élément de la liste représente la notification actuellement présente sur la vignette, et les éléments suivants représentent les notifications que l’utilisateur a vues avant la notification actuelle. Si votre vignette a été effacée, cette liste est vide.

Chaque ShownTileNotification possède une propriété Arguments. La propriété Arguments est initialisée avec la chaîne d’arguments de votre charge utile de notification de vignette, ou null si votre charge utile n’a pas inclus la chaîne d’arguments.

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
    // If the API is present (doesn't exist on 10240 and 10586)
    if (ApiInformation.IsPropertyPresent(typeof(LaunchActivatedEventArgs).FullName, nameof(LaunchActivatedEventArgs.TileActivatedInfo)))
    {
        // If clicked on from tile
        if (args.TileActivatedInfo != null)
        {
            // If tile notification(s) were present
            if (args.TileActivatedInfo.RecentlyShownNotifications.Count > 0)
            {
                // Get arguments from the notifications that were recently displayed
                string[] allArgs = args.TileActivatedInfo.RecentlyShownNotifications
                .Select(i => i.Arguments)
                .ToArray();
 
                // TODO: Highlight each story in the app
            }
        }
    }
 
    // TODO: Initialize app
}

Accéder à OnLaunched à partir d’applications bureautiques

Les applications bureautiques (comme WPF, etc.) à l’aide du pont du bureau peuvent également utiliser des vignettes pouvant être suivies ! La seule différence réside dans l’accès aux arguments OnLaunched. Notez que vous devez d’abord empaqueter votre application avec le pont du bureau.

Pour les applications bureautiques, pour accéder aux arguments de lancement, procédez comme suit...

static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);

    // API only available on build 17763 or later
    var args = AppInstance.GetActivatedEventArgs();
    switch (args.Kind)
    {
        case ActivationKind.Launch:

            var launchArgs = args as LaunchActivatedEventArgs;

            // If clicked on from tile
            if (launchArgs.TileActivatedInfo != null)
            {
                // If tile notification(s) were present
                if (launchArgs.TileActivatedInfo.RecentlyShownNotifications.Count > 0)
                {
                    // Get arguments from the notifications that were recently displayed
                    string[] allTileArgs = launchArgs.TileActivatedInfo.RecentlyShownNotifications
                    .Select(i => i.Arguments)
                    .ToArray();
     
                    // TODO: Highlight each story in the app
                }
            }

            break;

Exemple de XML brut

Si vous utilisez du XML brut au lieu de la bibliothèque de notifications, voici le XML.

<tile>
  <visual arguments="action=storyClicked&amp;story=201c9b1">
 
    <binding template="TileMedium">
       
      <text>Kitten learns how to drive a car...</text>
      ... (omitted)
     
    </binding>
 
    <binding template="TileWide">
      ... (same as Medium)
    </binding>
     
    <!--Large tile is an aggregate of multiple stories-->
    <binding
      template="TileLarge"
      arguments="action=storiesClicked&amp;story=43f939ag&amp;story=201c9b1&amp;story=d9481ca">
   
      <text>Can your dog understand what you're saying?</text>
      ... (another story)
      ... (one more story)
   
    </binding>
 
  </visual>
</tile>

Articles connexes

• Propriété LaunchActivatedEventArgs.TileActivatedInfo
• Classe TileActivatedInfo