Notifications par vignette pouvant être suiviesChaseable tile notifications

Les notifications de vignettes chaseables vous permettent de déterminer les notifications de vignettes affichées par la vignette dynamique de votre application lorsque l’utilisateur clique sur la vignette.Chaseable tile notifications let you determine which tile notifications your app's Live Tile was displaying when the user clicked the tile.
Par exemple, une application d’actualités peut utiliser cette fonctionnalité pour déterminer le récit d’actualité affiché par la vignette dynamique quand l’utilisateur l’a lancée. Cela peut s’assurer que l’histoire est affichée de manière visible afin que l’utilisateur puisse la trouver.For example, a news app could use this feature to determine which news story the its Live Tile was displaying when the user launched it; it could that ensure that the story is prominently displayed so that the user can find it.

Important

Nécessite une mise à jour anniversaire: pour utiliser des notifications de vignettes chaseables avec des applications UWP C#, C++ ou vb, vous devez cibler le kit de développement logiciel (SDK) 14393 et exécuter la version 14393 ou une version ultérieure.Requires Anniversary Update: To use chaseable tile notifications with C#, C++, or VB-based UWP apps, you must target SDK 14393 and be running build 14393 or higher. Pour les applications UWP basées sur JavaScript, vous devez cibler le kit de développement logiciel (SDK) 17134 et exécuter la version 17134 ou une version ultérieure.For JavaScript-based UWP apps, you must target SDK 17134 and be running build 17134 or higher.

API importantes: propriété LaunchActivatedEventArgs. TileActivatedInfo, classe TileActivatedInfoImportant APIs: LaunchActivatedEventArgs.TileActivatedInfo property, TileActivatedInfo class

FonctionnementHow it works

Pour activer les notifications de vignettes chaseables, utilisez la propriété arguments sur la charge utile de notification par vignette, similaire à la propriété Launch sur la charge utile de notification Toast, pour incorporer des informations sur le contenu dans la notification de vignette.To enable chaseable tile notifications, you use the Arguments property on the tile notification payload, similar to the launch property on the toast notification payload, to embed info about the content in the tile notification.

Lorsque votre application est lancée par le biais de la vignette dynamique, le système renvoie une liste d’arguments à partir des notifications de vignettes actuelles/récemment affichées.When your app is launched via the Live Tile, the system returns a list of arguments from the current/recently displayed tile notifications.

Quand utiliser les notifications de vignettes chaseablesWhen to use chaseable tile notifications

Les notifications de vignettes chaseables sont généralement utilisées lorsque vous utilisez la file d’attente de notification sur votre vignette dynamique (ce qui signifie que vous parcourez jusqu’à 5 notifications différentes).Chaseable tile notifications are typically used when you're using the notification queue on your Live Tile (which means you are cycling through up to 5 different notifications). Ils sont également bénéfiques lorsque le contenu de votre vignette dynamique est potentiellement désynchronisé avec le contenu le plus récent de l’application.They're also beneficial when the content on your Live Tile is potentially out of sync with the latest content in the app. Par exemple, l’application News actualise sa vignette dynamique toutes les 30 minutes, mais lorsque l’application est lancée, elle charge les dernières actualités (ce qui peut ne pas inclure un élément qui se trouvait sur la vignette à partir du dernier intervalle d’interrogation).For example, the News app refreshes its Live Tile every 30 minutes, but when the app is launched, it loads the latest news (which may not include something that was on the tile from the last polling interval). Dans ce cas, l’utilisateur risque de ne pas pouvoir trouver le récit qu’il a vu sur sa vignette dynamique.When this happens, the user might get frustrated about not being able to find the story they saw on their Live Tile. C’est là que les notifications de vignettes peuvent vous aider, en vous permettant de vous assurer que ce que l’utilisateur a vu sur sa vignette est facilement détectable.That's where chaseable tile notifications can help, by allowing you to make sure that what the user saw on their Tile is easily discoverable.

Que faire avec les notifications de vignettes ChaseWhat to do with a chaseable tile notifications

L’élément le plus important à noter est que dans la plupart des scénarios, vous ne devez pas accéder directement à la notification spécifique qui se trouvait sur la vignette lorsque l’utilisateur cliquait dessus.The most important thing to note is that in most scenarios, you should NOT directly navigate to the specific notification that was on the Tile when the user clicked it. Votre vignette dynamique est utilisée comme point d’entrée de votre application.Your Live Tile is used as an entry point to your application. Il peut y avoir deux scénarios lorsqu’un utilisateur clique sur votre vignette dynamique : (1) il souhaitait lancer votre application normalement, ou (2) qu’elle souhaitait obtenir plus d’informations sur une notification spécifique qui était sur la vignette dynamique.There can be two scenarios when a user clicks your Live Tile: (1) they wanted to launch your app normally, or (2) they wanted to see more information about a specific notification that was on the Live Tile. Étant donné qu’il n’existe aucun moyen pour l’utilisateur d’indiquer explicitement le comportement qu’il veut, l’expérience idéale consiste à lancer votre application normalement, tout en vous assurant que la notification que l’utilisateur a vue est facilement détectable.Since there's no way for the user to explicitly say which behavior they want, the ideal experience is to launch your app normally, while making sure that the notification the user saw is easily discoverable.

