Gérer le prélancement d’une application

Découvrez comment gérer la prélancement de l’application en remplaçant la méthode OnLaunched et en appelant CoreApplication.EnablePrelaunch.

Introduction

Lorsque les ressources système disponibles permettent, les performances de démarrage des applications UWP sur les appareils de bureau de famille d’appareils de bureau sont améliorées en lançant de manière proactive les applications les plus fréquemment utilisées par l’utilisateur en arrière-plan. Une application prélancée est placée dans l’état suspendu peu après son lancement. Ensuite, lorsque l’utilisateur appelle l’application, l’application est reprise en la faisant passer de l’état suspendu à l’état en cours d’exécution, ce qui est plus rapide que le lancement de l’application à froid. L’expérience de l’utilisateur est que l’application s’est simplement lancée très rapidement.

Avant Windows 10, les applications ne tirent pas automatiquement parti de la prélancement. Dans Windows 10, version 1511, toutes les applications plateforme Windows universelle (UWP) étaient candidates pour être prélancées. Dans Windows 10, version 1607, vous devez choisir de prélancer le comportement en appelant CoreApplication.EnablePrelaunch et en passant true. Un bon endroit pour mettre cet appel est dans OnLaunched, près de l’emplacement où la if (e.PrelaunchActivated == false) vérification est effectuée.

Si une application est prélancée dépend des ressources système. Si le système subit une pression sur les ressources, les applications ne sont pas prélancées.

Certains types d’applications peuvent avoir besoin de modifier leur comportement de démarrage pour fonctionner correctement avec le prélancement. Par exemple, une application qui joue de la musique au démarrage ; un jeu qui suppose que l’utilisateur est présent et affiche des visuels élaborés au démarrage de l’application ; une application de messagerie qui modifie la visibilité en ligne de l’utilisateur pendant le démarrage : tous ces éléments peuvent identifier le moment où l’application a été prélancée et peuvent modifier leur comportement de démarrage, comme décrit dans les sections ci-dessous.

