Atualizar um bloco dinâmico de uma tarefa em segundo planoUpdate a live tile from a background task

APIs importantesImportant APIs

Use uma tarefa em segundo plano para atualizar o bloco dinâmico de seu aplicativo com novo conteúdo.Use a background task to update your app's live tile with fresh content.

Veja um vídeo que mostra como adicionar blocos dinâmicos aos aplicativos.Here's a video that shows how to add live tiles to your apps.

Criar o projeto de tarefa em segundo planoCreate the background task project

Para habilitar um bloco dinâmico para seu aplicativo, adicione um novo projeto de componente Windows Runtime à sua solução.To enable a live tile for your app, add a new Windows Runtime component project to your solution. Trata-se de um assembly separado, que o SO carrega e executa em segundo plano quando um usuário instala o aplicativo.This is a separate assembly that the OS loads and runs in the background when a user installs your app.

  1. No Gerenciador de Soluções, clique com o botão direito na solução, clique em Adicionar e em Novo Projeto.In Solution Explorer, right-click the solution, click Add, and then click New Project.
  2. Na caixa de diálogo Adicionar Novo Projeto, selecione o modelo Componente do Tempo de Execução do Windows na seção Instalado > Outros idiomas > Visual C# > Windows Universal.In the Add New Project dialog, select the Windows Runtime Component template in the Installed > Other Languages > Visual C# > Windows Universal section.
  3. Chame o projeto de BackgroundTasks e clique ou toque em OK.Name the project BackgroundTasks and click or tap OK. O Microsoft Visual Studio adiciona o novo projeto à solução.Microsoft Visual Studio adds the new project to the solution.
  4. No projeto principal, adicione uma referência ao projeto BackgroundTasks.In the main project, add a reference to the BackgroundTasks project.

Implementar a tarefa em segundo planoImplement the background task

Implemente a interface de IBackgroundTask para criar uma classe que atualize o bloco dinâmico de seu aplicativo.Implement the IBackgroundTask interface to create a class that updates your app's live tile. A operação em segundo plano ocorre no método Run.Your background work goes in the Run method. Neste caso, a tarefa obtém um feed de sindicalização para os blogs do MSDN.In this case, the task gets a syndication feed for the MSDN blogs. Para impedir que a tarefa feche antecipadamente enquanto o código assíncrono ainda está em execução, obtenha um adiamento.To prevent the task from closing prematurely while asynchronous code is still running, get a deferral.

  1. No Gerenciador de Soluções, renomeie o arquivo gerado automaticamente, Class1.cs, para BlogFeedBackgroundTask.cs.In Solution Explorer, rename the automatically generated file, Class1.cs, to BlogFeedBackgroundTask.cs.
  2. Em BlogFeedBackgroundTask.cs, substitua o código gerado automaticamente pelo código do stub para a classe BlogFeedBackgroundTask.In BlogFeedBackgroundTask.cs, replace the automatically generated code with the stub code for the BlogFeedBackgroundTask class.
  3. Na implementação do método Run, adicione o código dos métodos GetMSDNBlogFeed e UpdateTile.In the Run method implementation, add code for the GetMSDNBlogFeed and UpdateTile methods.
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

// Added during quickstart
using Windows.ApplicationModel.Background;
using Windows.Data.Xml.Dom;
using Windows.UI.Notifications;
using Windows.Web.Syndication;

namespace BackgroundTasks
{
    public sealed class BlogFeedBackgroundTask  : IBackgroundTask
    {
        public async void Run( IBackgroundTaskInstance taskInstance )
        {
            // Get a deferral, to prevent the task from closing prematurely
            // while asynchronous code is still running.
            BackgroundTaskDeferral deferral = taskInstance.GetDeferral();

            // Download the feed.
            var feed = await GetMSDNBlogFeed();

            // Update the live tile with the feed items.
            UpdateTile( feed );

            // Inform the system that the task is finished.
            deferral.Complete();
        }

