Compartilhar via

Mostrar várias exibições com ApplicationView

Ajude os usuários a serem mais produtivos, permitindo que eles exibam partes independentes do aplicativo em janelas separadas. Quando você cria várias janelas para um aplicativo, cada janela se comporta de forma independente. A barra de tarefas mostra cada janela separadamente. Os usuários podem mover, redimensionar, mostrar e ocultar janelas do aplicativo de forma independente e podem alternar entre janelas de aplicativo como se fossem aplicativos separados. Cada janela opera em seu próprio thread.

APIs importantes: ApplicationViewSwitcher, CreateNewView

O que é uma visão?

Uma visão de aplicativo é o emparelhamento 1:1 de um thread e uma janela que o aplicativo usa para exibir conteúdo. Ele é representado por um objeto Windows.ApplicationModel.Core.CoreApplicationView .

As exibições são gerenciadas pelo objeto CoreApplication . Você chama CoreApplication.CreateNewView para criar um objeto CoreApplicationView . O CoreApplicationView reúne uma CoreWindow e um CoreDispatcher (armazenados nas propriedades CoreWindow e Dispatcher). Você pode pensar no CoreApplicationView como o objeto que o Windows Runtime usa para interagir com o sistema principal do Windows.

Normalmente, você não trabalha diretamente com o CoreApplicationView. Em vez disso, o Windows Runtime fornece a classe ApplicationView no namespace Windows.UI.ViewManagement . Essa classe fornece propriedades, métodos e eventos que você usa quando seu aplicativo interage com o sistema de janelas. Para trabalhar com um ApplicationView, chame o método estático ApplicationView.GetForCurrentView, que obtém uma instância ApplicationView vinculada à thread atual do CoreApplicationView.

Da mesma forma, a estrutura XAML encapsula o objeto CoreWindow em um objeto Windows.UI.XAML.Window . Em um aplicativo XAML, você normalmente interage com o objeto Window em vez de trabalhar diretamente com o CoreWindow.

Mostrar uma nova visualização

Embora cada layout de aplicativo seja exclusivo, recomendamos incluir um botão "nova janela" em um local previsível, como o canto superior direito do conteúdo que pode ser aberto em uma nova janela. Considere também incluir uma opção de menu de contexto para "Abrir em uma nova janela".

Vamos examinar as etapas para criar uma nova visão. Aqui, o novo modo de exibição é iniciado em resposta a um clique de botão.

private async void Button_Click(object sender, RoutedEventArgs e)
{
    CoreApplicationView newView = CoreApplication.CreateNewView();
    int newViewId = 0;
    await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        Frame frame = new Frame();
        frame.Navigate(typeof(SecondaryPage), null);   
        Window.Current.Content = frame;
        // You have to activate the window in order to show it later.
        Window.Current.Activate();

        newViewId = ApplicationView.GetForCurrentView().Id;
    });
    bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);
}

Para mostrar uma nova exibição

  1. Chame CoreApplication.CreateNewView para criar uma nova janela e um thread para o conteúdo da exibição.

    CoreApplicationView newView = CoreApplication.CreateNewView();

  2. Acompanhe o Id da nova visualização. Você usa isso para mostrar a visualização posteriormente.

    Talvez você queira considerar a criação de alguma infraestrutura em seu aplicativo para ajudar no acompanhamento das exibições que você cria. Consulte a classe ViewLifetimeControl no exemplo MultipleViews para referência.

    int newViewId = 0;

  3. No novo tópico, preencha a janela.

    Use o método CoreDispatcher.RunAsync para agendar o trabalho no thread da interface do usuário para o novo modo de exibição. Você usa a expressão lambda para passar uma função como argumento para o método RunAsync . O trabalho que você faz na função lambda acontece no thread do novo modo de exibição.

    No XAML, você normalmente adiciona um Frame à propriedade de Conteúdo do Windowe, em seguida, navega o Frame para uma Page XAML onde você definiu o conteúdo do seu aplicativo. Para obter mais informações sobre quadros e páginas, consulte navegação entre pares entre duas páginas.

    Depois que a nova janela for preenchida, você deverá chamar o método Ativar da janela para mostrar a janela posteriormente. Esse trabalho ocorre na linha do novo modo de exibição, de modo que a nova Janela seja ativada.

    Por fim, obtenha o ID da nova visão que você utilizará para mostrar a visão posteriormente. Mais uma vez, esse trabalho está na linha de execução da nova visualização, portanto, ApplicationView.GetForCurrentView obtém o ID da nova visualização.

    await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
    Frame frame = new Frame();
    frame.Navigate(typeof(SecondaryPage), null);   
    Window.Current.Content = frame;
    // You have to activate the window in order to show it later.
    Window.Current.Activate();

    newViewId = ApplicationView.GetForCurrentView().Id;
});

  4. Mostrar a nova exibição chamando ApplicationViewSwitcher.TryShowAsStandaloneAsync.

    Depois de criar um novo modo de exibição, você pode mostrá-lo em uma nova janela chamando o método ApplicationViewSwitcher.TryShowAsStandaloneAsync . O parâmetro viewId para esse método é um inteiro que identifica exclusivamente cada uma das exibições em seu aplicativo. Você obtém a visualização Id usando a propriedade ApplicationView.Id ou o método ApplicationView.GetApplicationViewIdForWindow.

    bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);

Visão principal

A primeira exibição criada quando seu aplicativo é iniciado é chamada de exibição principal. Essa exibição é armazenada na propriedade CoreApplication.MainView e sua propriedade IsMain é verdadeira. Você não cria essa exibição; ela é criada pelo aplicativo. O thread do modo de exibição principal serve como o gerenciador do aplicativo e todos os eventos de ativação do aplicativo são entregues nesse thread.

Se as exibições secundárias estiverem abertas, a janela do modo de exibição principal poderá ser ocultada, por exemplo, clicando no botão fechar (x) na barra de título da janela, mas seu thread continuará ativo. Chamar Fechar na janela do modo de exibição principal faz com que uma InvalidOperationException ocorra. (Use Application.Exit para fechar seu aplicativo.) Se o thread do modo de exibição principal for encerrado, o aplicativo será fechado.

Visões secundárias

Outros modos de exibição, incluindo todos os modos de exibição criados chamando CreateNewView no código do aplicativo, são exibições secundárias. A exibição principal e as exibições secundárias são armazenadas na coleção CoreApplication.Views . Normalmente, você cria exibições secundárias em resposta a uma ação do usuário. Em alguns casos, o sistema cria exibições secundárias para seu aplicativo.

Observação

Você pode usar o recurso de acesso atribuído do Windows para executar um aplicativo no modo quiosque . Quando você faz isso, o sistema cria uma exibição secundária para apresentar a interface do usuário do aplicativo acima da tela de bloqueio. Exibições secundárias criadas pelo aplicativo não são permitidas, portanto, se você tentar mostrar sua própria exibição secundária no modo de quiosque, uma exceção será gerada.

Alternar de uma exibição para outra

Considere fornecer uma maneira para o usuário navegar de uma janela secundária de volta para sua janela principal. Para fazer isso, use o método ApplicationViewSwitcher.SwitchAsync . Você chama esse método do thread da janela da qual está alternando e passa a ID de exibição da janela para a qual está alternando.

await ApplicationViewSwitcher.SwitchAsync(viewIdToShow);

Ao usar SwitchAsync, você pode escolher se deseja fechar a janela inicial e removê-la da barra de tarefas especificando o valor de ApplicationViewSwitchingOptions.

  • Last updated on