C#

In C#, the OnLaunched method looks like this (App.xaml.cs):

        protected override async void OnLaunched(LaunchActivatedEventArgs e)
        {
 
#if DEBUG
            // Show graphics profiling information while debugging.
            if (System.Diagnostics.Debugger.IsAttached)
            {
                // Display the current frame rate counters
                this.DebugSettings.EnableFrameRateCounter = true;
            }
#endif
 
            Frame rootFrame = Window.Current.Content as Frame;
 
            // Do not repeat app initialization when the Window already has content,
            // just ensure that the window is active
 
            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();
                //Associate the frame with a SuspensionManager key
                SuspensionManager.RegisterFrame(rootFrame, "AppFrame");
                // Set the default language
                rootFrame.Language = Windows.Globalization.ApplicationLanguages.Languages[0];
 
                if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
                {
                    // Restore the saved session state only when appropriate
                    try
                    {
                        await SuspensionManager.RestoreAsync();
                    }
                    catch (SuspensionManagerException)
                    {
                        //Something went wrong restoring state.
                        //Assume there is no state and continue
                    }
                }
 
                // Place the frame in the current Window
                Window.Current.Content = rootFrame;
            }
            if (rootFrame.Content == null)
            {
                // When the navigation stack isn't restored navigate to the first page,
                // configuring the new page by passing required information as a navigation
                // parameter
                if (!rootFrame.Navigate(typeof(GroupedItemsPage)))
                {
                    throw new Exception("Failed to create initial page");
                }
            }
            // Ensure the current window is active
            Window.Current.Activate();
        }

The default implementation evaluates the PreviousExecutionState property of LaunchActivatedEventArgs to see whether its value is equal to the Terminate value of the ApplicationExecutionState enumeration that you can see in the class diagram shown in Figure 5-4. Remember this diagram because you will refer to it when you evaluate other values of ApplicationExecutionState for other transitions. By checking the PreviousExecutionState, you can restore a saved state. The #if DEBUG statement enables the framerate counter on the top of the screen (starting in Windows 8.1).

The remaining code allows the application to start using a root content of your application as an instance of the MainPage application page.

To manage the application activation completely, you must handle the OnActivated event this way:

protected override void OnActivated(IActivatedEventArgs args)
{
    switch (args.Kind)
    {
        case ActivationKind.CachedFileUpdater:
            //Do something here
            break;
        case ActivationKind.CameraSettings:
            //Do something here
            break;
        case ActivationKind.ContactPicker:
            //Do something here
            break;
        case ActivationKind.Device:
            //Do something here
            break;
        case ActivationKind.File:
            //Do something here
            break;
        case ActivationKind.FileOpenPicker:
            //Do something here
            break;
        case ActivationKind.FileSavePicker:
            //Do something here
            break;
        case ActivationKind.PrintTaskSettings:
            //Do something here
            break;
        case ActivationKind.Protocol:
            //Do something here
            break;
        case ActivationKind.Search:
            //Do something here
            break;
        case ActivationKind.ShareTarget:
            //Do something here
            break;
    }
}

In this code, you are preparing your application to manage various types of activation, evaluating the Kind property of the IActivatedEventArgs interface (see Figure 5-5). You may be wondering why you use an interface. You do so because you’ll have a different implementation of IActivatedEventArgs depending on ActivationKind. (It will be clarified when we talk about contracts and extensions).

VB

As soon as you create your project, a file named App.xaml.vb is created. In this file is a standard implementation of the OnLaunched method that looks like this:

    Protected Overrides Sub OnLaunched(e As Windows.ApplicationModel.Activation.LaunchActivatedEventArgs)
#If DEBUG Then
        ' Show graphics profiling information while debugging.
        If System.Diagnostics.Debugger.IsAttached Then
            ' Display the current frame rate counters
            Me.DebugSettings.EnableFrameRateCounter = True
        End If
#End If
 
        Dim rootFrame As Frame = TryCast(Window.Current.Content, Frame)
 
        ' Do not repeat app initialization when the Window already has content,
        ' just ensure that the window is active
 
        If rootFrame Is Nothing Then
            ' Create a Frame to act as the navigation context and navigate to the first page
            rootFrame = New Frame()
            If e.PreviousExecutionState = ApplicationExecutionState.Terminated Then
                ' TODO: Load state from previously suspended application
            End If
            ' Place the frame in the current Window
            Window.Current.Content = rootFrame
        End If
        If rootFrame.Content Is Nothing Then
            ' When the navigation stack isn't restored navigate to the first page,
            ' configuring the new page by passing required information as a navigation
            ' parameter
            If Not rootFrame.Navigate(GetType(MainPage), e.Arguments) Then
                Throw New Exception("Failed to create initial page")
            End If
        End If
 
        ' Ensure the current window is active
        Window.Current.Activate()
    End Sub

