Actualizar un icono dinámico desde una tarea en segundo planoUpdate a live tile from a background task

API importantesImportant APIs

Usa una tarea en segundo plano para actualizar el icono dinámico de tu aplicación con contenido actualizado.Use a background task to update your app's live tile with fresh content.

Este vídeo te muestra cómo agregar iconos dinámicos a tus aplicaciones.Here's a video that shows how to add live tiles to your apps.

Crear el proyecto de tareas en segundo planoCreate the background task project

Para habilitar un icono dinámico para la aplicación, agregue un nuevo Windows Runtime proyecto de componente a la solución.To enable a live tile for your app, add a new Windows Runtime component project to your solution. Este es un ensamblado independiente que el sistema operativo carga y ejecuta en segundo plano cuando un usuario instala tu aplicación.This is a separate assembly that the OS loads and runs in the background when a user installs your app.

  1. En el Explorador de soluciones, haga clic con el botón derecho en la solución; luego, en Agregar y en Nuevo proyecto.In Solution Explorer, right-click the solution, click Add, and then click New Project.
  2. En el cuadro de diálogo Agregar nuevo proyecto , seleccione la plantilla de componentes de Windows Runtime en la sección ** > > > Windows universal de otros lenguajes instalados Visual C#** .In the Add New Project dialog, select the Windows Runtime Component template in the Installed > Other Languages > Visual C# > Windows Universal section.
  3. Asigna el nombre BackgroundTasks al proyecto y haz clic o pulsa Aceptar.Name the project BackgroundTasks and click or tap OK. Microsoft Visual Studio agrega el nuevo proyecto a la solución.Microsoft Visual Studio adds the new project to the solution.
  4. En el proyecto principal, agrega una referencia al proyecto BackgroundTasks.In the main project, add a reference to the BackgroundTasks project.

Implementar la tarea en segundo planoImplement the background task

Implementa la interfaz IBackgroundTask para crear una clase que actualice el icono dinámico de tu aplicación.Implement the IBackgroundTask interface to create a class that updates your app's live tile. El trabajo en segundo plano se incluye en el método Run.Your background work goes in the Run method. En este caso, la tarea obtiene una fuente de distribución para los blogs de MSDN.In this case, the task gets a syndication feed for the MSDN blogs. Para impedir que la tarea se cierre de forma prematura mientras aún se ejecuta el código asincrónico, obtén un aplazamiento.To prevent the task from closing prematurely while asynchronous code is still running, get a deferral.

  1. En el Explorador de soluciones, cambia el nombre del archivo generado automáticamente, Class1.cs, a BlogFeedBackgroundTask.cs.In Solution Explorer, rename the automatically generated file, Class1.cs, to BlogFeedBackgroundTask.cs.
  2. En BlogFeedBackgroundTask.cs, reemplaza el código generado automáticamente con el código auxiliar de la clase BlogFeedBackgroundTask.In BlogFeedBackgroundTask.cs, replace the automatically generated code with the stub code for the BlogFeedBackgroundTask class.
  3. En la implementación del método Run, agrega código para los métodos GetMSDNBlogFeed y 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 el manifiesto del paqueteSet up the package manifest

