Een live-tegel bijwerken vanaf een achtergrondtaak

Opmerking

Live Tiles zijn een Windows 10-functie die niet wordt ondersteund in latere versies van Windows. Voor nieuwe apps wordt u aangeraden de huidige richtlijnen voor app-pictogrammen te volgen.

Gebruik een achtergrondtaak om de livetegel van uw app bij te werken met nieuwe inhoud.

Belangrijke API's

Het achtergrondtaakproject maken

Als u een live-tegel voor uw app wilt inschakelen, voegt u een nieuw Windows Runtime-onderdeelproject toe aan uw oplossing. Dit is een afzonderlijke assembly die het besturingssysteem op de achtergrond laadt en uitvoert wanneer een gebruiker uw app installeert.

  1. Klik in Solution Explorer met de rechtermuisknop op de oplossing, klik op toevoegen en klik vervolgens op Nieuw project.
  2. Selecteer in het dialoogvenster Nieuw project toevoegen de sjabloon Windows Runtime-component in de sectie Geïnstalleerd > Andere talen > Visual C# > Windows Universeel.
  3. Geef het project de naam BackgroundTasks en klik of tik op OK-. Microsoft Visual Studio voegt het nieuwe project toe aan de oplossing.
  4. Voeg in het hoofdproject een verwijzing toe naar het BackgroundTasks-project.

De achtergrondtaak implementeren

Implementeer de interface IBackgroundTask om een klasse te maken waarmee de livetegel van uw app wordt bijgewerkt. Uw achtergrondwerk gaat in de Run-methode. In dit geval krijgt de taak een syndicatiefeed voor de MSDN-blogs. Als u wilt voorkomen dat de taak voortijdig wordt gesloten terwijl asynchrone code nog steeds wordt uitgevoerd, haalt u een uitstel op.

  1. Wijzig in Solution Explorer de naam van het automatisch gegenereerde bestand, Class1.cs, in BlogFeedBackgroundTask.cs.
  2. Vervang in BlogFeedBackgroundTask.cs de automatisch gegenereerde code door de stub-code voor de BlogFeedBackgroundTask klasse.
  3. Voeg in de implementatie van de methode Uitvoeren code toe voor de GetMSDNBlogFeed- en UpdateTile methoden.
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";
    }
}

Het pakketmanifest instellen

Als u het pakketmanifest wilt instellen, opent u het en voegt u een nieuwe achtergrondtaakdeclaratie toe. Stel het invoerpunt voor de taak in op de klassenaam, inclusief de naamruimte.

  1. Open Package.appxmanifest in Solution Explorer.
  2. Klik of tik op het tabblad Declaraties.
  3. Selecteer onder Beschikbare declaratiesBackgroundTasks en klik op toevoegen. Visual Studio voegt BackgroundTasks toe onder Ondersteunde Declaraties.
  4. Controleer onder Ondersteunde taaktypenof Timer is aangevinkt.
  5. Stel onder App-instellingenhet toegangspunt in op BackgroundTasks.BlogFeedBackgroundTask.
  6. Klik of tik op het tabblad Applicatie-UI.
  7. Stel Vergrendelingsschermmeldingen in op badge- en tegeltekst.
  8. Stel een pad in naar een 24x24 pixel pictogram in het badge-logo veld. Belangrijk Dit pictogram mag alleen monochrome en transparante pixels gebruiken.
  9. Stel in het veld Klein logo een pad in naar een pictogram van 30 x 30 pixels.
  10. Stel in het veld Wide-logo een pad in naar een pictogram van 310x150 pixels.

De achtergrondtaak registreren

Maak een BackgroundTaskBuilder om uw taak te registreren.

Opmerking Vanaf Windows 8.1 worden registratieparameters voor achtergrondtaken gevalideerd op het moment van registratie. Er wordt een fout geretourneerd als een van de registratieparameters ongeldig is. Uw app moet scenario's kunnen afhandelen waarbij de registratie van achtergrondtaken mislukt. Gebruik bijvoorbeeld een voorwaardelijke instructie om te controleren op registratiefouten en probeer de registratie vervolgens opnieuw uit te voeren met behulp van verschillende parameterwaarden.  

Voeg op de hoofdpagina van uw app de methode RegisterBackgroundTask toe en roep deze aan in de OnNavigatedTo gebeurtenishandler.

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

Fouten opsporen in de achtergrondtaak

Als u fouten wilt opsporen in de achtergrondtaak, stelt u een onderbrekingspunt in de methode Uitvoeren van de taak in. Selecteer uw achtergrondtaak in de Debuglocatie werkbalk. Dit zorgt ervoor dat het systeem de Run-methode onmiddellijk aanroept.

  1. Stel een onderbrekingspunt in de methode Uitvoeren van de taak in.
  2. Druk op F5 of tik op Foutopsporing > Start Foutopsporing om de app te implementeren en uit te voeren.
  3. Nadat de app is gestart, gaat u terug naar Visual Studio.
  4. Zorg ervoor dat de werkbalk Locatie voor foutopsporing zichtbaar is. Deze bevindt zich in het menu Weergave > Werkbalken.
  5. Klik op de werkbalk Locatie voor foutopsporing op de vervolgkeuzelijst Onderbreken en selecteer BlogFeedBackgroundTask-.
  6. Visual Studio onderbreekt de uitvoering op het onderbrekingspunt.
  7. Druk op F5 of tik op Debug > Continue om door te gaan met het uitvoeren van de app.
  8. Druk op Shift+F5 of tik op Fouten opsporen > Foutopsporing stoppen om foutopsporing te stoppen.
  9. Ga terug naar de tegel van de app op het startscherm. Na enkele seconden worden tegelmeldingen weergegeven op de tegel van uw app.
  • Last updated on