Freigeben über

Anzeigen eines Begrüßungsbildschirms für eine längere Dauer

Zeigen Sie einen Begrüßungsbildschirm für mehr Zeit an, indem Sie einen erweiterten Begrüßungsbildschirm für Ihre App erstellen. Dieser erweiterte Bildschirm imitiert den Begrüßungsbildschirm, der beim Starten der App angezeigt wird, kann jedoch angepasst werden. Ganz gleich, ob Sie Informationen zum Laden in Echtzeit anzeigen oder Ihrer App zusätzliche Zeit geben möchten, um die erste Benutzeroberfläche vorzubereiten. Mit einem erweiterten Begrüßungsbildschirm können Sie die Startoberfläche definieren.

Hinweis

Der Ausdruck "erweiterter Begrüßungsbildschirm" in diesem Thema bezieht sich auf einen Begrüßungsbildschirm, der für einen längeren Zeitraum auf dem Bildschirm verbleibt. Es bedeutet nicht, dass es sich um eine Unterklasse handelt, die von der SplashScreen Klasse abgeleitet wird.

Wichtige APIs

Die folgenden APIs werden in diesem Thema verwendet:

Standardempfehlungen für den Begrüßungsbildschirm

Stellen Sie sicher, dass der erweiterte Begrüßungsbildschirm den standardmäßigen Begrüßungsbildschirm genau imitiert, indem Sie die folgenden Empfehlungen befolgen:

  • Die Seite für den erweiterten Begrüßungsbildschirm sollte ein Bild mit 620 x 300 Pixeln verwenden, das mit dem bild konsistent ist, das für den Begrüßungsbildschirm im App-Manifest (das Bild des Begrüßungsbildschirms Ihrer App) angegeben ist. In Microsoft Visual Studio werden die Einstellungen für den Begrüßungsbildschirm im Abschnitt Begrüßungsbildschirm der Registerkarte Visual Assets in Ihrem App-Manifest (Datei "Package.appxmanifest") gespeichert.
  • Der erweiterte Begrüßungsbildschirm sollte eine Hintergrundfarbe verwenden, die mit der hintergrundfarbe konsistent ist, die für den Begrüßungsbildschirm im App-Manifest (der Hintergrund des Begrüßungsbildschirms Ihrer App) angegeben ist.
  • Ihr Code sollte die SplashScreen- Klasse verwenden, um das Bild des Begrüßungsbildschirms Ihrer App an den gleichen Bildschirmkoordinaten wie der standardmäßige Begrüßungsbildschirm zu positionieren.
  • Ihr Code sollte auf Ereignisse zur Fensteränderung reagieren (z. B. wenn der Bildschirm gedreht wird oder Ihre App neben einer anderen App auf dem Bildschirm verschoben wird), indem Sie die Klasse SplashScreen verwenden, um Elemente auf dem erweiterten Begrüßungsbildschirm neu zu positionieren.

Führen Sie die folgenden Schritte aus, um einen erweiterten Begrüßungsbildschirm zu erstellen, der den standardmäßigen Begrüßungsbildschirm effektiv imitiert.

Fügen Sie ein leere Seite-Element zu Ihrer vorhandenen App hinzu

In diesem Thema wird davon ausgegangen, dass Sie einem vorhandenen UWP-App-Projekt (Universelle Windows-Plattform) mit C#, Visual Basic oder C++ einen erweiterten Begrüßungsbildschirm hinzufügen möchten.

  • Öffnen Sie Ihre App in Visual Studio.
  • Drücken oder öffnen Sie Project in der Menüleiste, und klicken Sie auf Neues Element hinzufügen. Ein Dialogfeld zum Hinzufügen eines neuen Elements wird angezeigt.
  • Fügen Sie in diesem Dialogfeld Ihrer App eine neue Leere Seite hinzu. In diesem Thema wird die Seite für den erweiterten Begrüßungsbildschirm "ExtendedSplash" benannt.

Das Hinzufügen eines Leeren Seite-Elements generiert zwei Dateien, eine für das Markup (ExtendedSplash.xaml) und eine weitere für den Code (ExtendedSplash.xaml.cs).

Grundlegendes XAML für einen erweiterten Startbildschirm

Führen Sie die folgenden Schritte aus, um dem erweiterten Begrüßungsbildschirm ein Bild und eine Fortschrittsanzeige zu ergänzen.