Para configurar el manifiesto del paquete, ábrelo y agrégale una nueva declaración de tarea en segundo plano.To set up the package manifest, open it and add a new background task declaration. Establece el punto de entrada de la tarea en el nombre de la clase, incluido su espacio de nombres.Set the entry point for the task to the class name, including its namespace.

  1. Abre "Package.appxmanifest" en el Explorador de soluciones.In Solution Explorer, open Package.appxmanifest.
  2. Haz clic o pulsa en la pestaña Declaraciones .Click or tap the Declarations tab.
  3. En Declaraciones disponibles, selecciona BackgroundTasks y haz clic en Agregar.Under Available Declarations, select BackgroundTasks and click Add. Visual Studio agrega BackgroundTasks en Declaraciones admitidas.Visual Studio adds BackgroundTasks under Supported Declarations.
  4. En Tipos de tareas admitidos, asegúrate de que esté activado Temporizador.Under Supported task types, ensure that Timer is checked.
  5. En Configuración de la aplicación, establece el punto de entrada en BackgroundTasks.BlogFeedBackgroundTask.Under App settings, set the entry point to BackgroundTasks.BlogFeedBackgroundTask.
  6. Haz clic o pulsa en la pestaña IU de la aplicación.Click or tap the Application UI tab.
  7. Establece Notificaciones de pantallas de bloqueo en Distintivo y texto de imagen.Set Lock screen notifications to Badge and Tile Text.
  8. Establece una ruta de acceso en un icono de 24 x 24 píxeles en el campo Logotipo del distintivo .Set a path to a 24x24 pixel icon in the Badge logo field. Importante    Este icono debe usar solo píxeles monocromáticos y transparentes.Important  This icon must use monochrome and transparent pixels only.
  9. En el campo Logotipo pequeño, establece una ruta de acceso en un icono de 30 x 30 píxeles.In the Small logo field, set a path to a 30x30 pixel icon.
  10. En el campo Logotipo ancho , establece una ruta de acceso a un icono de 310 x 150 píxeles.In the Wide logo field, set a path to a 310x150 pixel icon.

Registrar la tarea en segundo planoRegister the background task

Crea un BackgroundTaskBuilder para registrar tu tarea.Create a BackgroundTaskBuilder to register your task.

Nota:    A partir de Windows 8.1, los parámetros de registro de tareas en segundo plano se validan en el momento del registro.Note  Starting in Windows 8.1, background task registration parameters are validated at the time of registration. Se devuelve un error si cualquiera de los parámetros de registro no es válido.An error is returned if any of the registration parameters are invalid. La aplicación debe poder enfrentarse a los escenarios en que se produce un error en el registro de tareas en segundo plano. Por ejemplo, usa una instrucción condicional para comprobar si hay errores de registro y después vuelve a probar el registro con errores con 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.  

En la página principal de tu aplicación, agrega el método RegisterBackgroundTask y llámalo en el controlador 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 la tarea en segundo planoDebug the background task

Para depurar la tarea en segundo plano, establece un punto de interrupción en el método Run de la tarea.To debug the background task, set a breakpoint in the task’s Run method. En la barra de herramientas Ubicación de depuración, selecciona tu tarea en segundo plano.In the Debug Location toolbar, select your background task. Esto hace que el sistema llame al método Run inmediatamente.This causes the system to call the Run method immediately.

  1. Establece un punto de interrupción en el método Run de la tarea.Set a breakpoint in the task’s Run method.
  2. Presiona F5 o pulsa Depurar > Iniciar depuración para implementar y ejecutar la aplicación.Press F5 or tap Debug > Start Debugging to deploy and run the app.
  3. Una vez iniciada la aplicación, vuelve a Visual Studio.After the app launches, switch back to Visual Studio.
  4. Asegúrate de que la barra de herramientas Ubicación de depuración aparezca visible.Ensure that the Debug Location toolbar is visible. Se encuentra en el menú Ver > Barras de herramientas.It's on the View > Toolbars menu.
  5. En la barra de herramientas Ubicación de depuración , haz clic en la lista desplegable Suspender y selecciona BlogFeedBackgroundTask.On the Debug Location toolbar, click the Suspend dropdown and select BlogFeedBackgroundTask.
  6. Visual Studio suspende la ejecución en el punto de interrupción.Visual Studio suspends execution at the breakpoint.
  7. Presiona F5 o pulsa Depurar > Continuar para continuar con la ejecución de la aplicación.Press F5 or tap Debug > Continue to continue running the app.
  8. Presiona Mayús+F5 o pulsa Depurar > Detener depuración para detener la depuración.Press Shift+F5 or tap Debug > Stop Debugging to stop debugging.
  9. Regresa al icono de la aplicación en la pantalla Inicio.Return to the app's tile on the Start screen. Tras unos pocos segundos, aparecerán notificaciones de icono en el icono de tu aplicación.After a few seconds, tile notifications appear on your app's tile.