Window Store Application Life Cycle

In this article I will explain of all four Window Store Application Life Cycle steps.

A Metro style app is in one of four Lifecycle states at any given time:

Not running, Running , Suspended or Terminated

Metro Style app Lifecycle1.png

As your app transitions among its states, it receives lifecycle events that help you provide a consistent and high performance experience for your users.

Application Launch:
An app is launched whenever it is activated by the user but the process is in the NotRunning state and Windows displays a splash screen for the app.

The primary tasks for the app are to register event handlers and set up any custom UI it needs for loading. After completion of activation, an app enters the Running state and the splash screen is torn down.

Application activation: An app can be activated by the user through a variety of contracts and extensions.

To participate in activation, your app must register to receive the Activated | activated event. Your app's activation event handler can test to see why it was activated and whether it was already in the Running state.

An app can be activated as follows:

Activation type-Description

  • Cached file: The user wants to save a file that the app provides content management for.

  • Camera: The user wants to capture photos or video from an attached camera.

  • Contact picker: The user wants to pick contacts.

  • Device: The app handles AutoPlay.

  • File: An app launched a file whose file type this app is registered to handle.

  • File open picker: The user wants to picks files or folders that are provided by the app.

  • File save picker: The user wants to save a file and selected the app.

  • Launch: The user launched the app or tapped a content tile.

  • Print task: The app handles print tasks.

  • Protocol: An app launched a URL whose protocol this app is registered to handle.

  • Search: The user wants to search with the app.

  • Share target: The app is a target for a share operation.

Handling Activation in JavaScript: In the activated event handler code, your app can check the session State object to determine if it should load saved data or if it should display the default home view. Session State determines the last state of your app automatically by examining eventArgs.detail.previousExecutionState. If the session State is populated, use it to restore your session data, otherwise use your app's default data.

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 currency and range values saved in the checkpoint handler
       
if (app.sessionState)
        {
            currency = app.sessionState.lastSeencurrency;
            range = app.sessionState.lastSeenRange;
        }
           
// If not, use the app's default values
       
else
        {
            currency =
"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.initializeUsercurrency();
        }));
    }
}

app.addEventListener(
"activated", activatedHandler);

Application Suspend: An app is suspended when the user switches to another app or windows enters a low-power mode. However, there are some apps that need to continue to run to complete background tasks.

When the user moves an app to the background, Windows waits a few seconds to see whether the user immediately switches back to the app. If the user does not switch back, Windows suspends the app. Your app must be registered for the suspending or checkpoint (JavaScript) events, which it receives when Windows wants to suspend it so that the app data can be kept in persistent storage.

If your app doesn't return from its suspending event handler within 5 seconds of receiving the suspending event, Windows will terminate it. It's important not to do any heavy operations in your suspending event handler. Save your app data and return quickly.

Example of handling suspend in JavaScript: You can use the checkpoint event to handle suspending.
 

var
app = WinJS.Application;
function
checkpointHandler()
{
   
// The checkpoint event gives us the chance to save application data.
   
// In this case, we save the current currency info that the user is viewing.
    app.sessionState.lastSeencurrency = selectedcurrency;
    app.sessionState.lastSeenRange = selectedRange;
   
// Send client side notifications
    Tile.sendTileUpdate(selectedcurrency, currencyInfo.change, currencyInfo.lastSale, currencyInfo.lastSaleTime, currencyInfo.open);
}

app.addEventListener(
"checkpoint", checkpointHandler);

Application Visiblity: When the user switches from your app to another app, your app is no longer visible but remains in the running state until Windows can suspend it (for about 10 seconds).

If the user switches away from your app but activates or switches back to it before Windows can suspend it, the app remains in the running state. You can use the VisibilityChanged | msvisibilitychange event if your app needs to do something when the user switches away and back.

Application Resume: A suspended app is resumed when the user switches to it or when Windows comes out of a low-power state.

When an app is resumed from the Suspended state, it enters the Running state and continues from where it was when it was suspended. No app data is lost, as it was stored in memory. Therefore, most apps don't need to do anything when they are resumed. However, the app could have been suspended for hours. If an app registered an event handler for the Resuming | resuming event, it is called when the app is resumed from the Suspended state.

Example of Handling Resume in JavaScript: In JavaScript, you can use the Windows Runtime resuming event in the Windows.UI.WebUI.WebUIApplication namespace. This is a specialized resuming event meant only for JavaScript apps.

 
function resumingHandler()
{
   
//Update the selected currency with the latest news, currency info, and chart data
    News.requestNews(currency);
    Api.getcurrencyInfoData(currency).then(
function (data)
    {
        displaycurrencyInfo(data);
    });
    Api.getHistoryData(range).then(
function (chartData)
    {
        CanvasChart.drawChart(
"chartCanvas", chartData, Chart.getChartOptions(false));
    });
   
// Send client side notifications
    Tile.sendTileUpdate(currency, currencyInfo.change, currencyInfo.lastSale, currencyInfo.lastSaleTime, currencyInfo.open);
}

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

Application Crash: Apps are required to follow the system crash experience i.e to simply return to the Start screen.

So that users can return to what they were doing as quickly as possible, you shouldn't provide a warning dialog or other notification because that'll cause a delay for the user. The disappearance of the app should make it clear to the user that something went wrong. Windows reports the error to Microsoft and Microsoft provides a subset of this error data to you so that you can use it to improve your app.

Application Close: Usually, the user doesn't need to close apps; they can let Windows manage them.

There's no special event to indicate that the user has closed an app. After an app has been closed by the user, it's suspended and terminated, entering the NotRunning state within about 10 seconds. The Suspending | suspending event is called when the app is suspended and you can use this event handler to save relevant application and user data to persistent storage.

Application Removal: When the user deletes your app, the app is removed along with all its local data and it does not affect user data.

Application lifecycle programming interfaces: