Manipulando a suspensão, retomada e ativação no Hilo (aplicativos da Windows Store em C++ e XAML)

Applies to Windows only

De: Desenvolvendo um aplicativo da Windows Store de ponta a ponta em C++ e XAML: Hilo

Logotipo padrões & práticas

Página anterior | Próxima página

O Hilo fornece exemplos de como suspender e retomar um aplicativo que usa C++ e XAML. Você pode usar este exemplos para escrever um aplicativo que gerencia totalmente seu ciclo de vida de execução. A suspensão pode ocorrer a qualquer momento e então você precisa salvar os dados de seu aplicativo para que ele possa ser retomado corretamente.

Baixar

Baixar o exemplo do Hilo
Baixar o manual (PDF)

Depois de baixar o código, veja as instruções em Aprenda a usar o Hilo.

Você aprenderá

  • Como o histórico de ativação do aplicativo afeta seu comportamento.
  • Como implementar suporte para a suspensão e a retomada usando C++ e XAML.

Aplica-se a

  • Tempo de Execução do Windows para o Windows 8
  • Extensões de componentes do Visual C++ (C++/CX)
  • XAML

Dicas para implementar a suspensão/retomada

Você deve criar seu aplicativo para ser suspenso corretamente quando o usuário sai dele ou quando há um estado de baixo consumo de energia. Você também deve criar o aplicativo para ser retomado corretamente quando o usuário volta a ele ou quando o Windows sai do estado de baixo consumo de energia. Veja a seguir alguns pontos importantes.

  • Salve os dados do aplicativo quando ele é suspenso.
  • Retome o aplicativo no estado em que o usuário o deixou, em vez de iniciá-lo novamente.
  • Permita que os modos de exibição e os modelos de exibição sejam salvos e restaure o estado relevante para cada um deles. Por exemplo, se o usuário digitou texto em uma caixa de texto, mas ainda não saiu dela, você pode salvar o texto parcialmente inserido como um estado do modo de exibição. No Hilo, apenas os modelos de exibição precisam salvar o estado.
  • Libere recursos exclusivos quando o aplicativo é suspenso.
  • Quando o aplicativo é retomado, atualize a interface do usuário, caso o conteúdo tenha mudado.
  • Quando o aplicativo é retomado depois de encerrado, use os dados salvos do aplicativo para restaurá-lo.

Veja Diretrizes para a suspensão e retomada de aplicativos (aplicativos da Windows Store).

[Início]

Entendendo possíveis estados de execução

Os eventos que ocorrem quando você ativa um aplicativo dependem do histórico de execução do aplicativo. Há cinco casos para considerar. Os casos correspondem aos valores da enumeração Windows::ActivationModel::Activation::ApplicationExecutionState.

  • NotRunning
  • Terminated
  • ClosedByUser
  • Suspended
  • Running

Veja aqui um diagrama que mostra como o Windows determina o estado de execução do aplicativo. No diagrama, o retângulo azul indica que o aplicativo não está carregado na memória do sistema. Os retângulos brancos indicam que o aplicativo está na memória. Os arcos tracejados são mudanças que ocorrem sem qualquer notificação para o aplicativo em execução. Os arcos sólidos são ações que incluem a notificação do aplicativo.

A estado de execução de um aplicativo

O estado de execução depende do histórico do aplicativo. Por exemplo, quando o usuário inicia o aplicativo pela primeira vez depois de instalá-lo ou depois de reiniciar o Windows, o estado de execução anterior é NotRunning, e o estado após a ativação é Running. Os argumentos do evento de ativação incluem uma propriedade PreviousExecutionState que informa o estado do aplicativo antes dele ter sido ativado.

Se o usuário alternar para outro aplicativo ou se o sistema entrar em um modo de operação de baixo consumo de energia, o Windows notifica o aplicativo de que ele está sendo suspenso. Nesse momento, você deve salvar o estado de navegação e todos os dados do usuário que representam a sessão do usuário. Você também deve liberar recursos exclusivos do sistema, como arquivos e conexões de rede abertos.

O Windows dá cinco segundos para o aplicativo manipular o evento Suspending. Se o manipulador de eventos Suspending não terminar nesse período, o Windows assume que o aplicativo parou de responder e o encerra.

Depois que o aplicativo responde ao evento Suspending, seu estado é Suspended. Se o usuário volta para o aplicativo, o Windows o retoma e permite que ele seja executado novamente.