In der Datei "ExtendedSplash.xaml":

  • Ändern Sie die Eigenschaft "Background" des standardmäßigen "Grid"-Elements, sodass sie der Hintergrundfarbe entspricht, die Sie für den Begrüßungsbildschirm Ihrer App im App-Manifest festgelegt haben (im Abschnitt "Visual Assets" der Datei „Package.appxmanifest“). Die Standardmäßige Farbe des Begrüßungsbildschirms ist hellgrau (Hexwert #464646). Beachten Sie, dass dieses Grid-Element standardmäßig bereitgestellt wird, wenn Sie eine neue Leere Seiteerstellen. Sie müssen kein Grid-verwenden; Es ist nur eine bequeme Basis zum Erstellen eines erweiterten Begrüßungsbildschirms.
  • Fügen Sie dem Gridein Canvas Element hinzu. Sie verwenden dieses Canvas-, um das Bild des erweiterten Begrüßungsbildschirms zu positionieren.
  • Fügen Sie dem Canvasein Image Element hinzu. Verwenden Sie das gleiche Bild von 620 x 300 Pixeln für den erweiterten Begrüßungsbildschirm, den Sie für den standardmäßigen Begrüßungsbildschirm ausgewählt haben.
  • (Optional) Fügen Sie ein Statussteuerelement hinzu, um Benutzern anzuzeigen, dass Ihre App geladen wird. In diesem Thema wird ein ProgressRing-anstelle eines determinierten oder unbestimmten ProgressBar-hinzugefügt.

Im folgenden Beispiel wird ein Grid- mit diesen Ergänzungen und Änderungen veranschaulicht.

    <Grid Background="#464646">
        <Canvas>
            <Image x:Name="extendedSplashImage" Source="Assets/SplashScreen.png"/>
            <ProgressRing Name="splashProgressRing" IsActive="True" Width="20" HorizontalAlignment="Center"></ProgressRing>
        </Canvas>
    </Grid>

Hinweis

In diesem Beispiel wird die Breite des ProgressRing- auf 20 Pixel festgelegt. Sie können die Breite manuell auf einen Wert festlegen, der für Ihre App funktioniert. Das Steuerelement wird jedoch nicht mit einer Breite von weniger als 20 Pixeln gerendert.

Grundlegender Code für eine erweiterte Splashscreen-Klasse

Der erweiterte Startbildschirm muss reagieren, wenn sich die Fenstergröße (nur für Windows) oder die Ausrichtung ändert. Damit Ihr erweiterter Begrüßungsbildschirm gut aussieht, egal wie das Fenster verändert wird, muss die Position des von Ihnen verwendeten Bildes aktualisiert werden.

Verwenden Sie diese Schritte, um die Methoden zum ordnungsgemäßen Anzeigen des erweiterten Startbildschirms zu definieren.

  1. Hinzufügen erforderlicher Namespaces

    Sie müssen die folgenden Namensräume zu ExtendedSplash.xaml.cs hinzufügen, um auf die SplashScreen--Klasse, die Rect--Struktur und die Window.SizeChanged--Ereignisse zuzugreifen.

    using Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.UI.Core;

  2. Erstellen einer partiellen Klasse und Deklarieren von Klassenvariablen

    Fügen Sie den folgenden Code in ExtendedSplash.xaml.cs ein, um eine partielle Klasse zum Darstellen eines erweiterten Begrüßungsbildschirms zu erstellen.

    partial class ExtendedSplash : Page
{
    internal Rect splashImageRect; // Rect to store splash screen image coordinates.
    private SplashScreen splash; // Variable to hold the splash screen object.
    internal bool dismissed = false; // Variable to track splash screen dismissal status.
    internal Frame rootFrame;

   // Define methods and constructor
}

    Diese Klassenvariablen werden von mehreren Methoden verwendet. Die splashImageRect Variable speichert die Koordinaten, an denen das System das Begrüßungsbild für die App angezeigt hat. Die splash-Variable speichert ein SplashScreen--Objekt, und die dismissed-Variable verfolgt, ob der vom System angezeigte SplashScreen geschlossen wurde.

  3. Definieren eines Konstruktors für Ihre Klasse, der das Bild korrekt positioniert

    Der folgende Code definiert einen Konstruktor für die Klasse des erweiterten Startbildschirms, der auf Ereignisse zur Größenänderung des Fensters lauscht, das Bild und (optional) die Fortschrittsanzeige auf dem erweiterten Startbildschirm positioniert, einen Frame für die Navigation erstellt und eine asynchrone Methode zum Wiederherstellen eines gespeicherten Sitzungszustands aufruft.

    public ExtendedSplash(SplashScreen splashscreen, bool loadState)
{
    InitializeComponent();

    // Listen for window resize events to reposition the extended splash screen image accordingly.
    // This ensures that the extended splash screen formats properly in response to window resizing.
    Window.Current.SizeChanged += new WindowSizeChangedEventHandler(ExtendedSplash_OnResize);

    splash = splashscreen;
    if (splash != null)
    {
        // Register an event handler to be executed when the splash screen has been dismissed.
        splash.Dismissed += new TypedEventHandler<SplashScreen, Object>(DismissedEventHandler);

        // Retrieve the window coordinates of the splash screen image.
        splashImageRect = splash.ImageLocation;
        PositionImage();

        // If applicable, include a method for positioning a progress control.
        PositionRing();
    }

    // Create a Frame to act as the navigation context
    rootFrame = new Frame();            
}

    Registrieren Sie unbedingt Ihren Window.SizeChanged Handler (ExtendedSplash_OnResize im Beispiel) im Klassenkonstruktor, damit das Bild auf Ihrem erweiterten Splash-Bildschirm korrekt positioniert wird.

  4. Definieren einer Klassenmethode zum Positionieren des Bilds im erweiterten Begrüßungsbildschirm

    Dieser Code zeigt, wie das Bild auf der erweiterten Startseite mit der Klassenvariable splashImageRect positioniert wird.

    void PositionImage()
{
    extendedSplashImage.SetValue(Canvas.LeftProperty, splashImageRect.X);
    extendedSplashImage.SetValue(Canvas.TopProperty, splashImageRect.Y);
    extendedSplashImage.Height = splashImageRect.Height;
    extendedSplashImage.Width = splashImageRect.Width;
}

  5. (Optional) Definieren Sie eine Klassenmethode zum Positionieren einer Fortschrittsanzeige im erweiterten Begrüßungsbildschirm

    Wenn Sie einen ProgressRing zu Ihrem erweiterten Startbildschirm hinzufügen möchten, platzieren Sie ihn relativ zum Bild des Startbildschirms. Fügen Sie den folgenden Code zu ExtendedSplash.xaml.cs hinzu, um das ProgressRing 32 Pixel unter dem Bild zu zentrieren.

    void PositionRing()
{
    splashProgressRing.SetValue(Canvas.LeftProperty, splashImageRect.X + (splashImageRect.Width*0.5) - (splashProgressRing.Width*0.5));
    splashProgressRing.SetValue(Canvas.TopProperty, (splashImageRect.Y + splashImageRect.Height + splashImageRect.Height*0.1));
}

  6. Innerhalb der Klasse definieren Sie einen Handler für das Ereignis "Dismissed"

    Reagieren Sie in ExtendedSplash.xaml.cs, wenn das SplashScreen.Dismissed-Ereignis auftritt, indem Sie die Klassenvariable dismissed auf "true" setzen. Wenn Ihre App Setupvorgänge hat, fügen Sie sie diesem Ereignishandler hinzu.

    // Include code to be executed when the system has transitioned from the splash screen to the extended splash screen (application's first view).
void DismissedEventHandler(SplashScreen sender, object e)
{
    dismissed = true;

    // Complete app setup operations here...
}

    Navigieren Sie nach Abschluss der App-Einrichtung vom erweiterten Startbildschirm weg. Der folgende Code definiert eine Methode namens DismissExtendedSplash, die zu der in der Datei "MainPage.xaml" Ihrer App definierten MainPage navigiert.

    async void DismissExtendedSplash()
  {
     await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,() =>            {
          rootFrame = new Frame();
          rootFrame.Content = new MainPage(); Window.Current.Content = rootFrame;
        });
  }

  7. Innerhalb der Klasse definieren Sie einen Handler für Window.SizeChanged-Ereignisse

    Bereiten Sie den erweiterten Begrüßungsbildschirm vor, um seine Elemente neu zu positionieren, wenn ein Benutzer die Größe des Fensters ändert. Wenn ein Window.SizeChanged-Ereignis auftritt, reagiert dieser Code, indem er die neuen Koordinaten erfasst und das Bild neu positioniert. Wenn Sie dem erweiterten Begrüßungsbildschirm eine Fortschrittsanzeige hinzugefügt haben, positionieren Sie diese ebenfalls in diesem Ereignishandler.

    void ExtendedSplash_OnResize(Object sender, WindowSizeChangedEventArgs e)
{
    // Safely update the extended splash screen image coordinates. This function will be executed when a user resizes the window.
    if (splash != null)
    {
        // Update the coordinates of the splash screen image.
        splashImageRect = splash.ImageLocation;
        PositionImage();

        // If applicable, include a method for positioning a progress control.
        // PositionRing();
    }
}

    Hinweis

     Bevor Sie versuchen, den Bildspeicherort abzurufen, stellen Sie sicher, dass die Klassenvariable (splash) ein gültiges SplashScreen--Objekt enthält, wie im Beispiel gezeigt.

     

  8. (Optional) Hinzufügen einer Klassenmethode zum Wiederherstellen eines gespeicherten Sitzungszustands

    Der Code, den Sie der OnLaunched-Methode in Schritt 4 hinzugefügt haben: Ändern des Startaktivierungshandlers, bewirkt, dass Ihre App beim Start einen erweiterten Begrüßungsbildschirm anzeigt. Um alle Methoden für den App-Start in der Klasse für den erweiterten Begrüßungsbildschirm zu konsolidieren, können Sie eine Methode zur ExtendedSplash.xaml.cs Datei hinzufügen, um den Zustand der App wiederherzustellen.

    void RestoreState(bool loadState)
{
    if (loadState)
    {
         // code to load your app's state here
    }
}

    Wenn Sie den Startaktivierungshandler in App.xaml.cs ändern, legen Sie auch loadstate auf "wahr" fest, wenn der vorherige AnwendungsAusführungsZustand- Ihrer App Beendetgewesen ist. Wenn ja, stellt die RestoreState-Methode die App im vorherigen Zustand wieder her. Eine Übersicht über das Starten, Anhalten und Beenden von Apps finden Sie unter App-Lebenszyklus.

