Notifiche di tipo riquadro individuabiliChaseable tile notifications

Le notifiche dei riquadri inseguibili consentono di determinare le notifiche del riquadro visualizzate dal riquadro animato dell'app quando l'utente ha fatto clic sul riquadro.Chaseable tile notifications let you determine which tile notifications your app's Live Tile was displaying when the user clicked the tile.
Ad esempio, un'app notizie può usare questa funzionalità per determinare quale storia di notizie è stata visualizzata dal riquadro animato quando l'utente l'ha avviata; Questo potrebbe garantire che la storia venga visualizzata in primo piano, in modo che l'utente possa trovarlo.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.

Importante

Richiede l'aggiornamento dell'anniversario : per usare le notifiche dei riquadri inseguibili con le app UWP basate su C#, C++ o VB, è necessario destinare l'SDK 14393 ed eseguire build 14393 o versione successiva.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. Per le app UWP basate su JavaScript, è necessario destinare l'SDK 17134 ed eseguire build 17134 o versione successiva.For JavaScript-based UWP apps, you must target SDK 17134 and be running build 17134 or higher.

API importanti : Proprietà LaunchActivatedEventArgs. TileActivatedInfo, classe TileActivatedInfoImportant APIs : LaunchActivatedEventArgs.TileActivatedInfo property, TileActivatedInfo class

FunzionamentoHow it works

Per abilitare le notifiche dei riquadri inseribili, è possibile usare la proprietà arguments nel payload di notifica del riquadro, in modo analogo alla proprietà Launch nel payload della notifica di tipo avviso popup, per incorporare informazioni sul contenuto nella notifica del riquadro.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.

Quando l'app viene avviata tramite il riquadro animato, il sistema restituisce un elenco di argomenti dalle notifiche dei riquadri correnti o visualizzate di recente.When your app is launched via the Live Tile, the system returns a list of arguments from the current/recently displayed tile notifications.

Quando usare le notifiche di riquadri inseguibiliWhen to use chaseable tile notifications

Le notifiche dei riquadri inseguibili vengono in genere usate quando si usa la coda delle notifiche sul riquadro animato (il che significa che è in corso il ciclo fino a 5 notifiche diverse).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). Sono utili anche quando il contenuto nel riquadro animato non è potenzialmente sincronizzato con il contenuto più recente dell'app.They're also beneficial when the content on your Live Tile is potentially out of sync with the latest content in the app. Ad esempio, l'app News aggiorna il riquadro animato ogni 30 minuti, ma quando l'app viene avviata, carica le ultime notizie, che potrebbero non includere un elemento che si trovava nel riquadro dall'ultimo intervallo di polling.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). Quando ciò accade, l'utente potrebbe essere frustrato per non riuscire a trovare la storia che ha visto nel riquadro animato.When this happens, the user might get frustrated about not being able to find the story they saw on their Live Tile. Questo è il punto in cui possono essere utili le notifiche dei riquadri inseguibili, consentendo di assicurarsi che ciò che l'utente ha visto sul riquadro sia facilmente individuabile.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.

Cosa fare con le notifiche di un riquadro inseguibileWhat to do with a chaseable tile notifications

La cosa più importante da notare è che nella maggior parte degli scenari non è necessario passare direttamente alla notifica specifica che si trovava sul riquadro quando l'utente ha fatto clic su di essa.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. Il riquadro animato viene usato come punto di ingresso per l'applicazione.Your Live Tile is used as an entry point to your application. Possono esserci due scenari in cui un utente fa clic sul riquadro animato: (1) vuole avviare l'app normalmente oppure (2) vuole visualizzare altre informazioni su una notifica specifica che era sul riquadro animato.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. Poiché non esiste alcun modo per consentire all'utente di indicare in modo esplicito il comportamento che desidera, l'esperienza ideale consiste nell' avviare normalmente l'app, assicurandosi che la notifica visualizzata dall'utente sia facilmente individuabile .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 .

Se ad esempio si fa clic sul riquadro animato di MSN News app, l'app viene avviata normalmente: viene visualizzata la home page o qualsiasi articolo letto dall'utente.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. Tuttavia, nel home page, l'app garantisce che la storia dal riquadro animato sia facilmente individuabile.However, on the home page, the app ensures that the story from the Live Tile is easily discoverable. In questo modo, entrambi gli scenari sono supportati: lo scenario in cui si vuole semplicemente avviare o riprendere l'app e lo scenario in cui si vuole visualizzare la storia specifica.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.

