Mettre à jour une vignette dynamique à partir d’une tâche en arrière-planUpdate a live tile from a background task

API importantesImportant APIs

Utilisez une tâche en arrière-plan pour mettre à jour une vignette dynamique de votre application avec du contenu actualisé.Use a background task to update your app's live tile with fresh content.

La vidéo suivante montre comment ajouter des vignettes dynamiques à vos applications.Here's a video that shows how to add live tiles to your apps.

Créer le projet de tâche en arrière-planCreate the background task project

Pour activer une vignette dynamique pour votre application, ajoutez un nouveau projet de composant Windows Runtime à votre solution.To enable a live tile for your app, add a new Windows Runtime Component project to your solution. Il s’agit d’un assembly distinct que le système d’exploitation charge et exécute en arrière-plan lorsqu’un utilisateur installe votre application.This is a separate assembly that the OS loads and runs in the background when a user installs your app.

  1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la solution, cliquez sur Ajouter, puis cliquez sur Nouveau projet.In Solution Explorer, right-click the solution, click Add, and then click New Project.
  2. Dans la boîte de dialogue Ajouter un nouveau projet, sélectionnez le modèle Composant Windows Runtime dans la section Installé > Autres langages > 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. Nommez le projet BackgroundTasks, puis cliquez ou appuyez sur OK.Name the project BackgroundTasks and click or tap OK. Microsoft Visual Studio ajoute le nouveau projet à la solution.Microsoft Visual Studio adds the new project to the solution.
  4. Dans le projet principal, ajoutez une référence au projet BackgroundTasks.In the main project, add a reference to the BackgroundTasks project.

Implémenter la tâche en arrière-planImplement the background task

Implémentez l’interface IBackgroundTask pour créer une classe qui met à jour la vignette dynamique de votre application.Implement the IBackgroundTask interface to create a class that updates your app's live tile. Votre tâche en arrière-plan va dans la méthode Run.Your background work goes in the Run method. Dans ce cas, la tâche obtient un flux de syndication pour les blogs MSDN.In this case, the task gets a syndication feed for the MSDN blogs. Pour éviter la fermeture prématurée de la tâche lorsque du code asynchrone est encore en cours d’exécution, obtenez un report.To prevent the task from closing prematurely while asynchronous code is still running, get a deferral.

  1. Dans l’Explorateur de solutions, renommez le fichier généré automatiquement, Class1.cs, sous la forme BlogFeedBackgroundTask.cs.In Solution Explorer, rename the automatically generated file, Class1.cs, to BlogFeedBackgroundTask.cs.
  2. Dans BlogFeedBackgroundTask.cs, remplacez le code généré automatiquement par le code stub pour la classe BlogFeedBackgroundTask.In BlogFeedBackgroundTask.cs, replace the automatically generated code with the stub code for the BlogFeedBackgroundTask class.
  3. Dans l’implémentation de la méthode Run, ajoutez du code pour les méthodes GetMSDNBlogFeed et 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.TileWideText03 );

                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";
    }
}

Configurer le manifeste du packageSet up the package manifest

Pour configurer le manifeste du package, ouvrez-le et ajoutez une nouvelle déclaration de tâche en arrière-plan.To set up the package manifest, open it and add a new background task declaration. Affectez au point d’entrée de la tâche le nom de la classe, y compris son espace de noms.Set the entry point for the task to the class name, including its namespace.

  1. Dans l’Explorateur de solutions, ouvrez Package.appxmanifest.In Solution Explorer, open Package.appxmanifest.
  2. Cliquez ou appuyez sur l’onglet Déclarations.Click or tap the Declarations tab.
  3. Sous Déclarations disponibles, sélectionnez BackgroundTasks, puis cliquez sur Ajouter.Under Available Declarations, select BackgroundTasks and click Add. VisualStudio ajoute BackgroundTasks sous Déclarations prises en charge.Visual Studio adds BackgroundTasks under Supported Declarations.
  4. Sous Types de tâches pris en charge, vérifiez que la case Minuterie est cochée.Under Supported task types, ensure that Timer is checked.
  5. Sous Paramètres de l’application, affectez BackgroundTasks.BlogFeedBackgroundTask au point d’entrée.Under App settings, set the entry point to BackgroundTasks.BlogFeedBackgroundTask.
  6. Cliquez ou appuyez sur l’onglet Interface utilisateur de l’application.Click or tap the Application UI tab.
  7. Affectez à Notifications de verrouillage de l’écran la valeur Badge et texte de mosaïque.Set Lock screen notifications to Badge and Tile Text.
  8. Définissez un chemin d’accès à une icône de 24x24pixels dans le champ Logo du badge.Set a path to a 24x24 pixel icon in the Badge logo field. Important Cette icône doit uniquement utiliser des pixels monochromes et transparents.Important This icon must use monochrome and transparent pixels only.
  9. Dans le champ Petit logo, définissez un chemin d’accès à une icône de 30x30pixels.In the Small logo field, set a path to a 30x30 pixel icon.
  10. Dans le champ Logo large, définissez un chemin d’accès vers une icône de 310x150pixels.In the Wide logo field, set a path to a 310x150 pixel icon.