Les modèles par défaut pour les projets XAML (C#, VB, C++) prennent en charge le prélancement.

Prélancement et cycle de vie de l’application

Une fois qu’une application est prélancée, elle entre dans l’état suspendu. (voir Gérer l’interruption de l’application).

Détecter et gérer le prélancement

Les applications reçoivent l’indicateur LaunchActivatedEventArgs.PrelaunchActivated pendant l’activation. Utilisez cet indicateur pour exécuter du code qui ne doit s’exécuter que lorsque l’utilisateur lance explicitement l’application, comme indiqué dans la modification suivante d’Application.OnLaunched.

protected override void OnLaunched(LaunchActivatedEventArgs e)
{
    // CoreApplication.EnablePrelaunch was introduced in Windows 10 version 1607
    bool canEnablePrelaunch = Windows.Foundation.Metadata.ApiInformation.IsMethodPresent("Windows.ApplicationModel.Core.CoreApplication", "EnablePrelaunch");

    // NOTE: Only enable this code if you are targeting a version of Windows 10 prior to version 1607,
    // and you want to opt out of prelaunch.
    // In Windows 10 version 1511, all UWP apps were candidates for prelaunch.
    // Starting in Windows 10 version 1607, the app must opt in to be prelaunched.
    //if ( !canEnablePrelaunch && e.PrelaunchActivated == true)
    //{
    //    return;
    //}

    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();

        rootFrame.NavigationFailed += OnNavigationFailed;

        if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
        {
            //TODO: Load state from previously suspended application
        }

        // Place the frame in the current Window
        Window.Current.Content = rootFrame;
    }

    if (e.PrelaunchActivated == false)
    {
        // On Windows 10 version 1607 or later, this code signals that this app wants to participate in prelaunch
        if (canEnablePrelaunch)
        {
            TryEnablePrelaunch();
        }

        // TODO: This is not a prelaunch activation. Perform operations which
        // assume that the user explicitly launched the app such as updating
        // the online presence of the user on a social network, updating a
        // what's new feed, etc.

        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>
/// This method should be called only when the caller
/// determines that we're running on a system that
/// supports CoreApplication.EnablePrelaunch.
/// </summary>
private void TryEnablePrelaunch()
{
    Windows.ApplicationModel.Core.CoreApplication.EnablePrelaunch(true);
}

Il existe également du code dans l’exemple ci-dessus que vous pouvez annuler les marques de commentaire si votre application doit refuser le prélancement lors de l’exécution sur Windows 10, version 1511. Dans la version 1511, toutes les applications UWP ont été automatiquement choisies pour prélancement, ce qui peut ne pas convenir à votre application.

Utiliser l’événement VisibilityChanged

Les applications activées par prélancement ne sont pas visibles par l’utilisateur. Ils deviennent visibles lorsque l’utilisateur passe à eux. Vous pouvez retarder certaines opérations jusqu’à ce que la fenêtre principale de votre application devienne visible. Par exemple, si votre application affiche une liste des nouveaux éléments à partir d’un flux, vous pouvez mettre à jour la liste pendant l’événement VisibilityChanged plutôt que d’utiliser la liste générée lorsque l’application a été prélancée, car elle peut devenir obsolète au moment où l’utilisateur active l’application. Le code suivant gère l’événement VisibilityChanged pour MainPage :

public sealed partial class MainPage : Page
{
    public MainPage()
    {
        this.InitializeComponent();

        Window.Current.VisibilityChanged += WindowVisibilityChangedEventHandler;
    }

    void WindowVisibilityChangedEventHandler(System.Object sender, Windows.UI.Core.VisibilityChangedEventArgs e)
    {
        // Perform operations that should take place when the application becomes visible rather than
        // when it is prelaunched, such as building a what's new feed
    }
}

Conseils sur les jeux DirectX

Les jeux DirectX ne doivent généralement pas activer le prélancement, car de nombreux jeux DirectX effectuent leur initialisation avant de pouvoir être détectés. À compter de Windows 1607, édition anniversaire, votre jeu n’est pas prélancé par défaut. Si vous souhaitez que votre jeu tire parti de la prélancement, appelez CoreApplication.EnablePrelaunch(true).

Si votre jeu cible une version antérieure de Windows 10, vous pouvez gérer la condition de prélancement pour quitter l’application :

void ViewProvider::OnActivated(CoreApplicationView const& /* appView */, Windows::ApplicationModel::Activation::IActivatedEventArgs const& args)
{
    if (args.Kind() == Windows::ApplicationModel::Activation::ActivationKind::Launch)
    {
        auto launchArgs{ args.as<Windows::ApplicationModel::Activation::LaunchActivatedEventArgs>()};
        if (launchArgs.PrelaunchActivated())
        {
            // Opt-out of Prelaunch.
            CoreApplication::Exit();
        }
    }
}

void ViewProvider::Initialize(CoreApplicationView const & appView)
{
    appView.Activated({ this, &App::OnActivated });
}

void ViewProvider::OnActivated(CoreApplicationView^ appView,IActivatedEventArgs^ args)
{
    if (args->Kind == ActivationKind::Launch)
    {
        auto launchArgs = static_cast<LaunchActivatedEventArgs^>(args);
        if (launchArgs->PrelaunchActivated)
        {
            // Opt-out of Prelaunch
            CoreApplication::Exit();
            return;
        }
    }
}

Règle générale

• Les applications ne doivent pas effectuer d’opérations longues pendant le prélancement, car l’application se termine si elle ne peut pas être suspendue rapidement.
• Les applications ne doivent pas lancer la lecture audio à partir d’Application.OnLaunched lorsque l’application est prélancée, car l’application ne sera pas visible et elle ne sera pas visible pourquoi il y a lecture audio.
• Les applications ne doivent effectuer aucune opération pendant le lancement, ce qui suppose que l’application est visible par l’utilisateur ou suppose que l’application a été lancée explicitement par l’utilisateur. Étant donné qu’une application peut maintenant être lancée en arrière-plan sans action explicite de l’utilisateur, les développeurs doivent prendre en compte la confidentialité, l’expérience utilisateur et les implications en termes de performances.
  • Un exemple de considérations relatives à la confidentialité est qu’une application sociale doit changer l’état de l’utilisateur en ligne. Il doit attendre que l’utilisateur bascule vers l’application au lieu de modifier l’état lorsque l’application est prélancée.
  • Un exemple d’expérience utilisateur est que si vous avez une application, telle qu’un jeu, qui affiche une séquence d’introduction lors du lancement, vous pouvez retarder la séquence d’introduction jusqu’à ce que l’utilisateur passe à l’application.
  • Par exemple, vous pouvez attendre que l’utilisateur passe à l’application pour récupérer les informations météorologiques actuelles au lieu de le charger lorsque l’application est prélancée, puis que vous devez la charger à nouveau lorsque l’application devient visible pour s’assurer que les informations sont actuelles.
• Si votre application efface sa vignette dynamique lors du lancement, reportez cette opération jusqu’à ce que l’événement de visibilité change.
• La télémétrie de votre application doit faire la distinction entre les activations de vignettes normales et les activations de prélancement pour faciliter la réduction du scénario si des problèmes se produisent.
• Si vous disposez de Microsoft Visual Studio 2015 Update 1 et Windows 10 version 1511, vous pouvez simuler un prélancement pour l’application dans Visual Studio 2015 en choisissant Déboguer>d’autres cibles>de débogage Debug Universal App PreLaunch.

Rubriques connexes

• Cycle de vie de l’application
• CoreApplication.EnablePrelaunch