Gerenciando o ciclo de vida para que os aplicativos pareçam estar sempre ativos

Blog do desenvolvedor de aplicativos do Windows 8

Ideias sobre a criação de aplicativos com o estilo Metro para o Windows 8, da equipe de engenharia do Windows 8

Gerenciando o ciclo de vida para que os aplicativos pareçam estar sempre ativos

  • Comments 0

Com o modelo de ciclo de vida do aplicativo no Windows 8, os usuários não precisam mais gerenciar a execução simultânea dos aplicativos. Com ele, os desenvolvedores também podem criar facilmente uma excelente experiência do usuário que não afete a bateria ou o desempenho do dispositivo quando o aplicativo estiver em segundo plano. Usando os eventos de ciclo de vida, o seu aplicativo sempre parecerá ativo, mesmo que nunca esteja em execução quando não estiver sendo exibido na tela.

Hoje, as baterias de laptops, tablets e telefones sempre acabam logo porque todos nós tendemos a deixar aplicativos em execução mesmo quando não estão em uso. Fazemos isso por conveniência e para alternar rapidamente entre eles.

Tínhamos isto em mente quando desenvolvemos o modelo de ciclo de vida de aplicativos estilo Metro no Windows 8: manter os aplicativos com grande capacidade de resposta, preservar a vida útil da bateria e proporcionar um desempenho excelente e consistente. Os aplicativos estilo Metro apresentam tela inteira e experiências imersivas. Sendo assim, o novo modelo de ciclo de vida do Windows 8 enfoca os aplicativos em primeiro plano, garantindo uma experiência ativa de interação com o usuário e o uso de todo o potencial do dispositivo. Nesta postagem, falarei sobre os novos estados do modelo de ciclo de vida e o que você precisa para tornar o seu aplicativo excelente.

Ciclo de vida de aplicativos estilo Metro

O seu aplicativo estilo Metro sempre se encontra em um destes quatro estados de ciclo de vida: não está em execução, em execução , suspenso ou terminado. Conforme o seu aplicativo muda de um estado para outro, ele recebe eventos de ciclo de vida que ajudam você a oferecer uma experiência consistente e de alto desempenho para os seus usuários.

Este diagrama mostra como um aplicativo estilo Metro muda de um estado para outro:

3 caixas com setas entre si em um padrão circular. Não está em execução > ativando > em execução > suspendendo > suspenso > terminando > sem execução.

Todos os aplicativos estilo Metro percorrem esses estados conforme os usuários iniciam aplicativos, alternam entre eles e fecha-os. O seu aplicativo provavelmente alternará entre os estados em execução e suspenso com frequência conforme os usuários alternarem entre aplicativos. Portanto, o seu aplicativo deve manipular os eventos de ciclo de vida.

Conforme o seu aplicativo mudar de um estado de ciclo de vida para outro, ele receberá estes eventos de ciclo de vida:

Evento De Para

activated

não está em execução

em execução

suspending ou checkpoint (WinJS)

em execução

suspenso

resuming

suspenso

em execução

Suspenso

Em geral, os aplicativos estilo Metro interrompem a execução quando o usuário usa outro aplicativo. O Windows suspende o seu aplicativo quando ele não está em primeiro plano. Quando o seu aplicativo é suspenso, ele fica congelado na memória. Ele não pode ser executado nesse estado, mas o Windows pode retomá-lo quando o usuário voltar a ele. Dessa forma, o Windows permite que o aplicativo em primeiro plano use melhor os recursos do sistema e garante que os aplicativos em segundo plano não acabem com a bateria do usuário.

Quando o seu aplicativo sai do primeiro plano, o Windows aguarda alguns segundos para permitir um rápido retorno ao aplicativo e tenta suspender o aplicativo. O seu aplicativo deve ser registrado para os eventos suspending ou checkpoint (JavaScript), que ele recebe quando o Windows deseja suspendê-lo. Esse é um intervalo importante para o seu aplicativo; use essa oportunidade para salvar dados do aplicativo que devem ser mantidos em armazenamento persistente. Normalmente, o seu aplicativo é retomado da forma como foi interrompido, e você não precisa usar os dados persistentes porque eles são mantidos na memória. Mas é necessário armazenar esses dados para o caso de o Windows terminar o seu aplicativo para liberar recursos do sistema. Salve dados do aplicativo suficientes para levar o usuário ao ponto em que ele estava quando o aplicativo foi suspenso. Dessa forma, os seus clientes pensam que o seu aplicativo está sempre ativo e em execução.