If you compare this code with C# code, you’ll notice that there’s no difference between the implementations except for a slight difference in syntax. And this consideration is valid also for the OnActivated override, which looks like this:

Protected Overrides Sub OnActivated(args As IActivatedEventArgs)
    Select Case args.Kind
        Case ActivationKind.CachedFileUpdater
            'Do something here
        Case ActivationKind.CameraSettings
            'Do something here
        Case ActivationKind.ContactPicker
            'Do something here
        Case ActivationKind.Device
            'Do something here
        Case ActivationKind.File
            'Do something here
        Case ActivationKind.FileOpenPicker
            'Do something here
        Case ActivationKind.FileSavePicker
            'Do something here
        Case ActivationKind.PrintTaskSettings
            'Do something here
        Case ActivationKind.Protocol
            'Do something here
        Case ActivationKind.Search
            'Do something here
        Case ActivationKind.ShareTarget
            'Do something here
    End Select
End Sub

That’s all you have to do to manage the activation of your application. Now you learn how to manage the VisibilityChanged event.

C#

As mentioned, you declare a private member of the DispatcherTimer type in the App class (App.xaml.cs) and you initialize it inside the constructor, using 1 second as the TimeSpan to set the value of the Interval property of DispatcherTimer.

private DispatcherTimer _timer;
 
...
 
public App()
{
   this.InitializeComponent();
   this.Suspending += OnSuspending;
   timer = new DispatcherTimer
   {
      Interval = TimeSpan.FromSeconds(1)
   };
}

Another thing that you need is a private member of the CoreWindow type, which you’ll initialize in the OnLaunched method, getting an instance from the static method GetForCurrentThread of the CoreWindow class:

private CoreWindow coreWindow;
 
... 
 
coreWindow = CoreWindow.GetForCurrentThread();
 
coreWindow.VisibilityChanged +=
   (s, e) =>
   {
      if (e.Visible)
         timer.Start();
      else
         timer.Stop();
   };

In this way, when the app loses visibility, the timer stops running and starts again when the app becomes visible. Of course, this is only an example of how to manage the VisibilityChanged event, and the code inside the event handler will change based on your own application.

VB

As in C#, the first thing that you need is an instance of DispatcherTimer created in this way:

Dim _timer = New DispatcherTimer() With {.Interval = TimeSpan.FromSeconds(1)}

Then you need to add an event handler for the VisibilityChanged event, which is like this in VB:

Private Sub VisibilityChanged(sender As Windows.UI.Core.CoreWindow, args As Windows.UI.Core.VisibilityChangedEventArgs)
        If args.Visible Then
            _timer.Start()
        Else
            _timer.Stop()
        End If
End Sub

Now that you have an event handler, you will get an instance of CoreWindow. Because VB is a managed language like C#, you create an instance of CoreWindow inside the App class and then you can get the CoreWindow instance inside the OnLaunched event in two ways:

Dim _coreWindow As Windows.UI.Core.CoreWindow
...
_coreWindow = coreWindow.GetForCurrentThread()
Or
_coreWindow = Window.Current.coreWindow;

There is no difference between these two methods because you will always get the same instance. The last thing to do is to subscribe the event handler to the event, and you will do it inside the OnLaunched method in this way:

AddHandler coreWindow.VisibilityChanged, AddressOf VisibilityChanged

That’s it.

C#

Managing the Suspending event in C# is really simple. The first thing that you need is an event handler in App.xaml.cs:

private async void OnSuspending(object sender, SuspendingEventArgs e)
{
    var deferral = e.SuspendingOperation.GetDeferral();
    await SuspensionManager.SaveAsync();
    deferral.Complete();
}

In the first line of code, you get an object of the SuspendingDeferral class in order to notify the OS that your operations ended in the last line of code. Now that you have an event handler, you can attach your handler to the event:

this.Suspending += OnSuspending;

app is an instance of your application that you can refer to by using the this keyword if you are working in App.xaml.cs or using the Current static property of the Application object:

Application.Current.Suspending += OnSuspending;

VB

The code to manage the Suspending event in VB is also really simple:

AddHandler Application.Current.Suspending, AddressOf OnSuspending
Private Async Sub OnSuspending(sender As Object, e As SuspendingEventArgs) Handles Me.Suspending
     Dim deferral As SuspendingDeferral = e.SuspendingOperation.GetDeferral()
     Await Common.SuspensionManager.SaveAsync()
     deferral.Complete()
End Sub

C#

Managing the Resuming event is really easy. The event handler can be implemented as follows in App.xaml.cs:

void OnResuming(object sender, object e)
{
    //Place your code here
}

Attach the event handler to the Resuming event in the App() constructor:

this.Resuming += OnResuming;

VB.NET

In the App.xaml.vb file, use this code:

AddHandler Application.Current.Resuming, AddressOf App_Resuming
 
Private Sub App_Resuming(sender As Object, e As Object)
        ' TODO: Refresh network data
End Sub