Gérer le prélancement d’une application

  • Article

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

Introduction

Lorsque les ressources système disponibles le permettent, les performances de démarrage des applications UWP sur les appareils de la 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 à l’état suspendu dans les secondes suivant son lancement. Ensuite, lorsque l’utilisateur appelle l’application, l’application est reprise en la faisant passer de l’état suspendu à l’état d’exécution, ce qui est plus rapide que le lancement de l’application à froid. L’utilisateur peut donc lancer son application très rapidement.

Avant Windows 10, les applications ne profitaient pas automatiquement du prélancement. Dans Windows 10, version 1511, toutes les applications de plateforme Windows universelle (UWP) étaient candidates au prélancement. Dans Windows 10 version 1607, vous devez choisir le comportement de prélancement en appelant CoreApplication.EnablePrelaunch et en transmettant true. Un bon endroit pour passer cet appel est dans OnLaunched, près de l’emplacement où le if (e.PrelaunchActivated == false) case activée est effectué.

Le prélancement d’une application 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 lit 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 lors du 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 passe à l’état suspendu. (Voir Gérer la suspension d’une 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 apportée à 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);
}

Important

La méthode TryEnablePrelaunch dans l’exemple de code ci-dessus appelle CoreApplication.EnablePrelaunch. TryEnablePrelaunch est lui-même appelé uniquement lorsque l’application s’exécute sur une version de Windows qui prend en charge CoreApplication.EnablePrelaunch. En général, en cas de doute, vous devez utiliser une API Windows uniquement après avoir déterminé qu’elle est prise en charge par la plateforme sur laquelle votre code s’exécute. Et vous pouvez le faire à l’aide de la classe ApiInformation , comme indiqué dans l’exemple de code ci-dessus.

L’exemple ci-dessus comporte également du code qui vous permet de supprimer 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 activées pour le 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 pour l’utilisateur. Elles le deviennent lorsque l’utilisateur bascule vers celles-ci. Vous souhaitez peut-être retarder certaines opérations jusqu’à ce que la fenêtre principale de votre application soit visible. Par exemple, si votre application affiche une liste des nouveaux éléments d’un flux, vous pouvez mettre à jour cette liste pendant l’événement VisibilityChanged plutôt que d’utiliser une liste qui a été générée lors du prélancement de l’application et qui peut être 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
    }
}

Recommandations en matière de jeux DirectX

Il n’est généralement pas conseillé d’activer le prélancement pour les jeux DirectX car de nombreux jeux DirectX s’initialisent avant que le prélancement puisse être détecté. À partir de Windows version 1607, édition anniversaire, le prélancement de votre jeu sera désactivé par défaut. Si vous souhaitez activer le prélancement pour votre jeu, appelez l’élément CoreApplication.EnablePrelaunch(true).

Si votre jeu utilise 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 de longue durée pendant le prélancement, puisque l’application s’arrêtera si elle ne peut pas être suspendue rapidement.
  • Les applications ne doivent pas lancer la lecture audio à partir de Application.OnLaunched lorsque l’application est prélancée, car l’application ne sera pas visible et la raison de la lecture audio ne sera pas évidente.
  • Les applications ne doivent pas effectuer d’opérations lors du lancement, qui suppose que l’application est visible par l’utilisateur ou qu’elle a été lancée explicitement par l’utilisateur. Dans la mesure où 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’incidence sur les performances et l’expérience utilisateur.
    • Le moment où une application sociale doit définir l’état de l’utilisateur sur « en ligne » est un exemple de considération relative à la confidentialité. Elle doit attendre que l’utilisateur bascule vers l’application au lieu de modifier l’état de celui-ci lors du prélancement de l’application.
    • Exemple de considération relative à l’expérience utilisateur : vous possédez une application, telle qu’un jeu, qui affiche une séquence d’introduction lors de son lancement, et aimeriez avoir la possibilité de retarder la séquence d’introduction jusqu’à ce que l’utilisateur bascule vers l’application.
    • En ce qui concerne l’incidence sur les performances, vous devrez peut-être attendre que l’utilisateur bascule vers l’application pour récupérer les informations météorologiques actuelles au lieu de les charger lors du prélancement de l’application, puis les charger une nouvelle fois lorsque l’application devient visible pour vous assurer que les informations sont à jour.
  • Si votre application efface sa vignette dynamique lors de son lancement, reportez cette opération pour qu’elle ait lieu après l’événement VisibilityChanged.
  • La télémétrie de votre application doit faire la distinction entre les activations de vignette standard et les activations de prélancement, afin que vous puissiez identifier plus facilement le scénario correspondant en cas de problème.
  • Si vous avez Microsoft Visual Studio 2015 Update 1 et Windows 10 version 1511, vous pouvez simuler le prélancement de l’application dans Visual Studio 2015 en choisissant Déboguer>d’autres cibles> de débogageDéboguer le prélancement de l’application universelle Windows.