Se o seu aplicativo não retornar do manipulador do evento suspending em 5 segundos após receber esse evento, o Windows o terminará. É importante não realizar nenhuma operação pesada no manipulador do evento suspending. Salve os dados do aplicativo e retorne rapidamente.

Nesta postagem, usamos um aplicativo de ações como exemplo. Esse aplicativo pode usar o evento suspending para salvar as últimas ações vistas pelo usuário e o intervalo de tempo do gráfico de ações. Se o aplicativo for terminado, ele poderá ser reiniciado na mesma exibição exata que o usuário estava vendo na última vez. Por exemplo, a recomendação para um aplicativo de ações é usar isso como mais uma oportunidade de enviar uma notificação de bloco local para que o bloco seja atualizado com as últimas informações antes de o Windows suspendê-lo.

Manipulando a suspensão no JavaScript

Se escrever um aplicativo estilo Metro usando a Biblioteca do Windows para JavaScript (WinJS), você poderá usar o evento checkpoint para manipular a suspensão.

var app = WinJS.Application;

function checkpointHandler() {
// The checkpoint event gives us the chance to save application data.
// In this case, we save the current stock info that the user is viewing.
app.sessionState.lastSeenStock = selectedStock;
app.sessionState.lastSeenRange = selectedRange;

// Send client side notifications
Tile.sendTileUpdate(selectedStock, stockInfo.change, stockInfo.lastSale,
stockInfo.lastSaleTime, stockInfo.open);
}

app.addEventListener("checkpoint", checkpointHandler);

Isso é apenas uma visão geral. Para obter mais informações, consulte How to suspend an app (JavaScript and HTML) (Como suspender um aplicativo (JavaScript e HTML)) no Centro de Desenvolvimento.

Manipulando a suspensão em XAML

Se escrever um aplicativo estilo Metro usando XAML e C#, você poderá usar o evento Suspending no objeto do aplicativo para manipular a suspensão do aplicativo.

public App()
{
InitializeComponent();
this.Suspending += new SuspendingEventHandler(OnSuspending);
}

async protected void OnSuspending(object sender, SuspendingEventArgs args)
{
// The Suspending event gives us the chance to save application state
// In this case, we save the current stock info that the user is viewing

// Because writing to a file is asynchronous, we grab a deferral which ensures
// that suspending doesn’t complete until our file write is complete
SuspendingDeferral deferral = args.SuspendingOperation.GetDeferral();

// Here we create a SuspensionManager class which handles adding session data
// to a Dictionary and then serializing that data to a file
SuspensionManager.SessionState["lastSeenStock"] = stock;
SuspensionManager.SessionState["lastSeenRange"] = range;
await SuspensionManager.SaveAsync();

// Send client side notifications
Tile.SendTileUpdate(stock, stockInfo.Change, stockInfo.LastSale,
stockInfo.LastSaleTime, stockInfo.Open);

deferral.Complete();
}

Isso é apenas uma visão geral. Para obter mais informações sobre como manipular a suspensão em XAML e C#, consulte How to suspend an app (VB/C#/C++ and XAML) (Como suspender um aplicativo (VB/C#/C++ e XAML) no Centro de Desenvolvimento.

Retomar

Quando o aplicativo é retomado, ele continua no estado em que estava quando foi suspenso pelo Windows. Sendo mais específico: o estado e os dados do aplicativo são mantidos na memória durante a suspensão do aplicativo, portanto, quando ele é retomado, tudo continua como estava quando o aplicativo foi suspenso. Você não precisa restaurar nenhum dado salvo explicitamente ao receber o evento resuming.

Mas desejamos que o seu aplicativo pareça estar sempre ativo. Para tanto, ele precisa ficar conectado e exibir os últimos dados. É possível que o seu aplicativo fique no estado suspenso por um bom tempo antes de ser retomado. As conexões de rede ou dados podem ficar desatualizadas e talvez seja necessário atualizá-las quando o aplicativo for retomado. Quando o usuário traz o aplicativo para o primeiro plano, o aplicativo recebe o evento retomando. Você pode atualizar o conteúdo do aplicativo e reconectar seus recursos de rede quando o aplicativo receber esse evento.

