Gérer le prélancement d’une application

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

Présentation

Lorsque les ressources système disponibles le permettent, les performances de démarrage des applications UWP sur les appareils de la famille des appareils de bureau sont améliorées en lançant de manière proactive les applications qu’il utilise le plus souvent 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 de la plateforme Windows universelle (UWP) pouvaient être prélancées. Dans Windows 10, version 1607, vous devez opter pour le comportement de prélancement en appelant CoreApplication.EnablePrelaunchet en passant true. Un bon endroit pour mettre cet appel se trouve dans OnLaunched , près de l’emplacement où la vérification if (e.PrelaunchActivated == false) 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 la suspension de l’application).

Détecter et gérer le prélancement

Les applications reçoivent l’indicateur LaunchActivatedEventArgs.PrelaunchActivated lors de 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 de 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 y a également du code dans l’exemple ci-dessus que vous pouvez décommenter si votre application doit refuser le prélancement lorsqu'elle est exécutée 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 les sélectionne. 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 la PagePrincipale:

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 profite du 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;
        }
    }
}

Conseils généraux

• 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 initier la lecture audio à partir de Application.OnLaunched lorsque l’application est lancée en arrière-plan, car l’application n’est pas visible et il n’est pas clair pourquoi de l’audio est diffusé.
• 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ération relative à la confidentialité est lorsqu'une application sociale doit passer 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, une implication en termes de performance pourrait être d'attendre que l'utilisateur passe à l'application pour récupérer les informations météorologiques actuelles, au lieu de les charger lorsque l'application est prélancée, et devoir les recharger lorsque l'application devient visible pour garantir que les informations soient à jour.
• Si votre application efface sa vignette dynamique lors du lancement, reportez cette opération jusqu'à ce que l'événement de changement de visibilité se produise.
• La télémétrie de votre application doit faire la distinction entre les activations normales de vignettes et les activations de prélancement pour identifier plus facilement le scénario en cas de problèmes.
• Si vous avez Microsoft Visual Studio 2015 Update 1 et Windows 10, version 1511, vous pouvez simuler le prélancement de votre application dans Visual Studio 2015 en choisissant Déboguer>Autres cibles de débogage>Déboguer le prélancement de l'application universelle Windows.

Rubriques connexes

• cycle de vie des applications
• CoreApplication.EnablePrelaunch