Startaktivierungshandler ändern

Wenn Ihre App gestartet wird, übergibt das System Informationen zum Begrüßungsbildschirm an den Ereignishandler für die Startaktivierung der App. Sie können diese Informationen verwenden, um das Bild auf Ihrer erweiterten Begrüßungsbildschirmseite richtig zu positionieren. Sie können diese Startbildschirminformationen aus den Argumenten des Aktivierungsereignisses abrufen, die an den OnLaunched- Handler Ihrer App übergeben werden (siehe die args Variable im folgenden Code).

Wenn Sie den OnLaunched- Handler für Ihre App noch nicht außer Kraft gesetzt haben, lesen Sie App-Lebenszyklus, um zu erfahren, wie Aktivierungsereignisse behandelt werden.

Fügen Sie in App.xaml.cs den folgenden Code hinzu, um einen erweiterten Begrüßungsbildschirm zu erstellen und anzuzeigen.

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
    if (args.PreviousExecutionState != ApplicationExecutionState.Running)
    {
        bool loadState = (args.PreviousExecutionState == ApplicationExecutionState.Terminated);
        ExtendedSplash extendedSplash = new ExtendedSplash(args.SplashScreen, loadState);
        Window.Current.Content = extendedSplash;
    }

    Window.Current.Activate();
}