O Windows pode encerrar o aplicativo (sem notificação) depois que ele foi suspenso. Por exemplo, se o sistema está com poucos recursos, ele pode decidir recuperar recursos mantidos por aplicativos suspensos. Se o usuário inicia seu aplicativo depois que o Windows o encerrou, o estado de execução anterior do aplicativo no momento da ativação é Terminated.

Você pode usar o estado de execução anterior para determinar se o aplicativo precisa restaurar os dados que ele salvou na última vez em que foi suspenso ou se você deve carregar os dados padrão do aplicativo. Em geral, se o aplicativo falha ou se o usuário o fecha, o reinício do aplicativo deve levar o usuário para o estado de navegação inicial padrão do aplicativo. Quando um aplicativo determina que está ativado depois de ter sido encerrado, ele deve carregar os dados do aplicativo salvos durante a suspensão para que o aplicativo apareça como quando estava suspenso. Você pode ver como isso funciona no passo a passo do código do suporte do Hilo para a suspensão e a retomada nesta página.

Observação  Quando o aplicativo está suspenso, mas ainda não foi encerrado, você pode retomá-lo sem restaurar nenhum estado. O aplicativo ainda estará na memória. Nessa situação, talvez seja necessário readquirir recursos e atualizar a interface do usuário para refletir as mudanças do ambiente que ocorreram enquanto o aplicativo estava suspenso. Por exemplo, o Hilo atualiza sua exibição das Imagens do usuário quando é retomado do estado suspenso.

Veja Enumeração ApplicationExecutionState para saber mais sobre cada um dos possíveis estados de execução anteriores. Veja em Ciclo de vida do aplicativo (aplicativos da Windows Store) uma descrição do processo de suspensão/retomada. Você também pode consultar Diretrizes para suspensão e retomada de aplicativos (aplicativos da Windows Store) para ver informações sobre a experiência do usuário recomendada para a suspensão e a retomada.

[Início]

Abordagens de implementação para suspensão e retomada em C++ e XAML

Para aplicativos da Windows Store como o Hilo, que usam um modelo de projeto do Visual Studio, a implementação de suspensão/retomada envolve quatro componentes do sistema.

  • Windows Core. O evento Activated da classe Windows::ApplicationModel::Core::CoreApplicationView permite que um aplicativo receba notificações relacionadas à ativação.
  • XAML. A classe Windows::UI::Xaml::Application fornece o método OnLaunched que a classe App de seu aplicativo deve substituir para executar a inicialização do aplicativo e exibir seu conteúdo inicial. A classe Application do XAML invoca o método OnLaunched quando o usuário inicia o aplicativo. Quando você cria um novo projeto para um aplicativo da Windows Store usando um dos modelos de projeto do Microsoft Visual Studio para C++ e XAML, o Visual Studio cria uma classe App derivada de Windows::UI::Xaml::Application e substitui o método OnLaunched. Você pode especializar o código criado pelo Visual Studio ou usá-lo sem mudanças.
  • Classes de modelo do Visual Studio. Quando você cria um novo projeto para um aplicativo da Windows Store, o Visual Studio cria várias classes para você na pasta de soluções Common. Uma dessas classes é SuspensionManager. Essa classe fornece métodos que funcionam com a classe Windows::UI::Xaml::Application para torná-la conveniente para salvar e restaurar o estado do aplicativo. A classe SuspensionManager interage com a classe Windows::UI::Xaml::Frame para salvar e restaurar a pilha de navegação do aplicativo para você. A classe SuspensionManager interage com a classe do modelo LayoutAwarePage para integrar o salvamento do estado da página nos momentos apropriados.
  • As classes da página do seu aplicativo. O Hilo salva o estado de navegação com cada invocação do método OnNavigatedFrom. As páginas do Hilo delegam o salvamento do estado às classes do modelo de exibição associado. Os modelos de exibição do Hilo implementam os métodos LoadState e SaveState.

Observação  O Hilo não interage diretamente com os eventos relacionados à ativação da classe CoreApplicationView. Nós os mencionamos aqui caso seu aplicativo precise ter acesso a essas notificações de nível inferior.

Observação  O usuário pode ativar um aplicativo por meio de diversos contratos e extensões. A classe Application chama o método OnLaunched somente no caso de um início normal. Veja a classe Windows::UI::Xaml::Application para saber mais sobre como detectar outros tipos de eventos de ativação. No Hilo, nós precisávamos manipular apenas o início normal.

O resto desta página é um passo a passo de como o Hilo implementa a suspensão e a retomada usando essas camadas do sistema.

