Notificações de blocos rastreáveis
As notificações de bloco rastreáveis permitem que você determine quais notificações de bloco o Bloco Dinâmico do app estava exibindo quando o usuário clicou no bloco.
Por exemplo, um app de notícias pode usar esse recurso para determinar qual notícia o Bloco Dinâmico estava exibindo quando o usuário o inicializou; isso pode garantir que a notícia seja exibida com destaque para que o usuário consiga encontrá-la.
Importante
Requer Atualização de Aniversário: para usar notificações de blocos pesquisáveis com aplicativos UWP baseados em C#, C++ou VB, você deve direcionar o SDK 14393 e executar o build 14393 ou posterior. Para aplicativos UWP baseados em JavaScript, você deve direcionar o SDK 17134 e estar executando o build 17134 ou posterior.
APIs importantes: propriedade LaunchActivatedEventArgs.TileActivatedInfo, classe TileActivatedInfo
Como ele funciona
Para habilitar notificações de bloco rastreáveis, use a propriedade Arguments na carga de notificação de bloco, assim como acontece na propriedade launch na carga de notificação do sistema, para inserir informações sobre o conteúdo na notificação de bloco.
Quando o app for iniciado por meio do Bloco Dinâmico, o sistema retornará uma lista de argumentos nas notificações de bloco atuais/exibidas recentemente.
Quando usar notificações de bloco rastreáveis
As notificações de bloco rastreáveis são normalmente usadas quando você estiver usando a fila de notificação no Bloco Dinâmico (o que significa que você está percorrendo até cinco notificações diferentes). Elas também serão úteis quando o conteúdo do Bloco Dinâmico estiver potencialmente fora de sincronia com o conteúdo mais recente do app. Por exemplo, o app Notícias atualiza o Bloco Dinâmico a cada 30 minutos, mas, quando o app é iniciado, ele carrega as últimas notícias (que pode não incluir algo que estava no bloco a partir do último intervalo de sondagem). Quando isso acontece, o usuário pode ficar frustrado por não conseguir encontrar a notícia que leu no Bloco Dinâmico. É aqui que as notificações de bloco rastreáveis podem ajudar, permitindo que você se certifique de que o que o usuário leu no Bloco pode ser facilmente descoberto.
O que fazer com uma notificação de bloco rastreável
O mais importante a ser observado é que, na maioria dos cenários, você NÃO deve navegar diretamente para a notificação específica que estava no Bloco quando o usuário clicou nele. O Bloco Dinâmico é usado como um ponto de entrada para seu aplicativo. Dois cenários são possíveis quando um usuário clica no Bloco Dinâmico: (1) ele queria iniciar o app normalmente ou (2) queria ver mais informações sobre uma notificação específica que estava no Bloco Dinâmico. Como não há nenhuma maneira de o usuário dizer explicitamente qual comportamento ele deseja, a experiência ideal é iniciar o app normalmente, certificando-se de que a notificação vista pelo usuário pode ser descoberta facilmente.
Por exemplo, clicar no Bloco Dinâmico do app MSN Notícias iniciará o app normalmente: ele exibirá a home page ou qualquer artigo que o usuário tenha lido anteriormente. No entanto, na home page, o app garante que a notícia lida no Bloco Dinâmico poderá ser facilmente descoberta. Dessa forma, os dois cenários têm suporte: o cenário em que você simplesmente deseja a inicialização/retomada do app e o cenário em que você deseja exibir a notícia específica.
Como incluir a propriedade Arguments na carga de notificação do bloco
Em uma carga de notificação, a propriedade arguments permite que o app forneça dados que você pode usar para identificar a notificação posteriormente. Por exemplo, seu argumentos podem incluir a ID da notícia, para que, quando iniciada, você possa recuperá-la e exibi-la. A propriedade aceita uma cadeia de caracteres, que pode ser serializada da forma desejada (cadeia de caracteres de consulta, JSON etc.), mas normalmente recomendamos a cadeia de caracteres de consulta, pois ela é leve e é perfeitamente codificada em XML.
A propriedade pode ser definida nos dois elementos, TileVisual e TileBinding, e será cascateada. Se você quiser os mesmos argumentos em cada tamanho de bloco, basta definir os argumentos no elemento TileVisual. Se você precisar de argumentos específicos para tamanhos de bloco específicos, defina os argumentos em elementos individuais TileBinding.
Este exemplo cria uma carga de notificação que usa a propriedade arguments para que a notificação pode ser identificada mais tarde.
// 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 */ }
}
}
};
Como procurar a propriedade arguments quando o app for iniciado
A maioria dos apps tem um arquivo App.xaml.cs, que contém uma substituição para o método OnLaunched. Como o nome sugere, o app chama esse método quando ele é iniciado. Ele precisa de um único argumento, um objeto LaunchActivatedEventArgs.
O objeto LaunchActivatedEventArgs tem uma propriedade que habilita notificações rastreáveis: a propriedade TileActivatedInfo, que fornece acesso a um objeto TileActivatedInfo. Quando o usuário inicia o app de seu bloco (e não a lista de apps, a pesquisa ou qualquer outro ponto de entrada), o app inicializa essa propriedade.
O objeto TileActivatedInfo contém uma propriedade chamada RecentlyShownNotifications, que contém uma lista de notificações exibida no bloco nos últimos 15 minutos. O primeiro item na lista representa a notificação atual do bloco, enquanto os itens subsequentes representam as notificações que o usuário viu antes da notificação atual. Se o bloco foi limpo, essa lista estará vazia.
Cada ShownTileNotification tem uma propriedade Arguments. A propriedade Arguments será inicializada com a cadeia de caracteres de argumentos da carga de notificação de bloco ou será nula se a carga não tiver incluído a cadeia de caracteres de argumentos.
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
}
Acessando OnLaunched de aplicativos da área de trabalho
Aplicativos da área de trabalho (como WPF, etc.) usando o Ponte de Desktop também podem usar blocos perseguiveis! A única diferença é acessar os argumentos OnLaunched. Observe que primeiro você deve empacotar seu aplicativo com o Ponte de Desktop.
Importante
Requer atualização de outubro de 2018: para usar a API, você deve direcionar o AppInstance.GetActivatedEventArgs() SDK 17763 e estar executando o build 17763 ou posterior.
Para aplicativos da área de trabalho, para acessar os argumentos de inicialização, faça o seguinte...
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;
Exemplo de XML bruto
Se você estiver usando XML bruto, em vez da biblioteca de notificações, este será o XML.
<tile>
<visual arguments="action=storyClicked&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&story=43f939ag&story=201c9b1&story=d9481ca">
<text>Can your dog understand what you're saying?</text>
... (another story)
... (one more story)
</binding>
</visual>
</tile>