Vollständiger Code

Der folgende Code unterscheidet sich geringfügig von den Codeausschnitten, die in den vorhergehenden Schritten gezeigt wurden.

  • ExtendedSplash.xaml enthält eine Schaltfläche DismissSplash. Wenn auf diese Schaltfläche geklickt wird, ruft ein Ereignishandler DismissSplashButton_Clickdie DismissExtendedSplash-Methode auf. Rufen Sie in Ihrer App DismissExtendedSplash auf, wenn das Laden von Ressourcen oder die Initialisierung der Benutzeroberfläche Ihrer App abgeschlossen ist.
  • Diese App verwendet auch eine UWP-App-Projektvorlage, die Frame Navigation verwendet. Daher definiert der Startaktivierungshandler (OnLaunched) in App.xaml.cs ein rootFrame und verwendet es, um den Inhalt des App-Fensters festzulegen.

ExtendedSplash.xaml

Dieses Beispiel enthält eine Schaltfläche DismissSplash, da es über keine App-Ressourcen zum Laden verfügt. Schließen Sie in Ihrer App den erweiterten Begrüßungsbildschirm automatisch, wenn die App das Laden von Ressourcen oder die Vorbereitung der ersten Benutzeroberfläche abgeschlossen hat.

<Page
    x:Class="SplashScreenExample.ExtendedSplash"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:SplashScreenExample"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d">

    <Grid Background="#464646">
        <Canvas>
            <Image x:Name="extendedSplashImage" Source="Assets/SplashScreen.png"/>
            <ProgressRing Name="splashProgressRing" IsActive="True" Width="20" HorizontalAlignment="Center"/>
        </Canvas>
        <StackPanel HorizontalAlignment="Center" VerticalAlignment="Bottom">
            <Button x:Name="DismissSplash" Content="Dismiss extended splash screen" HorizontalAlignment="Center" Click="DismissSplashButton_Click" />
        </StackPanel>
    </Grid>