[Início]

Passo a passo do código de suspensão

Este diagrama mostra a interação das classes que implementam a operação de suspensão no Hilo.

Gráfico da sequência de suspensão

Quando o Hilo é iniciado, ele registra um manipulador para o evento Suspending que é fornecido pela classe base Application.

App.xaml.cpp


Suspending += ref new SuspendingEventHandler(this, &App::OnSuspending);


O Windows invoca o manipulador de eventos App::OnSuspending antes de suspender o aplicativo. O Hilo usa o manipulador de eventos para salvar dados relevantes do aplicativo e do usuário em um armazenamento persistente.

App.xaml.cpp


void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e)
{
    (void) sender; // Unused parameter
    assert(IsMainThread());

    auto deferral = e->SuspendingOperation->GetDeferral();
    HiloPage::IsSuspending = true;
    SuspensionManager::SaveAsync().then([=](task<void> antecedent)
    {
        HiloPage::IsSuspending = false;
        antecedent.get();
        deferral->Complete();
    });
}


O manipulador de eventos Suspending do Hilo é assíncrono. Se o manipulador de um evento Suspending é assíncrono, ele deve notificar ao chamador quando seu trabalho é concluído. Para fazer isso, o manipulador invoca o método GetDeferral, que retorna um objeto SuspendingDeferral e chama o método Complete desse objeto no final da operação assíncrona.

O método SaveAsync da classe SuspensionManager persiste os dados do usuário e de navegação do aplicativo para o disco. Depois que a operação de salvamento termina, uma tarefa de continuação notifica o objeto de adiamento de que o aplicativo está pronto para ser suspenso.

Observação  No Hilo, nós definimos a propriedade estática HiloPage::IsSuspending para estabelecer o contexto quando o aplicativo recebe retornos de chamada do método SaveAsync. Precisamos saber se o método OnNavigatedFrom é chamado no caso de operação normal ou se ele é chamado durante o salvamento de estado de suspensão/retomada. Por exemplo, quando o usuário navega para fora de uma página, às vezes o aplicativo precisa desconectar manipuladores de eventos dessa página. Não queremos desconectar os manipuladores de eventos ao suspender.

O método SaveAsync da classe SuspensionManager grava o estado da sessão atual no disco. O método SaveAsync chama o método GetNavigationState de cada objeto Frame registrado. No Hilo, há apenas um quadro registrado e ele corresponde à página atual. O método GetNavigationState invoca o método OnNavigatedFrom do objeto da página associada ao quadro.

No Hilo, cada página é uma instância da classe HiloPage. Este é o método OnNavigatedFrom dessa classe.

HiloPage.cpp


void Hilo::HiloPage::OnNavigatedFrom(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e)
{
    ViewModelBase^ viewModel = dynamic_cast<ViewModelBase^>(DataContext);
    if (!HiloPage::IsSuspending) 
    {        
        // Since we never receive destructs, this is the only place to unsubscribe.
        DetachNavigationHandlers(viewModel);
        viewModel->OnNavigatedFrom(e);
    }

   LayoutAwarePage::OnNavigatedFrom(e);
}


O método OnNavigatedFrom da classe HiloPage atualiza os modelos de exibição e depois invoca o método OnNavigatedFrom de sua classe base, LayoutAwarePage.

LayoutAwarePage.cpp


void LayoutAwarePage::OnNavigatedFrom(NavigationEventArgs^ e)
{
    auto frameState = SuspensionManager::SessionStateForFrame(Frame);
    auto pageState = ref new Map<String^, Object^>();
    SaveState(pageState);
    frameState->Insert(_pageKey, pageState);
}


O método OnNavigatedFrom da classe LayoutAwarePage obtém um objeto do gerenciador de suspensão e o define como o valor da variável frameState. Esse objeto implementa a interface de Windows::Foundation::Collections::IMap<String^, Object^>. Ele representa todo o estado que foi coletado até o momento durante a operação de SaveAsync. Em seguida, o código chama o método SaveState da página para complementar o objeto frameState com informações da página atual.

Observação  O método OnNavigatedFrom é chamado durante a operação de suspensão, mas também para a navegação normal, enquanto o aplicativo está em execução. O Hilo também usa os métodos SaveState e LoadState para dar suporte à navegação de volta a um estado conhecido. Por exemplo, depois que o usuário corta uma imagem e retorna à página de exibição de imagens, a restauração do estado na navegação permite que a página de exibição de imagens mostre a foto correta.