Come includere la proprietà Arguments nel payload delle notifiche dei riquadriHow to include the Arguments property in your tile notification payload

In un payload di notifica la proprietà arguments consente all'app di fornire i dati che è possibile usare per identificare successivamente la notifica.In a notification payload, the arguments property enables your app to provide data you can use to later identify the notification. Ad esempio, gli argomenti possono includere l'ID della storia, in modo che, al momento dell'avvio, sia possibile recuperare e visualizzare la storia.For example, your arguments might include the story's id, so that when launched, you can retrieve and display the story. La proprietà accetta una stringa, che può essere serializzata, tuttavia, (stringa di query, JSON e così via), ma in genere si consiglia il formato della stringa di query, poiché è semplice e codificato in 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 proprietà può essere impostata sia per gli elementi TileVisual che per i riquadri e si produrrà a cascata.The property can be set on both the TileVisual and the TileBinding elements, and will cascade down. Se si vogliono gli stessi argomenti in ogni dimensione, è sufficiente impostare gli argomenti in TileVisual .If you want the same arguments on every tile size, simply set the arguments on the TileVisual . Se sono necessari argomenti specifici per dimensioni specifiche dei riquadri, è possibile impostare gli argomenti su singoli elementi di affiancamento .If you need specific arguments for specific tile sizes, you can set the arguments on individual TileBinding elements.

Questo esempio crea un payload di notifica che usa la proprietà arguments in modo che la notifica possa essere identificata in un secondo momento.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 */ }
        }
    }
};

Come verificare la proprietà Arguments all'avvio dell'appHow to check for the arguments property when your app launches

La maggior parte delle app dispone di un file App.xaml.cs che contiene una sostituzione per il metodo OnLaunched .Most apps have an App.xaml.cs file that contains an override for the OnLaunched method. Come suggerisce il nome, l'app chiama questo metodo quando viene avviato.As its name suggests, your app calls this method when it's launched. Accetta un solo argomento, un oggetto LaunchActivatedEventArgs .It takes a single argument, a LaunchActivatedEventArgs object.

L'oggetto LaunchActivatedEventArgs dispone di una proprietà che Abilita le notifiche inseguibili: la Proprietà TileActivatedInfo, che fornisce l'accesso a un oggetto TileActivatedInfo.The LaunchActivatedEventArgs object has a property that enables chaseable notifications: the TileActivatedInfo property, which provides access to a TileActivatedInfo object. Quando l'utente avvia l'app dal relativo riquadro, anziché l'elenco di app, la ricerca o qualsiasi altro punto di ingresso, l'app Inizializza questa proprietà.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' oggetto TileActivatedInfo contiene una proprietà denominata RecentlyShownNotifications, che contiene un elenco di notifiche visualizzate sul riquadro negli ultimi 15 minuti.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. Il primo elemento dell'elenco rappresenta la notifica attualmente sul riquadro e gli elementi successivi rappresentano le notifiche che l'utente ha visto prima di quello corrente.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. Se il riquadro è stato cancellato, questo elenco è vuoto.If your tile has been cleared, this list is empty.

Ogni ShownTileNotification dispone di una proprietà arguments.Each ShownTileNotification has an Arguments property. La proprietà Arguments verrà inizializzata con la stringa arguments dal payload di notifica del riquadro oppure null se il payload non include la stringa 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
}

Accesso a OnLaunched dalle applicazioni desktopAccessing OnLaunched from desktop applications

Le app desktop (ad esempio WPF e così via) che usano Desktop Bridgepossono usare anche i riquadri inseguibili.Desktop apps (like WPF, etc) using the Desktop Bridge, can use chaseable tiles too! L'unica differenza è l'accesso agli argomenti OnLaunched.The only difference is accessing the OnLaunched arguments. Si noti che per prima cosa è necessario creare un pacchetto dell'app con desktop Bridge.Note that you first must package your app with the Desktop Bridge.

Importante

Richiede l'aggiornamento del 2018 ottobre : per usare l' AppInstance.GetActivatedEventArgs() API, è necessario fare riferimento a SDK 17763 ed eseguire build 17763 o versione successiva.Requires October 2018 Update : To use the AppInstance.GetActivatedEventArgs() API, you must target SDK 17763 and be running build 17763 or higher.

Per accedere agli argomenti di avvio per le applicazioni desktop, eseguire le operazioni seguenti...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;

Esempio di XML non elaboratoRaw XML example

Se si usa codice XML non elaborato invece della libreria di notifiche, di seguito è riportato il codice 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>