</Page>

ExtendedSplash.xaml.cs

Beachten Sie, dass die DismissExtendedSplash-Methode vom Klick-Event-Handler für die Schaltfläche DismissSplash aufgerufen wird. In Ihrer App benötigen Sie keine Schaltfläche DismissSplash. Rufen Sie stattdessen DismissExtendedSplash auf, wenn die App das Laden von Ressourcen abgeschlossen hat und Sie zur Hauptseite navigieren möchten.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
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.ApplicationModel.Activation;
using SplashScreenExample.Common;
using Windows.UI.Core;

// The Blank Page item template is documented at https://go.microsoft.com/fwlink/p/?LinkID=234238

namespace SplashScreenExample
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    partial class ExtendedSplash : Page
    {
        internal Rect splashImageRect; // Rect to store splash screen image coordinates.
        private SplashScreen splash; // Variable to hold the splash screen object.
        internal bool dismissed = false; // Variable to track splash screen dismissal status.
        internal Frame rootFrame;

        public ExtendedSplash(SplashScreen splashscreen, bool loadState)
        {
            InitializeComponent();

            // Listen for window resize events to reposition the extended splash screen image accordingly.
            // This is important to ensure that the extended splash screen is formatted properly in response to snapping, unsnapping, rotation, etc...
            Window.Current.SizeChanged += new WindowSizeChangedEventHandler(ExtendedSplash_OnResize);

            splash = splashscreen;

            if (splash != null)
            {
                // Register an event handler to be executed when the splash screen has been dismissed.
                splash.Dismissed += new TypedEventHandler<SplashScreen, Object>(DismissedEventHandler);

                // Retrieve the window coordinates of the splash screen image.
                splashImageRect = splash.ImageLocation;
                PositionImage();

                // Optional: Add a progress ring to your splash screen to show users that content is loading
                PositionRing();
            }

            // Create a Frame to act as the navigation context
            rootFrame = new Frame();

            // Restore the saved session state if necessary
            RestoreState(loadState);
        }

        void RestoreState(bool loadState)
        {
            if (loadState)
            {
                // TODO: write code to load state
            }
        }

        // Position the extended splash screen image in the same location as the system splash screen image.
        void PositionImage()
        {
            extendedSplashImage.SetValue(Canvas.LeftProperty, splashImageRect.X);
            extendedSplashImage.SetValue(Canvas.TopProperty, splashImageRect.Y);
            extendedSplashImage.Height = splashImageRect.Height;
            extendedSplashImage.Width = splashImageRect.Width;

        }

        void PositionRing()
        {
            splashProgressRing.SetValue(Canvas.LeftProperty, splashImageRect.X + (splashImageRect.Width*0.5) - (splashProgressRing.Width*0.5));
            splashProgressRing.SetValue(Canvas.TopProperty, (splashImageRect.Y + splashImageRect.Height + splashImageRect.Height*0.1));
        }

        void ExtendedSplash_OnResize(Object sender, WindowSizeChangedEventArgs e)
        {
            // Safely update the extended splash screen image coordinates. This function will be fired in response to snapping, unsnapping, rotation, etc...
            if (splash != null)
            {
                // Update the coordinates of the splash screen image.
                splashImageRect = splash.ImageLocation;
                PositionImage();
                PositionRing();
            }
        }

        // Include code to be executed when the system has transitioned from the splash screen to the extended splash screen (application's first view).
        void DismissedEventHandler(SplashScreen sender, object e)
        {
            dismissed = true;

            // Complete app setup operations here...
        }

        void DismissExtendedSplash()
        {
            // Navigate to mainpage
            rootFrame.Navigate(typeof(MainPage));
            // Place the frame in the current Window
            Window.Current.Content = rootFrame;
        }

        void DismissSplashButton_Click(object sender, RoutedEventArgs e)
        {
            DismissExtendedSplash();
        }
    }
}

