Tratar a pré-inicialização do aplicativo
Saiba como lidar com a pré-inicialização do aplicativo substituindo o método OnLaunched e chamando CoreApplication.EnablePrelaunch.
Introdução
Quando os recursos disponíveis do sistema permitem, o desempenho de inicialização de aplicativos UWP em dispositivos da família de dispositivos da área de trabalho é aprimorado iniciando proativamente os aplicativos usados com mais frequência do usuário em segundo plano. Um aplicativo pré-iniciado é colocado no estado suspenso logo após ser iniciado. Em seguida, quando o usuário invoca o aplicativo, o aplicativo é retomado trazendo-o do estado suspenso para o estado de execução, o que é mais rápido do que iniciar o aplicativo frio. A experiência do usuário é que o aplicativo simplesmente foi iniciado muito rapidamente.
Antes do Windows 10, os aplicativos não aproveitavam automaticamente a pré-inicialização. No Windows 10, versão 1511, todos os aplicativos da Plataforma Universal do Windows (UWP) eram candidatos a serem pré-lançados. 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 do OnLaunched, próximo ao local em que a if (e.PrelaunchActivated == false) verificação é feita.
Se um aplicativo é pré-inicializado depende dos recursos do sistema. Se o sistema estiver enfrentando pressão de recursos, os aplicativos não serão pré-iniciados.
Alguns tipos de aplicativos podem precisar alterar seu comportamento de inicialização para funcionar bem com a pré-inicialização. Por exemplo, um aplicativo que reproduz música quando é inicializado; 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 — tudo isso pode identificar quando o aplicativo foi pré-iniciado e pode 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 o ciclo de vida do aplicativo
Depois que um aplicativo é pré-inicializado, ele entra no estado suspenso. (ver Manipular a suspensão do aplicativo).
Detectar e manipular o pré-lançamento
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 em que 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á código no exemplo acima que você pode descomentar 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 aceitos automaticamente 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 para o usuário. Eles se tornam visíveis quando o usuário muda para eles. Talvez você queira atrasar determinadas operações até que a janela principal do seu aplicativo fique 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 ficar obsoleta no momento em que o usuário ativar o aplicativo. O código a seguir manipula o evento VisibilityChanged para 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 do DirectX
Os jogos DirectX geralmente não devem habilitar a pré-inicialização porque muitos jogos DirectX fazem sua inicialização antes que a pré-inicialização possa ser detectada. A partir do Windows 1607, edição de aniversário, seu jogo não será pré-inicializado por padrão. Se você quiser que seu jogo aproveite a pré-inicialização, chame CoreApplication.EnablePrelaunch(true).
Se o jogo for direcionado a uma versão anterior do Windows 10, você poderá lidar com 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 execução longa 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 porque o aplicativo não estará visível e não ficará claro por que há reprodução de áudio.
- Os aplicativos não devem executar nenhuma operação durante a inicialização que pressuponha que o aplicativo esteja visível para o usuário ou que o aplicativo foi 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 considerar as implicações de privacidade, experiência do usuário e desempenho.
- Um exemplo de consideração de privacidade é quando um aplicativo social deve alterar o estado do usuário para online. Ele deve esperar até que o usuário alterne para o aplicativo em vez de alterar o status quando o aplicativo for pré-inicializado.
- Um exemplo de consideração da experiência do usuário é que, se você tiver um aplicativo, como um jogo, que exibe uma sequência introdutória quando é iniciado, poderá atrasar a sequência introdutória até que o usuário alterne para o aplicativo.
- Um exemplo de implicação de desempenho é que você pode esperar até que o usuário alterne para o aplicativo para recuperar as informações meteorológicas atuais em vez de carregá-las quando o aplicativo for pré-inicializado e, em seguida, precisar carregá-las novamente quando o aplicativo se tornar visível para garantir que as informações estejam atualizadas.
- Se o aplicativo limpar o Bloco Dinâmico quando iniciado, adie isso até que a visibilidade seja alterada.
- A telemetria do seu aplicativo deve distinguir entre ativações de bloco normais e ativações de pré-inicialização para facilitar a restrição do cenário se ocorrerem problemas.
- Se você tiver o Microsoft Visual Studio 2015 Update 1 e o Windows 10, versão 1511, poderá simular a pré-inicialização do aplicativo no Visual Studio 2015 escolhendo Depurar>outros destinos>de depuração Depurar o pré-lançamento do aplicativo universal do Windows.