No nosso aplicativo de ações de exemplo, a retomada é o momento certo para atualizar todos os dados de ações que o aplicativo tinha em cache antes de ser suspenso. Os dados anteriores podem ser de horas ou até dias atrás. A percepção do usuário de que seu aplicativo está sempre ativo é quebrada se o usuário vir esses dados antigos. Ao ser retomado, o nosso aplicativo de ações deve atualizar todos os seus dados. Dessa forma, o usuário vê os últimos gráficos, preços das ações e novos artigos cada vez que o aplicativo é trazido para o primeiro plano.

Manipulando a retomada no JavaScript

No JavaScript, você pode usar o evento resuming do Tempo de Execução do Windows no namespace do Windows.UI.WebUI.WebUIApplication. Trata-se de um evento resuming específico para aplicativos JavaScript.

function resumingHandler() {
//Update the selected stock with the latest news, stock info, and chart data
News.requestNews(stock);
Api.getStockInfoData(stock).then(function(data){displayStockInfo(data); });
Api.getHistoryData(range).then(function (chartData)
{CanvasChart.drawChart("chartCanvas", chartData, Chart.getChartOptions(false));});

// Send client side notifications
Tile.sendTileUpdate(stock, stockInfo.change, stockInfo.lastSale,
stockInfo.lastSaleTime, stockInfo.open);
}

Windows.UI.WebUI.WebUIApplication.addEventListener("resuming", resumingHandler);

Para obter mais informações, consulte How to resume an app (JavaScript and HTML) (Como retomar um aplicativo (JavaScript e HTML)) no Centro de Desenvolvimento.

Manipulando a retomada em XAML

Se escrever um aplicativo estilo Metro usando XAML e C#, você poderá usar o evento Resuming no objeto do aplicativo para manipular a retomada do aplicativo.

public App()
{
InitializeComponent();
this.Resuming += new EventHandler<object>(App_Resuming);
}

async private void App_Resuming(object sender, object e)
{
//Update the selected stock with the latest news, stock info, and chart data
News.RequestNews(stock);

Data data = await Api.GetStockInfoDataAsync(stock);
Api.DisplayStockInfo(data);

Chart chartData = await Api.GetHistoryDataAsync(range);
CanvasChart.DrawChart("chartCanvas", chartData, Chart.GetChartOptions(false));

// Send client side notifications
Tile.SendTileUpdate(stock, stockInfo.Change, stockInfo.LastSale, stockInfo.LastSaleTime, stockInfo.Open);
}

Para obter mais informações sobre como manipular a retomada em VB/C#/C++ e XAML, consulte How to resume an app (VB/C#/C++ and XAML) (Como retomar um aplicativo (VB/C#/C++ e XAML) no Centro de Desenvolvimento.

Ativação

A ativação se refere à forma como o seu aplicativo é iniciado. Ela serve a várias finalidades em um aplicativo estilo Metro. Para obter mais detalhes sobre como você pode usar a ativação de aplicativo estilo Metro para manipular contratos, consulte a nossa postagem Ativando contratos do Windows 8 no seu aplicativo. Enfocamos aqui como você pode usar a ativação para restaurar dados salvos anteriormente caso o Windows termine o seu aplicativo e o usuário o inicie novamente.

O Windows pode terminar o seu aplicativo depois de ele ter sido suspenso for vários motivos. Por exemplo: o usuário sai ou fecha o aplicativo manualmente, ou o sistema fica com poucos recursos (alguns aplicativos, como os jogos, podem consumir recursos demais!). Quando o usuário inicia o seu aplicativo depois de ter sido terminado pelo Windows, o aplicativo recebe o evento activated e o usuário vê a tela inicial do aplicativo até que ele seja ativado. Você pode usar esse evento para determinar se o aplicativo precisa restaurar os dados que salvou quando foi suspenso pela última vez ou se você precisa carregar os dados padrão do aplicativo. Os argumentos do evento activated incluem a propriedade PreviousExecutionState que informa o estado em que o seu aplicativo estava antes de ser ativado. Essa propriedade é um dos valores da enumeração Windows.ApplicationModel.Activation.ApplicationExecutionState .

Motivo do término Valor PreviousExecutionState Ação a ser tomada
Terminado pelo sistema (devido a restrições de recursos, desligamento, reinicialização etc.)

Terminated

Restaurar dados da sessão

Fechado pelo usuário

ClosedByUser

Iniciar com dados padrão

          Terminado inesperadamente ou o aplicativo não foi executado desde o início da sessão do usuário

