Schnellstart: Aktualisieren einer Live-Kachel über eine Hintergrundaufgabe

Applies to Windows and Windows Phone

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

In diesem Video wird gezeigt, wie Sie Apps Live-Kacheln hinzufügen.

Voraussetzungen

In diesem Thema wird davon ausgegangen, dass Sie mit C++, C# oder Visual Basic eine einfache Windows-Runtime-App erstellen können. Anweisungen zum Erstellen Ihrer ersten Windows Store-App finden Sie unter Erstellen Ihrer ersten Windows-Runtime-Apps mit C++, C# oder Visual Basic.

Folgendes ist für die Verwendung des in diesem Abschnitt beschriebenen Codes erforderlich:

  • Windows 8
  • Microsoft Visual Studio Express 2012 für Windows 8

Erstellen des Hintergrundaufgabenprojekts

Fügen Sie der Projektmappe zum Aktivieren einer Live-Kachel für Ihre App ein neues Windows-Runtime-Komponentenprojekt hinzu. Dies ist eine separate Assembly, die vom BS im Hintergrund geladen und ausgeführt wird, wenn Benutzer die App installieren.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe, zeigen Sie auf Hinzufügen, und klicken oder tippen Sie auf Neues Projekt.
  2. Wählen Sie im Dialogfeld Neues Projekt hinzufügen im Abschnitt Visual C# > Windows Store die Vorlage Windows-Runtime-Komponente aus.
  3. Geben Sie dem Projekt den Namen "BackgroundTasks", und klicken oder tippen Sie auf OK. In Microsoft Visual Studio wird das neue Projekt der Projektmappe hinzugefügt.
  4. Fügen Sie im Hauptprojekt einen Verweis auf das Projekt "BackgroundTasks" hinzu.

Implementieren der Hintergrundaufgabe

Implementieren Sie die IBackgroundTask-Schnittstelle, um eine Klasse zu erstellen, mit der die Live-Kachel Ihrer App aktualisiert wird. Ihre Hintergrundarbeit bezieht sich auf die Run-Methode. In diesem Fall erhält die Aufgabe einen Veröffentlichungsfeed für die MSDN-Blogs. Richten Sie eine Verzögerung ein, um das zu frühe Schließen der Aufgabe zu verhindern, während noch asynchroner Code ausgeführt wird.

  1. Benennen Sie die automatisch generierte Datei Class1.cs im Projektmappen-Explorer in BlogFeedBackgroundTask.cs um.
  2. Ersetzen Sie den automatisch generierten Code in BlogFeedBackgroundTask.cs durch den Stub-Code für die BlogFeedBackgroundTask-Klasse.
  3. Fügen Sie in der Implementierung der Run-Methode 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.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";
    }
}


Einrichten des Paketmanifests

Öffnen Sie das Paketmanifest, um es einzurichten, und fügen Sie eine Deklaration einer neuen Hintergrundaufgabe hinzu. Legen Sie den Einstiegspunkt für die Aufgabe auf den Klassennamen fest, und fügen Sie auch den Namespace ein.

  1. Öffnen Sie im Projektmappen-Explorer das Element Package.appxmanifest.
  2. Klicken oder tippen Sie auf die Registerkarte Deklarationen.
  3. Wählen Sie unter Verfügbare Deklarationen die Option BackgroundTasks aus, und klicken Sie auf Hinzufügen. In Visual Studio wird BackgroundTasks unter Unterstützte Deklarationen hinzugefügt.
  4. Stellen Sie unter Unterstützte Aufgabentypen sicher, dass Timer aktiviert ist.
  5. Legen Sie unter App-Einstellungen den Einstiegspunkt auf BackgroundTasks.BlogFeedBackgroundTask fest.
  6. Klicken oder tippen Sie auf die Registerkarte Anwendungsbenutzeroberfläche.
  7. Legen Sie die Option Benachrichtigungen bei gesperrtem Bildschirm auf Text für Infoanzeiger und Kachel fest.
  8. Legen Sie im Feld Infoanzeigerlogo einen Pfad zu einem Symbol der Größe 24 x 24 Pixel fest.

    Wichtig  Für dieses Symbol dürfen nur einfarbige und transparente Pixel verwendet werden.

  9. Legen Sie im Feld Kleines Logo einen Pfad zu einem Symbol der Größe 30 x 30 Pixel fest.
  10. Legen Sie im Feld Breites Logo einen Pfad zu einem Symbol der Größe 310 x 150 Pixel fest.

Registrieren der Hintergrundaufgabe

Erstellen Sie ein BackgroundTaskBuilder-Objekt zum Registrieren Ihrer Aufgabe.

Hinweis  

Ab Windows 8.1 werden Parameter für die Registrierung von Hintergrundaufgaben zum Zeitpunkt der Registrierung überprüft. Bei ungültigen Registrierungsparametern wird ein Fehler zurückgegeben. Ihre App muss Szenarios, in denen die Registrierung von Hintergrundaufgaben fehlschlägt, problemlos verarbeiten können. Verwenden Sie beispielsweise eine Bedingungsanweisung, um die App auf Registrierungsfehler zu prüfen, und führen Sie die fehlgeschlagene Registrierung mit anderen Parameterwerten erneut durch.

Fügen Sie auf der Hauptseite der App die RegisterBackgroundTask-Methode hinzu, und rufen Sie diese im Ereignishandler OnNavigatedTo 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 http://go.microsoft.com/fwlink/?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";
    }
}


Debuggen der Hintergrundaufgabe

Legen Sie zum Debuggen der Hintergrundaufgabe in der Run-Methode der Aufgabe einen Haltepunkt fest. Wählen Sie die Hintergrundaufgabe auf der Symbolleiste Debugspeicherort aus. Das System ruft dann sofort die Run-Methode auf.

  1. Legen Sie in der Run-Methode der Aufgabe einen Haltepunkt fest.
  2. Drücken Sie F5, oder tippen Sie auf Debuggen > Debugging 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ü Ansicht > Symbolleisten.
  5. Klicken Sie in der Symbolleiste Debugspeicherort auf die Dropdownliste 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 > Debugging beenden, um das Debuggen zu beenden.
  9. Kehren Sie zur Kachel der App auf der Startseite zurück. Nach einigen Sekunden werden in der Kachel der App Kachelbenachrichtigungen angezeigt.

Zusammenfassung

Sie können der App jetzt Updates für Live-Kacheln hinzufügen und für Benutzer aktuelle Inhalte anzeigen, die regelmäßig aktualisiert werden.

Verwandte Themen

BackgroundTaskBuilder
TileUpdateManager
TileNotification
Unterstützen von Apps durch Hintergrundaufgaben
Richtlinien und Prüfliste für Kacheln und Infoanzeiger

 

 

Anzeigen:
© 2014 Microsoft