        private static async Task<SyndicationFeed> GetMSDNBlogFeed()
        {
            SyndicationFeed feed = null;

            try
            {
                // Create a syndication client that downloads the feed.  
                SyndicationClient client = new SyndicationClient();
                client.BypassCacheOnRetrieve = true;
                client.SetRequestHeader( customHeaderName, customHeaderValue );

                // Download the feed.
                feed = await client.RetrieveFeedAsync( new Uri( feedUrl ) );
            }
            catch( Exception ex )
            {
                Debug.WriteLine( ex.ToString() );
            }

            return feed;
        }

        private static void UpdateTile( SyndicationFeed feed )
        {
            // Create a tile update manager for the specified syndication feed.
            var updater = TileUpdateManager.CreateTileUpdaterForApplication();
            updater.EnableNotificationQueue( true );
            updater.Clear();

            // Keep track of the number feed items that get tile notifications.
            int itemCount = 0;

            // Create a tile notification for each feed item.
            foreach( var item in feed.Items )
            {
                XmlDocument tileXml = TileUpdateManager.GetTemplateContent( TileTemplateType.TileWide310x150Text03 );

                var title = item.Title;
                string titleText = title.Text == null ? String.Empty : title.Text;
                tileXml.GetElementsByTagName( textElementName )[0].InnerText = titleText;

                // Create a new tile notification.
                updater.Update( new TileNotification( tileXml ) );

                // Don't create more than 5 notifications.
                if( itemCount++ > 5 ) break;
            }
        }

        // Although most HTTP servers do not require User-Agent header, others will reject the request or return
        // a different response if this header is missing. Use SetRequestHeader() to add custom headers.
        static string customHeaderName = "User-Agent";
        static string customHeaderValue = "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)";

        static string textElementName = "text";
        static string feedUrl = @"http://blogs.msdn.com/b/MainFeed.aspx?Type=BlogsOnly";
    }
}

Configurar o manifesto do pacoteSet up the package manifest

Para configurar o manifesto do pacote, abra-o e adicione uma nova declaração de tarefa em segundo plano.To set up the package manifest, open it and add a new background task declaration. Configure o ponto de entrada da tarefa para o nome da classe, inclusive seu namespace.Set the entry point for the task to the class name, including its namespace.

  1. No Gerenciador de Soluções, abra Package.appxmanifest.In Solution Explorer, open Package.appxmanifest.
  2. Clique ou toque na guia Declarações.Click or tap the Declarations tab.
  3. Em Declarações Disponíveis, selecione BackgroundTasks e clique em Adicionar.Under Available Declarations, select BackgroundTasks and click Add. O Visual Studio adiciona BackgroundTasks a Declarações Suportadas.Visual Studio adds BackgroundTasks under Supported Declarations.
  4. Em Tipos de tarefa suportados, certifique-se de que Temporizador esteja marcado.Under Supported task types, ensure that Timer is checked.
  5. Em Configurações de aplicativo, defina o ponto de entrada como BackgroundTasks.BlogFeedBackgroundTask.Under App settings, set the entry point to BackgroundTasks.BlogFeedBackgroundTask.
  6. Clique ou toque na guia Interface de Usuário do Aplicativo.Click or tap the Application UI tab.
  7. Defina Notificações de tela de bloqueio como Notificação e Texto de Bloco.Set Lock screen notifications to Badge and Tile Text.
  8. Defina um caminho como um ícone de 24 x 24 pixels no campo Logotipo de notificação .Set a path to a 24x24 pixel icon in the Badge logo field. Importante    Este ícone deve usar apenas pixels monocromáticos e transparentes.Important  This icon must use monochrome and transparent pixels only.
  9. No campo Logotipo pequeno, defina um caminho como um ícone de 30 x 30 pixels.In the Small logo field, set a path to a 30x30 pixel icon.
  10. No campo Logotipo largo , defina um caminho como um ícone de 310 x 150 pixels.In the Wide logo field, set a path to a 310x150 pixel icon.

Registrar a tarefa em segundo planoRegister the background task

Crie um BackgroundTaskBuilder para registrar a tarefa.Create a BackgroundTaskBuilder to register your task.

