Atualizar um bloco dinâmico de uma tarefa em segundo plano

Use uma tarefa em segundo plano para atualizar o bloco dinâmico de seu aplicativo com novo conteúdo.

APIs importantes

• IBackgroundTask
• BackgroundTaskBuilder

Criar o projeto de tarefa em segundo plano

Para habilitar um bloco dinâmico para seu aplicativo, adicione um novo projeto de componente do Tempo de Execução do Windows à sua solução. Esse é um assembly separado que o sistema operacional carrega e executa em segundo plano quando um usuário instala seu aplicativo.

1. No Gerenciador de Soluções, clique com o botão direito na solução, clique em Adicionar e em Novo Projeto.
2. Na caixa de diálogo Adicionar Novo Projeto, selecione o modelo Componente do Tempo de Execução do Windows na seção Visual C# > Windows Universal de Outras Linguagens > Instaladas>.
3. Nomeie o projeto como BackgroundTasks e clique ou toque em OK. O Microsoft Visual Studio adiciona o novo projeto à solução.
4. No projeto principal, adicione uma referência ao projeto BackgroundTasks.

Implementar a tarefa em segundo plano

Implemente a interface IBackgroundTask para criar uma classe que atualize o bloco dinâmico do aplicativo. Seu trabalho em segundo plano vai no método Run. Nesse caso, a tarefa obtém um feed de distribuição para os blogs do MSDN. Para evitar que a tarefa seja fechada prematuramente enquanto o código assíncrono ainda estiver em execução, obtenha um adiamento.

1. No Gerenciador de Soluções, renomeie o arquivo gerado automaticamente, Class1.cs, para BlogFeedBackgroundTask.cs.
2. Em BlogFeedBackgroundTask.cs, substitua o código gerado automaticamente pelo código de stub para a classe BlogFeedBackgroundTask .
3. Na implementação do método Run, adicione código para os métodos GetMSDNBlogFeed e UpdateTile .

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 pacote

Para configurar o manifesto do pacote, abra-o e adicione uma nova declaração de tarefa em segundo plano. Defina o ponto de entrada da tarefa como o nome da classe, incluindo seu namespace.

1. No Gerenciador de Soluções, abra Package.appxmanifest.
2. Clique ou toque na guia Declarações .
3. Em Declarações Disponíveis, selecione BackgroundTasks e clique em Adicionar. O Visual Studio adiciona BackgroundTasks em Declarações com suporte.
4. Em Tipos de tarefa com suporte, verifique se o Temporizador está marcado.
5. Em Configurações do aplicativo, defina o ponto de entrada como BackgroundTasks.BlogFeedBackgroundTask.
6. Clique ou toque na guia Interface do usuário do aplicativo.
7. Defina as notificações da tela de bloqueio como Notificação e Texto do bloco.
8. Defina um caminho para um ícone de 24 x 24 pixels no campo Logotipo do selo. Importante Este ícone deve usar apenas pixels monocromáticos e transparentes.
9. No campo Logotipo pequeno, defina um caminho para um ícone de 30 x 30 pixels.
10. No campo Logotipo largo, defina um caminho para um ícone de 310 x 150 pixels.

Registrar a tarefa em segundo plano

Crie um BackgroundTaskBuilder para registrar sua tarefa.

Observação A partir do Windows 8.1, os parâmetros de registro de tarefa em segundo plano são validados no momento do registro. Um erro será retornado se qualquer um dos parâmetros de registro for inválido. Seu aplicativo deve ser capaz de lidar com cenários em que o registro de tarefas em segundo plano falha, por exemplo, use uma instrução condicional para verificar se há erros de registro e, em seguida, repita o registro com falha usando valores de parâmetro diferentes.  

Na página principal do aplicativo, adicione o método RegisterBackgroundTask e chame-o no manipulador de eventos OnNavigatedTo .

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 plano

Para depurar a tarefa em segundo plano, defina um ponto de interrupção no método Run da tarefa. Na barra de ferramentas Local de Depuração, selecione sua tarefa em segundo plano. Isso faz com que o sistema chame o método Run imediatamente.

1. Defina um ponto de interrupção no método Run da tarefa.
2. Pressione F5 ou toque em Depurar > Iniciar Depuração para implantar e executar o aplicativo.
3. Depois que o aplicativo for iniciado, volte para o Visual Studio.
4. Verifique se a barra de ferramentas Local de Depuração está visível. Essa opção está no menu Exibir > barras de ferramentas.
5. Na barra de ferramentas Local de Depuração, clique na lista suspensa Suspender e selecione BlogFeedBackgroundTask.
6. O Visual Studio suspende a execução no ponto de interrupção.
7. Pressione F5 ou toque em Depurar > Continuar para continuar executando o aplicativo.
8. Pressione Shift+F5 ou toque em Depurar > Parar Depuração para interromper a depuração.
9. Retorne ao bloco do aplicativo na tela inicial. Após alguns segundos, as notificações de bloco aparecem no bloco do seu aplicativo.

Tópicos relacionados

• BackgroundTaskBuilder
• TileUpdateManager
• TileNotification
• Dar suporte ao seu aplicativo com tarefas em segundo plano