Par exemple, le fait de cliquer sur la vignette dynamique de l’application MSN News lance l’application normalement : elle affiche la page d’hébergement, ou l’article que l’utilisateur a déjà lu.For example, clicking the MSN News app's Live Tile launches the app normally: it displays the home page, or whichever article the user was previously reading. Toutefois, dans la page d’hébergement, l’application s’assure que l’histoire de la vignette dynamique est facilement détectable.However, on the home page, the app ensures that the story from the Live Tile is easily discoverable. De cette façon, les deux scénarios sont pris en charge : le scénario dans lequel vous souhaitez simplement lancer/reprendre l’application, et le scénario dans lequel vous souhaitez afficher l’histoire spécifique.That way, both scenarios are supported: the scenario where you simply want to launch/resume the app, and the scenario where you want to view the specific story.

Comment inclure la propriété arguments dans la charge utile de notification de vignetteHow to include the Arguments property in your tile notification payload

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.In a notification payload, the arguments property enables your app to provide data you can use to later identify the notification. Par exemple, vos arguments peuvent inclure l’ID du récit, de sorte que, lorsqu’il est lancé, vous pouvez récupérer et afficher l’histoire.For example, your arguments might include the story's id, so that when launched, you can retrieve and display the story. 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 de chaîne de requête, car il est très léger et encodé en XML.The property accepts a string, which can be serialized however you like (query string, JSON, etc), but we typically recommend query string format, since it's lightweight and XML-encodes nicely.

La propriété peut être définie à la fois sur les éléments TileVisual et TileBinding , et s’affiche en cascade.The property can be set on both the TileVisual and the TileBinding elements, and will cascade down. Si vous souhaitez les mêmes arguments à chaque taille de mosaïque, définissez simplement les arguments sur le TileVisual.If you want the same arguments on every tile size, simply set the arguments on the TileVisual. Si vous avez besoin d’arguments spécifiques pour des tailles de vignette spécifiques, vous pouvez définir les arguments sur des éléments TileBinding individuels.If you need specific arguments for specific tile sizes, you can set the arguments on individual TileBinding elements.

Cet exemple crée une charge utile de notification qui utilise la propriété arguments pour que la notification puisse être identifiée ultérieurement.This example creates a notification payload that uses the arguments property so that notification can be identified later.

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

Comment vérifier la propriété arguments lors du lancement de votre applicationHow to check for the arguments property when your app launches

La plupart des applications ont un fichier App.xaml.cs qui contient une substitution pour la méthode OnLaunched .Most apps have an App.xaml.cs file that contains an override for the OnLaunched method. Comme son nom l’indique, votre application appelle cette méthode lorsqu’elle est lancée.As its name suggests, your app calls this method when it's launched. Il accepte un seul argument, un objet LaunchActivatedEventArgs .It takes a single argument, a LaunchActivatedEventArgs object.

L’objet LaunchActivatedEventArgs a une propriété qui active les notifications Chase : la propriété TileActivatedInfo, qui fournit l’accès à un objet TileActivatedInfo.The LaunchActivatedEventArgs object has a property that enables chaseable notifications: the TileActivatedInfo property, which provides access to a TileActivatedInfo object. Lorsque l’utilisateur lance votre application à partir de sa vignette (au lieu de la liste d’applications, de la recherche ou de tout autre point d’entrée), votre application initialise cette propriété.When the user launches your app from its tile (rather than the app list, search, or any other entry point), your app initializes this property.

L' objet TileActivatedInfo contient une propriété appelée RecentlyShownNotifications, qui contient la liste des notifications qui ont été affichées sur la vignette au cours des 15 dernières minutes.The TileActivatedInfo object contains a property called RecentlyShownNotifications, which contains a list of notifications that have been shown on the tile within the last 15 minutes. Le premier élément de la liste représente la notification actuellement sur la vignette, et les éléments suivants représentent les notifications que l’utilisateur a vues avant l’élément actuel.The first item in the list represents the notification currently on the tile, and the subsequent items represent the notifications that the user saw before the current one. Si votre vignette a été effacée, cette liste est vide.If your tile has been cleared, this list is empty.

Chaque ShownTileNotification a une propriété arguments.Each ShownTileNotification has an Arguments property. La propriété arguments sera initialisée avec la chaîne d’arguments de votre charge utile de notification par vignette, ou null si votre charge utile n’incluait pas la chaîne d’arguments.The Arguments property will be initialized with the arguments string from your tile notification payload, or null if your payload didn't include the arguments string.

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ès à OnLaunched à partir d’applications de bureauAccessing OnLaunched from desktop applications

Les applications de bureau (comme WPF, etc.) à l’aide du pont de bureaupeuvent également utiliser des vignettes chaseuses !Desktop apps (like WPF, etc) using the Desktop Bridge, can use chaseable tiles too! La seule différence est l’accès aux arguments OnLaunched.The only difference is accessing the OnLaunched arguments. Notez que vous devez d’abord empaqueter votre application avec le pont Desktop.Note that you first must package your app with the Desktop Bridge.

Important

Nécessite la mise à jour du 2018 octobre: pour utiliser l' AppInstance.GetActivatedEventArgs() API, vous devez cibler le kit de développement logiciel (SDK) 17763 et exécuter Build 17763 ou une version ultérieure.Requires October 2018 Update: To use the AppInstance.GetActivatedEventArgs() API, you must target SDK 17763 and be running build 17763 or higher.

Pour les applications de bureau, pour accéder aux arguments de lancement, procédez comme suit...For desktop applications, to access the launch arguments, do the following...


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

    // API only available on build 17763 or higher
    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 brutRaw XML example

Si vous utilisez des données XML brutes au lieu de la bibliothèque de notifications, voici le code XML.If you're using raw XML instead of the Notifications library, here's the 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>