Inscrire la tâche en arrière-planRegister the background task

Créez un élément BackgroundTaskBuilder pour inscrire votre tâche.Create a BackgroundTaskBuilder to register your task.

Remarque Depuis Windows8.1, les paramètres d’inscription de la tâche en arrière-plan sont validés au moment de l’inscription.Note Starting in Windows 8.1, background task registration parameters are validated at the time of registration. Si l’un des paramètres d’inscription n’est pas valide, une erreur est renvoyée.An error is returned if any of the registration parameters are invalid. Votre application doit être en mesure de gérer les scénarios dans lesquels l’inscription de la tâche en arrière-plan échoue. Par exemple utilisez une instruction conditionnelle pour rechercher les erreurs d’inscription, puis retentez l’inscription qui a échoué avec d’autres valeurs de paramètre.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.

Dans la page principale de votre application, ajoutez la méthode RegisterBackgroundTask et appelez-la dans le gestionnaire d’événements 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 http://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.AllowedMayUseActiveRealTimeConnectivity ||
                backgroundAccessStatus == BackgroundAccessStatus.AllowedWithAlwaysOnRealTimeConnectivity )
            {
                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";
    }
}

Déboguer la tâche en arrière-planDebug the background task

Pour déboguer la tâche en arrière-plan, définissez un point d’arrêt dans la méthode Run de la tâche.To debug the background task, set a breakpoint in the task’s Run method. Dans la barre d’outils Emplacement de débogage, sélectionnez votre tâche en arrière-plan.In the Debug Location toolbar, select your background task. Le système appelle immédiatement la méthode Run.This causes the system to call the Run method immediately.

  1. Définissez un point d’arrêt dans la méthode Run de la tâche.Set a breakpoint in the task’s Run method.
  2. Appuyez sur F5 ou sur Déboguer > Démarrer le débogage pour déployer et exécuter l’application.Press F5 or tap Debug > Start Debugging to deploy and run the app.
  3. Une fois l’application lancée, revenez à VisualStudio.After the app launches, switch back to Visual Studio.
  4. Vérifiez que la barre d’outils Emplacement de débogage est visible.Ensure that the Debug Location toolbar is visible. Elle se trouve dans le menu Affichage > Barres d’outils.It's on the View > Toolbars menu.
  5. Dans la barre d’outils Emplacement de débogage, cliquez sur la liste déroulante Interrompre et sélectionnez BlogFeedBackgroundTask.On the Debug Location toolbar, click the Suspend dropdown and select BlogFeedBackgroundTask.
  6. VisualStudio interrompt l’exécution au niveau du point d’arrêt.Visual Studio suspends execution at the breakpoint.
  7. Appuyez sur F5 ou sur Déboguer > Continuer pour continuer à exécuter l’application.Press F5 or tap Debug > Continue to continue running the app.
  8. Appuyez sur Maj+F5 ou sur Déboguer > Arrêter le débogage pour arrêter le débogage.Press Shift+F5 or tap Debug > Stop Debugging to stop debugging.
  9. Revenez à la vignette de l’application sur l’écran d’accueil.Return to the app's tile on the Start screen. Après quelques secondes, les notifications par vignette apparaissent sur la vignette de votre application.After a few seconds, tile notifications appear on your app's tile.