Compartilhar via

Mostrar várias exibições com ApplicationView

  • Artigo

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 maneira independente. A barra de tarefas mostra cada janela separadamente. Os usuários podem mover, redimensionar, mostrar e ocultar janelas do aplicativo de maneira independente e alternar janelas do aplicativo como se elas fossem aplicativos separados. Cada janela funciona no próprio thread.

APIs importantes: ApplicationViewSwitcher, CreateNewView

O que é uma exibição?

Modo de exibição do 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.

Os modos de exibição são gerenciados pelo objeto CoreApplication. Você chama CoreApplication.CreateNewView para criar um objetoCoreApplicationView. O CoreApplicationView reúne um CoreWindow e um CoreDispatcher (armazenados nas propriedades CoreWindow e Dispatcher). É possível pensar no CoreApplicationView como o objeto que o Windows Runtime usa para interagir com o sistema básico do Windows.

Você normalmente 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 o aplicativo interage com o sistema de janelas. Para trabalhar com um ApplicationView, chame o método ApplicationView.GetForCurrentView estático, que obtém uma instância ApplicationView vinculada ao thread atual de 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 um novo modo de exibição

Embora cada layout de aplicativo seja exclusivo, recomendamos incluir um botão de "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 em "Abrir em uma nova janela".

Vamos examinar as etapas de criação de um novo modo de exibiçã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 um novo modo de exibição

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

    CoreApplicationView newView = CoreApplication.CreateNewView();

  2. Acompanhe a Id do novo modo de exibição. Você pode usá-la para mostrar o modo de exibição mais tarde.

    Convém considerar a criação de uma infraestrutura no aplicativo para ajudar no controle dos modos de exibição criados. Consulte a classe ViewLifetimeControl na Amostra MultipleViews para obter um exemplo.

    int newViewId = 0;

  3. No novo thread, preencha a janela.

    Você usa 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 uma expressão lambda para passar uma função como um argumento para o método RunAsync. O trabalho feito na função lambda acontece no thread do novo modo de exibição.

    Em XAML, você normalmente adiciona um Frame à propriedade Content de Window e passa o Frame para um XAML Page em que você definiu o conteúdo do aplicativo. Para obter mais informações sobre quadros e páginas, confira Navegação ponto a ponto entre duas páginas.

    Depois que o novo Window for preenchido, você deverá chamar o método Activate de Window para mostrar o Window mais tarde. Esse trabalho acontece no thread do novo modo de exibição, logo, o novo Window é ativado.

    Por fim, obtenha a Id do novo modo de exibição que você usa para mostrar o modo de exibição mais tarde. Mais uma vez, esse trabalho é feito no thread do novo modo de exibição, logo, ApplicationView.GetForCurrentView obtém a Id do novo modo de exibiçã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. Mostre o novo modo de exibição chamando ApplicationViewSwitcher.TryShowAsStandaloneAsync.

    Depois de criar um novo modo de exibição, você poderá mostrá-lo em uma nova janela chamando o método ApplicationViewSwitcher.TryShowAsStandaloneAsync. O parâmetro viewId desse método é um inteiro que identifica com exclusividade cada um dos modos de exibição no aplicativo. Você recupera a Id do modo de exibição usando a propriedade ApplicationView.Id ou o método ApplicationView.GetApplicationViewIdForWindow.

    bool viewShown = await ApplicationViewSwitcher.TryShowAsStandaloneAsync(newViewId);

O modo de exibição principal

O primeiro modo de exibição criado quando o aplicativo é iniciado é chamado de modo de exibição principal. Esse modo de exibição é armazenado na propriedade CoreApplication.MainView, e a propriedade IsMain é verdadeira. Você não cria esse modo de exibição; ele é criado pelo aplicativo. O thread do modo de exibição principal funciona como o gerenciador para o aplicativo, e todos os eventos de ativação do aplicativo são fornecidos nesse thread.

Caso os modos de exibição secundários estejam abertos, a janela do modo de exibição principal pode permanecer oculta – por exemplo, clicando-se no botão de fechamento (x) na barra de título da janela –, mas o thread permanece ativo. Chamar Close no Window do modo de exibição principal causa a ocorrência de InvalidOperationException. (Use Application.Exit para fechar seu aplicativo.) Se o thread do modo de exibição principal for encerrado, o aplicativo será fechado.

Modos de exibição secundários

Outros modos de exibição, inclusive todos os modos de exibição que você cria chamando CreateNewView no código do aplicativo, são modos de exibição secundários. Os modos de exibição principal e secundário são armazenados na coleção CoreApplication.Views. Normalmente, você cria modos de exibição secundários em resposta à ação de um usuário. Em alguns casos, o sistema cria modos de exibição secundários para o aplicativo.

Observação

Você pode usar o recurso acesso atribuído do Windows para executar um aplicativo em modo de quiosque. Quando você faz isso, o sistema cria um modo de exibição secundário para apresentar a interface do usuário do aplicativo acima da tela de bloqueio. Os modos de exibição secundários criados pelo aplicativo não são permitidos, logo, caso você tente mostrar o próprio modo de exibição secundário no modo de quiosque, uma exceção é lançada.

Alternar de um modo de exibição para outro

É recomendável oferecer uma maneira para o usuário navegar de uma janela secundária para sua janela pai. Para fazer isso, use o método ApplicationViewSwitcher.SwitchAsync. Você chama esse método no thread da janela da qual está alternando e passa a ID do modo de exibição da janela para a qual 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.