Este é o método SaveState.

HiloPage.cpp


void HiloPage::SaveState(IMap<String^, Object^>^ pageState)
{
    auto vm = dynamic_cast<ViewModelBase^>(DataContext);
    if (vm != nullptr)
    {
        auto vmStateMap = ref new Map<String^, Object^>();
        vm->SaveState(vmStateMap);

        pageState->Insert(viewModelStateKey, vmStateMap);
    }
}


No Hilo, a página delega o salvamento de estado a seu modelo de exibição associado e usa um único par chave/valor para os dados de toda a página. Por exemplo, se a página exibida no momento é a página de exibição de imagens, o método aplicável é o método SaveState da classe ImageViewModel do Hilo.

ImageViewModel.cpp


void ImageViewModel::SaveState(IMap<String^, Object^>^ stateMap)
{
    if (m_currentPhotoImage != nullptr)
    {
        std::wstringstream stringSerialization;
        stringSerialization << m_monthDate.UniversalTime ;

        stateMap->Insert(FilePathMapKey, m_currentPhotoImage->Path);
        stateMap->Insert(FileDateMapKey, ref new String(stringSerialization.str().c_str()));
        stateMap->Insert(QueryMapKey, m_query);
    }
}


Este código mostra como a classe do modelo de exibição da imagem salva três informações: o caminho e o nome da imagem atual, a data do grupo de meses atual e a consulta usada. Outros modelos de exibição salvam os estados relevantes para suas operações.

Você pode usar qualquer técnica de serialização que quiser, mas o resultado final deve ser convertido em uma referência de Platform::Object^. Você pode escolher qualquer chave que quiser para os pares chave/valor. Certifique-se apenas de usar chaves exclusivas na página atual e use as mesmas chaves quando restaurar os dados mais tarde.

[Início]

Passo a passo do código de retomada

Quando um aplicativo é retomado do estado Suspended, ele entra no estado Running e continua de onde estava quando foi suspenso. Nenhum dado do aplicativo é perdido, pois eles foram armazenados na memória, então a maioria dos aplicativos não precisa fazer nada na retomada.

É possível que o aplicativo retomado tenha sido suspenso por horas ou dias. Assim, se o aplicativo tiver conteúdo ou conexões de rede que possam ter ficado obsoletos, eles precisam ser atualizados quando o aplicativo é retomado. Quando um aplicativo é suspenso, ele não recebe itens de eventos de rede ou de arquivo que está registrado para receber. Esses eventos não são colocados em fila, eles são simplesmente ignorados. Nessa situação, seu aplicativo deve testar os status de rede ou de arquivo ao ser retomado. O aplicativo também pode atualizar o estado dependente de localização, como uma posição no mapa.

Se um aplicativo registrou um manipulador de eventos para o evento Resuming, ele é chamado quando o aplicativo é retomado do estado Suspended. Você pode atualizar seu conteúdo usando esse manipulador de eventos. O Hilo assina o evento Resuming para atualizar seu modo de exibição de Imagens.

App.xaml.cpp


Resuming += ref new EventHandler<Platform::Object^>(this, &App::OnResume);


Esta é a função membro App::OnResume.

App.xaml.cpp


void App::OnResume(Object^ sender, Platform::Object^ e)
{
    (void) sender; // Unused parameter
    (void) e;      // Unused parameter
    assert(IsMainThread());

    if (m_repository != nullptr)
    {
        // Hilo does not receive data change events when suspended. Create these events on resume.
        m_repository->NotifyAllObservers();
    }
}


Este código informa o objeto do repositório de arquivos do aplicativo que ele deve gerar eventos de alteração de dados para modelos de exibição que precisam responder a mudanças do sistema de arquivos. O Hilo não tenta detectar mudanças de dados ocorridas enquanto ele estava suspenso.

[Início]

Passo a passo do código de ativação após o encerramento do aplicativo

Se o Windows encerrou um aplicativo suspenso, a classe base Application chama o método OnLaunched quando o aplicativo fica ativo novamente. Este diagrama mostra a interação de classes no Hilo que restaura o aplicativo depois que ele foi encerrado.

Diagrama da sequência de retomada

A classe App do Hilo substitui o método OnLaunched da classe base Windows::UI::Xaml::Application. Quando o método OnLaunched de sua classe App é executado, seu argumento é um objeto LaunchActivatedEventArgs. Esse objeto contém uma enumeração ApplicationExecutionState que informa o estado de execução anterior do aplicativo. Este é o código.