App.xaml.cs

Dieses Projekt wurde mit der UWP-App Blank App (XAML) Projektvorlage in Visual Studio erstellt. Sowohl die OnNavigationFailed als auch die OnSuspending Ereignishandler werden automatisch generiert und müssen nicht geändert werden, um einen erweiterten Startbildschirm zu implementieren. Dieser Abschnitt ändert nur OnLaunched.

Wenn Sie keine Projektvorlage für Ihre App verwendet haben, siehe Schritt 4: Ändern des Startaktivierungsprozesses für ein Beispiel einer modifizierten OnLaunched, bei der die Frame-Navigation nicht verwendet wird.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
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;

// The Blank Application template is documented at https://go.microsoft.com/fwlink/p/?LinkID=234227

namespace SplashScreenExample
{
    /// <summary>
    /// Provides application-specific behavior to supplement the default Application class.
    /// </summary>
    sealed partial class App : Application
    {
        /// <summary>
        /// Initializes the singleton application object.  This is the first line of authored code
        /// executed, and as such is the logical equivalent of main() or WinMain().
        /// </summary>
        public App()
        {
            Microsoft.ApplicationInsights.WindowsAppInitializer.InitializeAsync(
            Microsoft.ApplicationInsights.WindowsCollectors.Metadata |
            Microsoft.ApplicationInsights.WindowsCollectors.Session);
            this.InitializeComponent();
            this.Suspending += OnSuspending;
        }

        /// <summary>
        /// Invoked when the application is launched normally by the end user.  Other entry points
        /// will be used such as when the application is launched to open a specific file.
        /// </summary>
        /// <param name="e">Details about the launch request and process.</param>
        protected override void OnLaunched(LaunchActivatedEventArgs e)
        {
#if DEBUG
            if (System.Diagnostics.Debugger.IsAttached)
            {
                this.DebugSettings.EnableFrameRateCounter = true;
            }
#endif

            Frame rootFrame = Window.Current.Content as Frame;

            // Do not repeat app initialization when the Window already has content,
            // just ensure that the window is active
            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();
                // Set the default language
                rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];

                rootFrame.NavigationFailed += OnNavigationFailed;

                //  Display an extended splash screen if app was not previously running.
                if (e.PreviousExecutionState != ApplicationExecutionState.Running)
                {
                    bool loadState = (e.PreviousExecutionState == ApplicationExecutionState.Terminated);
                    ExtendedSplash extendedSplash = new ExtendedSplash(e.SplashScreen, loadState);
                    rootFrame.Content = extendedSplash;
                    Window.Current.Content = rootFrame;
                }
            }

            if (rootFrame.Content == null)
            {
                // When the navigation stack isn't restored navigate to the first page,
                // configuring the new page by passing required information as a navigation
                // parameter
                rootFrame.Navigate(typeof(MainPage), e.Arguments);
            }
            // Ensure the current window is active
            Window.Current.Activate();
        }

        /// <summary>
        /// Invoked when Navigation to a certain page fails
        /// </summary>
        /// <param name="sender">The Frame which failed navigation</param>
        /// <param name="e">Details about the navigation failure</param>
        void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
        {
            throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
        }

        /// <summary>
        /// Invoked when application execution is being suspended.  Application state is saved
        /// without knowing whether the application will be terminated or resumed with the contents
        /// of memory still intact.
        /// </summary>
        /// <param name="sender">The source of the suspend request.</param>
        /// <param name="e">Details about the suspend request.</param>
        private void OnSuspending(object sender, SuspendingEventArgs e)
        {
            var deferral = e.SuspendingOperation.GetDeferral();
            // TODO: Save application state and stop any background activity
            deferral.Complete();
        }
    }
}

Referenz

  • Last updated on