Aktualisieren einer Live-Kachel über eine Hintergrundaufgabe

Hinweis

Live-Kacheln sind ein Windows 10-Feature, das in späteren Versionen von Windows nicht unterstützt wird. Für neue Apps wird empfohlen, die aktuellen Anleitungen für App-Symbole zu befolgen.

Verwenden Sie eine Hintergrundaufgabe, um die Live-Kachel Ihrer App mit neuen Inhalten zu aktualisieren.

Wichtige APIs

• IBackgroundTask
• BackgroundTaskBuilder

Erstellen des Hintergrundaufgabenprojekts

Um eine Live-Kachel für Ihre App zu aktivieren, fügen Sie Ihrer Lösung ein neues Windows-Runtime Komponentenprojekt hinzu. Dies ist eine separate Assembly, die vom Betriebssystem geladen und im Hintergrund ausgeführt wird, wenn ein Benutzer Ihre App installiert.

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, und klicken Sie dann auf Hinzufügen und Neues Projekt.
2. Wählen Sie im Dialogfeld "Neues Projekt hinzufügen" die Vorlage "Windows-Runtime Komponente" im Abschnitt "Installierte > andere Sprachen > Visual C# > Windows Universal" aus.
3. Benennen Sie das Projekt "BackgroundTasks", und klicken oder tippen Sie auf "OK". Microsoft Visual Studio fügt das neue Projekt der Projektmappe hinzu.
4. Fügen Sie im Hauptprojekt einen Verweis auf das BackgroundTasks-Projekt hinzu.

Implementieren der Hintergrundaufgabe

Implementieren Sie die IBackgroundTask-Schnittstelle , um eine Klasse zu erstellen, die die Live-Kachel Ihrer App aktualisiert. Ihre Hintergrundarbeit wird in die Run-Methode aufgenommen. In diesem Fall ruft die Aufgabe einen Veröffentlichungsfeed für die MSDN-Blogs ab. Um zu verhindern, dass die Aufgabe vorzeitig geschlossen wird, während noch asynchroner Code ausgeführt wird, rufen Sie eine Verzögerung ab.

1. Benennen Sie in Projektmappen-Explorer die automatisch generierte Datei Class1.cs in BlogFeedBackgroundTask.cs um.
2. Ersetzen Sie in BlogFeedBackgroundTask.cs den automatisch generierten Code durch den Stubcode für die BlogFeedBackgroundTask-Klasse .
3. Fügen Sie in der Run-Methodenimplementierung Code für die Methoden "GetMSDNBlogFeed " und "UpdateTile " hinzu.

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

Einrichten des Paketmanifests

Um das Paketmanifest einzurichten, öffnen Sie es, und fügen Sie eine neue Hintergrundaufgabendeklaration hinzu. Legen Sie den Einstiegspunkt für die Aufgabe auf den Klassennamen fest, einschließlich des Namespaces.

1. Öffnen Sie in Projektmappen-Explorer "Package.appxmanifest".
2. Klicken oder tippen Sie auf die Registerkarte "Deklarationen ".
3. Wählen Sie unter "Verfügbare Deklarationen" "BackgroundTasks" aus, und klicken Sie auf "Hinzufügen". Visual Studio fügt "BackgroundTasks" unter "Unterstützte Deklarationen" hinzu.
4. Stellen Sie unter "Unterstützte Aufgabentypen" sicher, dass der Timer aktiviert ist.
5. Legen Sie unter "App-Einstellungen" den Einstiegspunkt auf "BackgroundTasks.BlogFeedBackgroundTask" fest.
6. Klicken oder tippen Sie auf die Registerkarte "Benutzeroberfläche der Anwendung".
7. Legen Sie Sperrbildschirmbenachrichtigungen auf Signal- und Kacheltext fest.
8. Legen Sie einen Pfad zu einem Symbol mit 24 x 24 Pixel im Feld "Signallogo " fest. Wichtig Dieses Symbol darf nur monochrome und transparente Pixel verwenden.
9. Legen Sie im Feld "Kleines Logo " einen Pfad zu einem Symbol mit 30 x 30 Pixel fest.
10. Legen Sie im Feld "Breites Logo " einen Pfad zu einem Symbol mit 310 x 150 Pixel fest.

Registrieren der Hintergrundaufgabe

Erstellen Sie einen BackgroundTaskBuilder , um Ihre Aufgabe zu registrieren.

Hinweis Ab Windows 8.1 werden die Registrierungsparameter für Hintergrundaufgaben zum Zeitpunkt der Registrierung überprüft. Wenn einer der Registrierungsparameter ungültig ist, wird ein Fehler zurückgegeben. Ihre App muss Szenarien behandeln können, in denen die Registrierung von Hintergrundaufgaben fehlschlägt . Verwenden Sie z. B. eine bedingte Anweisung, um auf Registrierungsfehler zu überprüfen und dann die fehlgeschlagene Registrierung mit unterschiedlichen Parameterwerten erneut zu versuchen.  

Fügen Sie auf der Hauptseite Der App die RegisterBackgroundTask-Methode hinzu, und rufen Sie sie im OnNavigatedTo-Ereignishandler auf.

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

Debuggen der Hintergrundaufgabe

Um die Hintergrundaufgabe zu debuggen, legen Sie einen Haltepunkt in der Run-Methode der Aufgabe fest. Wählen Sie auf der Symbolleiste "Debugspeicherort " Die Hintergrundaufgabe aus. Dies bewirkt, dass das System die Run-Methode sofort aufruft.

1. Legen Sie einen Haltepunkt in der Run-Methode der Aufgabe fest.
2. Drücken Sie F5, oder tippen Sie auf "Debuggen > starten" , um die App bereitzustellen und auszuführen.
3. Wechseln Sie nach dem Starten der App zurück zu Visual Studio.
4. Stellen Sie sicher, dass die Symbolleiste "Debugspeicherort " sichtbar ist. Sie befindet sich im Menü "Symbolleisten anzeigen>".
5. Klicken Sie auf der Symbolleiste "Debugspeicherort " auf das Dropdownmenü "Anhalten" , und wählen Sie "BlogFeedBackgroundTask" aus.
6. Visual Studio hält die Ausführung am Haltepunkt an.
7. Drücken Sie F5, oder tippen Sie auf "Debuggen > fortsetzen ", um die Ausführung der App fortzusetzen.
8. Drücken Sie UMSCHALT+F5, oder tippen Sie auf "Debuggen > beenden" , um das Debuggen zu beenden.
9. Kehren Sie auf der Startseite zur Kachel der App zurück. Nach ein paar Sekunden werden Kachelbenachrichtigungen auf der Kachel Ihrer App angezeigt.

Zugehörige Themen

• BackgroundTaskBuilder
• TileUpdateManager
• TileNotification
• Unterstützen Ihrer App mit Hintergrundaufgaben