App.xaml.cpp


void App::OnLaunched(LaunchActivatedEventArgs^ args)
{
    assert(IsMainThread());
    auto rootFrame = dynamic_cast<Frame^>(Window::Current->Content);

    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == nullptr)
    {
        // Create a Frame to act as the navigation context and associate it with
        // a SuspensionManager key. See http://go.microsoft.com/fwlink/?LinkId=267280 for more info 
        // on Hilo's implementation of suspend/resume.
        rootFrame = ref new Frame();
        SuspensionManager::RegisterFrame(rootFrame, "AppFrame");

        auto prerequisite = task<void>([](){});
        if (args->PreviousExecutionState == ApplicationExecutionState::Terminated)
        {
            // Restore the saved session state only when appropriate, scheduling the
            // final launch steps after the restore is complete
            prerequisite = SuspensionManager::RestoreAsync();
        }
        prerequisite.then([=](task<void> prerequisite)
        {
            try
            {
                prerequisite.get();
            }
            catch (Platform::Exception^)
            {
                //Something went wrong restoring state.
                //Assume there is no state and continue
            }

            if (rootFrame->Content == nullptr)
            {
                // When the navigation stack isn't restored navigate to the first page,
                // configuring the new page by passing required information as a navigation
                // parameter.  See http://go.microsoft.com/fwlink/?LinkId=267278 for a walkthrough of how 
                // Hilo creates pages and navigates to pages.
                if (!rootFrame->Navigate(TypeName(MainHubView::typeid)))
                {
                    throw ref new FailureException((ref new LocalResourceLoader())->GetString("ErrorFailedToCreateInitialPage"));
                }
            }

            // Place the frame in the current Window
            Window::Current->Content = rootFrame;
            // Ensure the current window is active
            Window::Current->Activate();

        }, task_continuation_context::use_current());
    }
    else
    {
        if (rootFrame->Content == nullptr)
        {
            // When the navigation stack isn't restored navigate to the first page,
            // configuring the new page by passing required information as a navigation
            // parameter. See http://go.microsoft.com/fwlink/?LinkId=267278 for a walkthrough of how 
            // Hilo creates pages and navigates to pages.
            if (!rootFrame->Navigate(TypeName(MainHubView::typeid)))
            {
                throw ref new FailureException((ref new LocalResourceLoader())->GetString("ErrorFailedToCreateInitialPage"));
            }
        }
        // Ensure the current window is active
        Window::Current->Activate();
    }

    // Schedule updates to the tile. See http://go.microsoft.com/fwlink/?LinkId=267275 for
    // info about how Hilo manages tiles.
    m_tileUpdateScheduler = std::make_shared<TileUpdateScheduler>();
    m_tileUpdateScheduler->ScheduleUpdateAsync(m_repository, m_exceptionPolicy);
}


O código verifica seu argumento para ver se o estado anterior era Terminated. Se for, o método chama o método RestoreAsync da classe SuspensionManager para recuperar as configurações salvas do arquivo _sessionState.dat.

O método RestoreAsync lê as informações de estado salvas e chama o método SetNavigationState de cada quadro registrado que foi salvo anteriormente. Veja Passo a passo do código de suspensão nesta página para ver como ocorre o salvamento.

O método SetNavigationState de caca quadro chama o método OnNavigatedTo de sua página associada. Veja aqui como a classe HiloPage substitui o método OnNavigatedTo.

HiloPage.cpp


void HiloPage::OnNavigatedTo(NavigationEventArgs^ e)
{
    
    ViewModelBase^ viewModel = dynamic_cast<ViewModelBase^>(DataContext);
    this->AttachNavigationHandlers(viewModel);
    if (viewModel != nullptr)
    {
        viewModel->OnNavigatedTo(e);
    }

    LayoutAwarePage::OnNavigatedTo(e);
}


A página do Hilo chama o método OnNavigatedTo de seu modelo de exibição associado. Por exemplo, se a página exibida no momento é a página de exibição de imagens, o método aplicável é o método OnNavigatedTo da classe ImageViewModel do Hilo. Este é o código.

ImageViewModel.cpp


void ImageViewModel::OnNavigatedTo(NavigationEventArgs^ e)
{
    auto data = dynamic_cast<String^>(e->Parameter);
    ImageNavigationData imageData(data);
    Initialize(imageData.GetFilePath(), imageData.GetMonthGroupDate(), imageData.GetDateQuery());
}