NotRunning

Iniciar com dados padrão

O valor de PreviousExecutionState também poderia ser Em execução ou Suspenso, mas nesses casos o aplicativo não é terminado anteriormente e, portanto, você não precisa de preocupar com a restauração de dados.

Quando o seu aplicativo é ativado e o valor de PreviousExecutionState é Terminated, é necessário restaurar os dados salvos da sessão para que o aplicativo apareça exatamente como estava quando foi visto pelo usuário pela última vez. Se o aplicativo for fechado pelo usuário manualmente, for terminado inesperadamente ou ainda não tiver sido executado na sessão atual, será necessário ignorar os dados da sessão anterior e iniciá-lo com sua exibição padrão.

O aplicativo de ações do nosso exemplo usa o evento activated para trazer as informações do gráfico e das ações que foram salvas quando foi suspenso. O aplicativo também atualiza os dados de rede em cache. Dessa forma, o usuário vê as mesmas ações que estava vendo antes de deixar o aplicativo, mas os gráficos, preços e novos artigos aparecem atualizados.

Manipulando a ativação no JavaScript

Se escrever um aplicativo estilo Metro usando a Biblioteca do Windows para JavaScript (WinJS), você poderá usar o evento activated para manipular a ativação.

No código do manipulador do evento activated, o seu aplicativo pode verificar o objeto sessionState para determinar se deve carregar os dados salvos ou apresentar a exibição padrão da página inicial. O SessionState determina o último estado do seu aplicativo automaticamente examinando o eventArgs.detail.previousExecutionState. Se o sessionState estiver preenchido, use-o para restaurar os dados da sua sessão ou use os dados padrão do seu aplicativo.

var app = WinJS.Application;

function activatedHandler(eventArgs) {
if (eventArgs.detail.kind == Windows.ApplicationModel.Activation.ActivationKind.launch) {
// Check whether the session state variables are valid.
// If so, retrieve the stock and range values saved in the checkpoint handler
if (app.sessionState) {
stock = app.sessionState.lastSeenStock;
range = app.sessionState.lastSeenRange;
}
// If not, use the app's default values
else{
stock = "DOW";
range = "1M";
}

// Initialize the WinJS controls asynchronously behind the app splash screen
// Start retrieving the latest stock data asynchronously after the controls are ready
eventObject.setPromise(WinJS.UI.processAll().then(function() {
Api.initializeUserStocks();
}));
}
}

app.addEventListener("activated", activatedHandler);
       

Para obter mais informações sobre como manipular a ativação em JavaScript, consulte How to activate an app (JavaScript and HTML) (Como ativar um aplicativo (JavaScript e HTML) no Centro de Desenvolvimento.

Manipulando a ativação em XAML

Em um aplicativo estilo Metro usando XAML e C#, você poderá substituir o evento OnLaunched para manipular a ativação básica de um bloco.

No código do manipulador do evento OnLaunched o seu aplicativo pode verificar o PreviousExecutionState nos argumentos do evento. Se for Terminated, restaure os dados salvos no evento Suspending . Se o valor for outro, use os dados padrão do seu aplicativo.

async protected override void OnLaunched(LaunchActivatedEventArgs args)
{
// Check whether the session data should be restored
if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
// Here we've created a SuspensionManager class which handles restoring session
// data from a file and then gives access to that data through a Dictionary
await SuspensionManager.RestoreAsync();

// Retrieve the stock and range values saved in the suspend handler
stock = SuspensionManager.SessionState["lastSeenStock"];
range = SuspensionManager.SessionState["lastSeenRange"];
}
// If not, use the app's default values
else
{
stock = "DOW";
range = "1M";
}

// Start retrieving the latest stock data
Api.InitializeUserStocks();

Window.Current.Activate();
}

