Share via

Tratar a pré-inicialização do aplicativo

  • Artigo

Saiba como lidar com a pré-inicialização do aplicativo substituindo o método OnLaunched e chamando CoreApplication.EnablePrelaunch.

Introdução

Quando os recursos do sistema disponíveis permitem, o desempenho de inicialização de aplicativos UWP em dispositivos da família de dispositivos desktop é aprimorado iniciando proativamente os aplicativos usados com mais frequência do usuário em segundo plano. Um aplicativo pré-lançado é colocado no estado suspenso pouco depois de ser iniciado. Em seguida, quando o usuário invoca o aplicativo, o aplicativo é retomado trazendo-o do estado suspenso para o estado em execução, o que é mais rápido do que iniciar o aplicativo frio. A experiência do usuário é que o aplicativo simplesmente iniciou muito rapidamente.

Antes do Windows 10, os aplicativos não aproveitam automaticamente a pré-inicialização. No Windows 10, versão 1511, todos os aplicativos da Plataforma Universal do Windows (UWP) eram candidatos para serem pré-inicializados. No Windows 10, versão 1607, você deve aceitar o comportamento de pré-inicialização chamando CoreApplication.EnablePrelaunch e passando true. Um bom lugar para colocar essa chamada é dentro de OnLaunched, perto do local em que a if (e.PrelaunchActivated == false) marcar é feita.

A pré-inicialização do aplicativo depende de recursos do sistema. Se o sistema estiver enfrentando pressão de recursos, os aplicativos não serão pré-inicializados.

Alguns tipos de aplicativos podem precisar alterar o comportamento de inicialização para funcionar bem com a pré-inicialização. Por exemplo, um aplicativo que reproduz música quando é iniciado; um jogo que pressupõe que o usuário está presente e exibe visuais elaborados quando o aplicativo é iniciado; um aplicativo de mensagens que altera a visibilidade online do usuário durante a inicialização— todos eles podem identificar quando o aplicativo foi pré-inicializado e podem alterar seu comportamento de inicialização, conforme descrito nas seções abaixo.

Os modelos padrão para projetos XAML (C#, VB, C++) acomodam a pré-inicialização.

Pré-lançamento e ciclo de vida do aplicativo

Depois que um aplicativo é pré-inicializado, ele entra no estado suspenso. (Consulte Manipular a suspensão de aplicativo.)

Detectar e manipular a pré-inicialização

Os aplicativos recebem o sinalizador LaunchActivatedEventArgs.PrelaunchActivated durante a ativação. Use esse sinalizador para executar o código que só deve ser executado quando o usuário iniciar explicitamente o aplicativo, conforme mostrado na modificação a seguir em 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);
}

Importante

O método TryEnablePrelaunch no exemplo de código acima chama CoreApplication.EnablePrelaunch. E TryEnablePrelaunch é chamado somente quando o aplicativo está em execução em uma versão do Windows que dá suporte a CoreApplication.EnablePrelaunch. Em geral, se houver alguma dúvida, você deverá usar uma API do Windows somente depois de determinar que ela é compatível com a plataforma na qual seu código está sendo executado. E você pode fazer isso por meio da classe ApiInformation , conforme mostrado no exemplo de código acima.

Também há um código no exemplo acima que você pode remover a marca de comentário se seu aplicativo precisar recusar a pré-inicialização ao ser executado no Windows 10, versão 1511. Na versão 1511, todos os aplicativos UWP foram automaticamente aceitos para pré-inicialização, o que pode não ser apropriado para seu aplicativo.

Usar o evento VisibilityChanged

Os aplicativos ativados pela pré-inicialização não são visíveis ao usuário. Eles ficam visíveis quando o usuário os alterna. Você poderá adiar determinadas operações até que a janela principal do aplicativo esteja visível. Por exemplo, se o aplicativo exibir uma lista de itens de novidades de um feed, você poderá atualizar a lista durante o evento VisibilityChanged, em vez de usar a lista que foi criada quando o aplicativo foi pré-inicializado, pois ela pode estar obsoleta no momento em que o usuário ativa o aplicativo. O código a seguir manipula o evento VisibilityChanged de 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
    }
}

Diretrizes de jogos em DirectX

Os jogos em DirectX geralmente não devem permitir pré-inicialização porque muitos jogos em DirectX fazem a inicialização antes de a pré-inicialização ser detectada. A partir do Windows 1607, a edição de aniversário, seu jogo não será pré-inicializado por padrão. Se você quiser que seu jogo tire proveito da pré-inicialização, chame CoreApplication.EnablePrelaunch(true).

Se seu jogo direcionar uma versão anterior do Windows 10, você poderá manipular a condição de pré-inicialização para sair do aplicativo:

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

Orientação geral

  • Os aplicativos não devem executar operações de longa duração durante a pré-inicialização porque o aplicativo será encerrado se não puder ser suspenso rapidamente.
  • Os aplicativos não devem iniciar a reprodução de áudio de Application.OnLaunched quando o aplicativo for pré-inicializado, pois o aplicativo não estará visível e ele não ficará aparente porque o áudio está sendo reproduzido.
  • Os aplicativos não devem executar operações durante a inicialização que pressuponham que o aplicativo esteja visível para o usuário ou que o aplicativo tenha sido iniciado explicitamente pelo usuário. Como um aplicativo agora pode ser iniciado em segundo plano sem ação explícita do usuário, os desenvolvedores devem levar em consideração a privacidade, a experiência do usuário e as implicações sobre o desempenho.
    • Um exemplo de consideração de privacidade acontece quando um aplicativo de rede social deve alterar o estado do usuário para online. Ele deve aguardar até que o usuário alterne para o aplicativo, em vez de alterar o status quando o aplicativo é pré-inicializado.
    • Um exemplo de consideração de experiência do usuário é que, se você tiver um aplicativo, como um jogo, que exiba uma sequência introdutória quando é iniciado, você poderá atrasar a sequência introdutória até o usuário alternar para o aplicativo.
    • Um exemplo de implicação de desempenho é que você poderá aguardar até o usuário alternar para o aplicativo a fim de recuperar as informações de clima atuais, em vez de carregá-las quando o aplicativo é pré-inicializado e, depois, recarregá-las quando o aplicativo ficar visível, para garantir que as informações estejam atualizadas.
  • Caso o aplicativo limpe o Bloco Dinâmico quando iniciado, adie isso até o evento de visibilidade alterada.
  • A telemetria do aplicativo deve distinguir ativações de bloco normais e ativações de pré-lançamento para facilitar a limitação do cenário se problemas ocorrerem.
  • Se você tiver o Microsoft Visual Studio 2015 Atualização 1 e o Windows 10, versão 1511, poderá simular a pré-inicialização do Aplicativo em seu aplicativo no Visual Studio 2015 escolhendo Depurar>Outros Destinos> deDepuração Depurar Pré-Inicialização do Aplicativo Universal do Windows.