Neste exemplo, o código extrai as informações de navegação salvas do argumento e atualiza o modelo de exibição.

Depois que o método OnNavigatedTo do modelo de exibição é concluído, o objeto HiloPage invoca o método OnNavigatedTo de sua classe base, LayoutAwarePage.

LayoutAwarePage.cpp


void LayoutAwarePage::OnNavigatedTo(NavigationEventArgs^ e)
{
    // Returning to a cached page through navigation shouldn't trigger state loading
    if (_pageKey != nullptr) return;

    auto frameState = SuspensionManager::SessionStateForFrame(Frame);
    _pageKey = "Page-" + Frame->BackStackDepth;

    if (e->NavigationMode == NavigationMode::New)
    {
        // Clear existing state for forward navigation when adding a new page to the
        // navigation stack
        auto nextPageKey = _pageKey;
        int nextPageIndex = Frame->BackStackDepth;
        while (frameState->HasKey(nextPageKey))
        {
            frameState->Remove(nextPageKey);
            nextPageIndex++;
            nextPageKey = "Page-" + nextPageIndex;
        }

        // Pass the navigation parameter to the new page
        LoadState(e->Parameter, nullptr);
    }
    else
    {
        // Pass the navigation parameter and preserved page state to the page, using
        // the same strategy for loading suspended state and recreating pages discarded
        // from cache
        LoadState(e->Parameter, safe_cast<IMap<String^, Object^>^>(frameState->Lookup(_pageKey)));
    }
}


O LayoutAwarePage obtém o estado salvo anteriormente da página da classe SuspensionManager. Então, ele chama o método LoadState da página para desserializar o estado salvo da página e restaurá-lo. Este é o código do método LoadState da classe HiloPage e da classe ImageViewModel.

HiloPage.cpp


void HiloPage::LoadState(Object^ navigationParameter, IMap<String^, Object^>^ pageState)
{
    auto vm = dynamic_cast<ViewModelBase^>(DataContext);
    if (vm != nullptr && pageState != nullptr)
    {
        IMap<String^, Object^>^ state = nullptr;
        state = dynamic_cast<IMap<String^, Object^>^>(pageState->Lookup(viewModelStateKey));

        vm->LoadState(state);
    }
}


ImageViewModel.cpp


void ImageViewModel::LoadState(IMap<String^, Object^>^ stateMap)
{
    if (stateMap != nullptr)
    {
        auto filePath = dynamic_cast<String^>(stateMap->Lookup(FilePathMapKey));

        auto fileDateString = dynamic_cast<String^>(stateMap->Lookup(FileDateMapKey));
        DateTime fileDate;
        fileDate.UniversalTime = _wtoi64(fileDateString->Data());

        auto query = dynamic_cast<String^>(stateMap->Lookup(QueryMapKey));

        Initialize(filePath, fileDate, query);
    }
}


Este código desserializa as informações salvas anteriormente do modelo de exibição da imagem. Você pode compará-las com o código que salvou os dados originalmente, que aparece acima em Passo a passo do código de suspensão nesta página.

[Início]

Outras maneiras de sair do aplicativo

Os aplicativos não contém uma interface do usuário para fechar o aplicativo, mas os usuários podem optar por fechar um aplicativo pressionando Alt+F4, arrastando o aplicativo da Página Inicial ou selecionando o menu de contexto Fechar. Quando um aplicativo é fechado usando qualquer desse métodos, ele entra no estado NotRunning por aproximadamente dez segundos e depois passa para o estado ClosedByUser.

Os aplicativos não devem se fechar de forma programática como parte da execução normal. Quando você fecha um aplicativo de forma programática, o Windows trata isso como uma falha de aplicativo. O aplicativo entra no estado NotRunning e permanece assim até o usuário ativá-lo novamente.

Seu aplicativo deve seguir a experiência de falha do sistema, que é simplesmente retornar à página inicial.

Veja aqui um diagrama que mostra como o Windows determina o estado de execução do aplicativo. O Windows considera as falhas de aplicativo e ações de fechamento do usuário, assim como o estado de suspensão ou retomada. No diagrama, o retângulo azul indica que o aplicativo não está carregado na memória do sistema. Os retângulos brancos indicam que o aplicativo está na memória. Os arcos tracejados são mudanças que ocorrem sem qualquer notificação para o aplicativo em execução. Os arcos sólidos são ações que incluem a notificação do aplicativo.

Estados de execução do aplicativo

[Início]

 

 

Mostrar:
© 2014 Microsoft