Para obter mais informações sobre como manipular a ativação em JavaScript, consulte How to activate an app (VB/C#/C++ and XAML) (Como ativar um aplicativo (VB/C#/C++ e XAML)) no Centro de Desenvolvimento.

Dicas para a criação de um aplicativo que proporcione uma experiência ótima e duradoura

Agora que você já recebeu todas as noções básicas, veja algumas dicas para ajudá-lo a criar uma experiência ótima e duradoura para o seu aplicativo, que parecerá estar sempre ativo e atualizado aos seus usuários.

Às vezes, é melhor iniciar do zero

Se já fizer um tempo considerável desde a última vez que o usuário viu o seu aplicativo, é melhor reiniciá-lo com sua exibição padrão. Cabe a você calcular o tempo adequado, mas se o conteúdo do seu aplicativo parecer antigo ou desatualizado, recomendamos que retorne à exibição da página inicial do aplicativo. Isso fará com que o seu aplicativo pareça mais inteligente aos seus usuários.

Por exemplo, caso se trate de um novo aplicativo de leitura de notícias, ele será suspenso quando o usuário deixar de usá-lo. Algum tempo depois, o aplicativo de leitura de notícias será retomado quando o usuário retornar a ele. No seu manipulador de retomada, verifique se o artigo atual ficou muito antigo. Se isso tiver ocorrido, apresente a exibição padrão da página inicial em seu lugar.

Salve os dados certos no momento certo

Sempre salve dados importantes de forma incremental durante a vida do aplicativo. Como o aplicativo tem apenas cinco segundos para executar o código do manipulador do evento suspending, você precisa garantir que os dados importantes do aplicativo sejam salvos no armazenamento persistente no momento em que for suspenso.

Há dois tipos de dados para você gerenciar enquanto escrever o aplicativo: dados da sessão e dados do usuário. Os dados da sessão são dados temporários que são relevantes à experiência atual do usuário no seu aplicativo. Por exemplo, a ação atual que estiver sendo exibida ao usuário, a página atual que o usuário estiver lendo em um livro eletrônico ou a posição da barra de rolagem em uma lista de itens longa. Os dados do usuário são permanentes e sempre devem estar acessíveis ao usuário. Por exemplo, um documento que o usuário esteja digitando, uma foto que tenha sido tirada no aplicativo ou o progresso do usuário em um jogo.

Garanta que, no momento em que o aplicativo for suspenso, ele salve os dois tipos de dados no armazenamento persistente.

Restaurando dados da sessão

Os usuários normalmente esperam encontrar o aplicativo estilo Metro da maneira que o deixaram na última vez que usaram. Do ponto de vista do desenvolvedor, quando o seu aplicativo é retomado de um estado suspenso ou ativado de um estado em que não se encontra em execução, é sempre adequado restaurar os últimos dados salvos da sessão.

Por exemplo, se o seu aplicativo inclui a funcionalidade de carrinho de compras, e o usuário tiver adicionado itens ao carrinho e depois deixado de usar o aplicativo, faz sentido que esses itens continuem no carrinho quando o usuário retomar ou reativar o aplicativo.

Em outro exemplo, considere um aplicativo que mostre novos artigos. Se o usuário interromper a leitura de um determinado artigo para usar outro aplicativo, ele espera ver o artigo que estava lendo quando voltar ao aplicativo.

Libere recursos exclusivos no manipulador do evento suspenso

Se o seu aplicativo tiver adquirido recursos exclusivos durante a execução (como identificadores de arquivo ou referências a dispositivos externos), ele deverá liberar esses recursos ao receber o evento suspending. Além disso, o aplicativo deverá recuperar esses recursos exclusivos ao receber o evento resuming se precisar que eles continuem.

Não feche o seu aplicativo!

Os aplicativos estilo Metro no Windows 8 nunca devem ser fechados nem apresentar interface do usuário que permita que um usuário feche o aplicativo. A suspensão e término de aplicativos é gerenciada pelo Windows em benefício do usuário para manter o desempenho do sistema e preservar a vida útil da bateria. Se os usuários desejarem fechar o seu aplicativo, eles poderão fazer isso passando o dedo na tela de cima para baixo ou pressionando ALT+F4.

Resumo

Usando os 3 eventos, suspending, resuming e activated, o seu aplicativo sempre parecerá ativo aos seus usuários. No entanto, ele nunca usa a bateria desnecessariamente nem diminui o desempenho do sistema quando não está sendo usado pelo usuário. No mundo de dispositivos mais móveis e finos, o novo ciclo de vida dos aplicativos estilo Metro permite que o seu aplicativo brilhe em qualquer dispositivo.

--Adam Barrus, gerente de programas, Windows

Esta postagem teve a participação de um grupo de pessoas. Agradeço às contribuições de Jake Sabulsky, Ben Srour, Ben Betz, Marco Matos, Ryan Haveson, Ian LeGrow e John Montgomery.

  • Loading...
Leave a Comment
  • Please add 8 and 8 and type the answer here:
  • Post