Observação    A partir do Windows 8.1, os parâmetros de registro da tarefa em segundo plano são validados no momento do registro.Note  Starting in Windows 8.1, background task registration parameters are validated at the time of registration. Um erro será retornado se algum parâmetro de registro for inválido.An error is returned if any of the registration parameters are invalid. Seu aplicativo deve ser capaz de manipular cenários em que o registro de tarefas em segundo plano apresenta falha, por exemplo, use uma instrução condicional para verificar se há erros de registro e tente novamente o registro com falha usando valores de parâmetros diferentes.Your app must be able to handle scenarios where background task registration fails - for example, use a conditional statement to check for registration errors and then retry failed registration using different parameter values.  

Na página principal de seu aplicativo, adicione o método RegisterBackgroundTask e chame-o no manipulador de eventos OnNavigatedTo.In your app's main page, add the RegisterBackgroundTask method and call it in the OnNavigatedTo event handler.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Windows.ApplicationModel.Background;
using Windows.Data.Xml.Dom;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
using Windows.Web.Syndication;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/p/?LinkID=234238

namespace ContosoApp
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        public MainPage()
        {
            this.InitializeComponent();
        }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        protected override void OnNavigatedTo( NavigationEventArgs e )
        {
            this.RegisterBackgroundTask();
        }


        private async void RegisterBackgroundTask()
        {
            var backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
            if( backgroundAccessStatus == BackgroundAccessStatus.AllowedSubjectToSystemPolicy ||
                backgroundAccessStatus == BackgroundAccessStatus.AlwaysAllowed )
            {
                foreach( var task in BackgroundTaskRegistration.AllTasks )
                {
                    if( task.Value.Name == taskName )
                    {
                        task.Value.Unregister( true );
                    }
                }

                BackgroundTaskBuilder taskBuilder = new BackgroundTaskBuilder();
                taskBuilder.Name = taskName;
                taskBuilder.TaskEntryPoint = taskEntryPoint;
                taskBuilder.SetTrigger( new TimeTrigger( 15, false ) );
                var registration = taskBuilder.Register();
            }
        }

        private const string taskName = "BlogFeedBackgroundTask";
        private const string taskEntryPoint = "BackgroundTasks.BlogFeedBackgroundTask";
    }
}

Depurar a tarefa em segundo planoDebug the background task

Para depurar a tarefa em segundo plano, defina um ponto de interrupção no método Run da tarefa.To debug the background task, set a breakpoint in the task’s Run method. Na barra de tarefas Local do Depurador, selecione a tarefa em segundo plano.In the Debug Location toolbar, select your background task. Isso fará com que o sistema chame o método Run imediatamente.This causes the system to call the Run method immediately.

  1. Defina um ponto de interrupção no método Run da tarefa.Set a breakpoint in the task’s Run method.
  2. Pressione F5 ou toque em Depurar > Iniciar Depuração para implantar e executar o aplicativo.Press F5 or tap Debug > Start Debugging to deploy and run the app.
  3. Depois que o aplicativo iniciar, volte para o Visual Studio.After the app launches, switch back to Visual Studio.
  4. Verifique se a barra de ferramentas Local do Depurador está visível.Ensure that the Debug Location toolbar is visible. Ela está no menu Exibir > Barras de Ferramentas.It's on the View > Toolbars menu.
  5. Na barra de ferramentas Local do Depurador , clique na lista suspensa Suspender e selecione BlogFeedBackgroundTask.On the Debug Location toolbar, click the Suspend dropdown and select BlogFeedBackgroundTask.
  6. O Visual Studio suspenderá a execução no ponto de interrupção.Visual Studio suspends execution at the breakpoint.
  7. Pressione F5 ou toque em Depurar > Continuar para continuar a executar o aplicativo.Press F5 or tap Debug > Continue to continue running the app.
  8. Pressione Shift+F5 ou toque em Depurar > Parar Depuração para parar a depuração.Press Shift+F5 or tap Debug > Stop Debugging to stop debugging.
  9. Retorne ao bloco do aplicativo na tela inicial.Return to the app's tile on the Start screen. Após alguns segundos, as notificações do bloco serão exibidas no bloco do aplicativo.After a few seconds, tile notifications appear on your app's tile.