Your app describes its tile’s content to Windows declaratively. That is, your app creates an XML document describing the desired contents of the tile and then your app passes this XML document to Windows. Windows predefines several XML tile templates; each offers a different way to lay out text and images on the tile.^[64] Windows then parses the document, builds the tile’s image, and displays that image on the user’s Start screen. So, in your code, you first start by creating an XML document that matches one of the predefined templates. The XML schema for tiles is documented at http://msdn.microsoft.com/en-us/library/windows/apps/br212859.aspx. The catalog of tile templates, along with examples of what each template produces, is documented at http://msdn.microsoft.com/en-us/library/windows/apps/hh761491.aspx.

Let’s look at some code that updates your app’s tile. Here we’ll update a square 150-pixel by 150-pixel tile. You start by creating an XML document matching one of the predefined templates. To simplify this, WinRT provides an API that returns a predefined template. Here is an example of how to get an empty, predefined XML template:

XmlDocument tileXml =
   TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquare150x150Text01);

Once you have this template, you modify the tile’s text by retrieving the text element from the XmlDocument and appending a text node to it:

tileXml.GetElementsByTagName("text")[0].AppendChild(tileXml.CreateTextNode("New text"));

The XML document now looks like this:

<tile>
   <visual version="2">
      <binding template="TileSquare150x150Text01" fallback="TileSquareText01">
         <text id="1">New text</text>
         <text id="2"></text>
         <text id="3"></text>
         <text id="4"></text>
      </binding>
   </visual>
</tile>

Now you create a TileNotification object, passing it the XmlDocument. A TileNotification object offers some additional properties to help manage the lifetime of the tile notification; these will be described later. Then, to update your app’s tile, you use the TileUpdateManager to create a TileUpdater object and then use this object to update your tile:

TileNotification tileNotification = new TileNotification(tileXml);
TileUpdater updater = TileUpdateManager.CreateTileUpdaterForApplication();
updater.Update(tileNotification);

If your app supports multiple tile sizes, you must prepare an XML template for each size, package all the templates together into a single XML document, create one TileNotification object from the XML document, and then update the tile. Remember, the user can change a tile’s size whenever he wants. This is why you must include XML templates for all tile sizes; the system remembers the last TileNotification object you sent to it and will update the tile’s content automatically if the user later changes its size.

This code demonstrates how to create an XML template for a square 150-by-150 tile and another XML template for a wide 310-by-150 tile, merge them together, and update the tile’s content:

// Create square 150x150 tile template
XmlDocument tileXml =
   TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquare150x150Text01);
tileXml.GetElementsByTagName("text")[0].AppendChild(tileXml.CreateTextNode("New text"));
// Create wide 310x150 tile template
XmlDocument wide310x150Xml =
   TileUpdateManager.GetTemplateContent(TileTemplateType.TileWide310x150ImageAndText01);
wide310x150Xml.GetElementsByTagName("text")[0]
   .AppendChild(wide310x150Xml.CreateTextNode("New text"));
wide310x150Xml.GetElementsByTagName("image")[0].Attributes.GetNamedItem("src")
   .NodeValue = "ms-appx:///Assets/snowday.jpg";
// Merge the two tile templates into a single XML document:
IXmlNode node =
   tileXml.ImportNode(wide310x150Xml.GetElementsByTagName("binding").Item(0), true);
tileXml.GetElementsByTagName("visual").Item(0).AppendChild(node);

The resulting XML document looks like this:

<tile>
   <visual version="2">
      <binding template="TileSquare150x150Text01" fallback="TileSquareText01">
         <text id="1">New text</text>
         <text id="2"></text>
         <text id="3"></text>
         <text id="4"></text>
      </binding>
      <binding template="TileWide310x150ImageAndText01" fallback="TileWideImageAndText01">
         <image id="1" src="ms-appx:///Assets/snowday.jpg"/>
         <text id="1">New text</text>
      </binding>
   </visual>
</tile>

Note how we set the image on the wide tile. When setting an image element’s src attribute, the URL can start with any of the values from Table 8-3.

Placing a badge on a tile is similar to how you update a tile’s contents. Instead of using TileUpdateManager, you use BadgeUpdateManager to retrieve one of the two BadgeTemplateTypes: BadgeNumber or BadgeGlyph. Then you modify the XmlDocument, use the document to create a BadgeNotification, and hand the notification to the badge updater:

XmlDocument xmlBadge = BadgeUpdateManager.GetTemplateContent(BadgeTemplateType.BadgeNumber);
// Passing BadgeTemplateType.BadgeGlpyh to GetTemplateContent returns identical XML as above
XmlNodeList badgeAttributes = xmlBadge.GetElementsByTagName("badge");
badgeAttributes[0].Attributes.GetNamedItem("value").NodeValue = "7";  // Set value to a number
BadgeNotification badgeNotification = new BadgeNotification(xmlBadge);
BadgeUpdater bu = BadgeUpdateManager.CreateBadgeUpdaterForApplication();
bu.Update(new BadgeNotification(xmlBadge));

To see the XML schema for badges, go to http://msdn.microsoft.com/en-us/library/windows/apps/br212851.aspx. To see the catalog of badge templates, visit http://msdn.microsoft.com/en-us/library/windows/apps/hh779719.aspx. This catalog is also shown in Figure 8-4. You use the status string in the first column to have the badge show a glyph. To have the previous code show a glyph instead of a number, change the fourth line of code to this:

badgeAttributes[0].Attributes.GetNamedItem("value").NodeValue = "attention";

Figure 8-4. The badge glyphs you can put on a tile.

To reset a tile back to its static logo or remove a badge from a tile, just call TileUpdateManager’s or BadgeUpdateManager’s Clear method:

// Reset the tile back to its static logo & remove its badge:
TileUpdateManager.CreateTileUpdaterForApplication().Clear();
BadgeUpdateManager.CreateBadgeUpdaterForApplication().Clear();

Live tiles typically show content that is fresh, and there are occasions when it is better to show nothing at all instead of showing old content. For example, you should not show weather temperatures or stock prices that are seven days old or older. To enable you to automatically remove old content, TileNotification objects offer an ExpirationTime property. The system automatically deletes a tile notification when its time expires and reverts the tile back to its static logo:

TileNotification tileNotification = new TileNotification(tileXml) {
   ExpirationTime = DateTimeOffset.Now.AddDays(7)
};
updater.Update(tileNotification);

There is a quick and easy way to animate a tile using predefined peek templates. Each peek template describes two views of a tile, and the Start screen automatically cycles from one view to the other every few seconds. The following XML template is the TileSquarePeekImageAndText01 template:

<tile>
  <visual version="2">
    <binding template="TileSquare150x150PeekImageAndText01"
             fallback="TileSquarePeekImageAndText01">
      <image id="1" src=""/>
      <text id="1"></text>
      <text id="2"></text>
      <text id="3"></text>
      <text id="4"></text>
    </binding>
  </visual>
</tile>

As documented, when the system receives XML containing this template, it shows one square image without text on the top, one header string in larger text on the first line, and three strings of regular text on each of the next three lines on the bottom. Figure 8-5 shows an example of this tile’s appearance.

Figure 8-5. The contents of a peek square tile (for which the system cycles between the top and bottom automatically).

The system shows the top half of the contents in the tile, waits a few seconds, shows the bottom half, waits a few seconds, and shows the top half again. This cycling happens continuously and automatically while the user is looking the Start screen.

In addition to using peek templates, your app can queue up to five tile notifications to a single tile and the Start screen will automatically cycle through them. You enable queuing by calling TileUpdateManager’s EnableNotificationQueue method and passing in true. The following code creates five tile notifications and queues them to the app’s tile:

TileUpdater tu = TileUpdateManager.CreateTileUpdaterForApplication();
tu.EnableNotificationQueue(true);  // Enable queuing up to 5 notifications
// Queue 5 tile notifications to our app's tile:
for (Int32 tileNum = 0; tileNum < 5; tileNum++) {
   XmlDocument tileXml =
      TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquare150x150Text01);
   tileXml.GetElementsByTagName("text")[0].AppendChild(tileXml.CreateTextNode("#" + tileNum));
   tu.Update(new TileNotification(tileXml));
}

Offering multiple tile notifications allows apps to cycle through multiple news feeds, email messages, stock prices, or weather temperatures, giving the user a lot of information at a glance. For developers, it becomes a challenge not to provide too much information.

Once you associate a set of tile notifications with a tile, your app can be suspended or terminated; the Start screen will still cycle through the notifications, giving the user the illusion that your app is still running. Consider how power and CPU efficient it is to have only the Start screen do this work for all apps instead of having every app update its own tile by executing code in the background.

If you add more than five tiles to the queue, the system replaces the oldest using a first-in, first-out (FIFO) algorithm. However, your app can replace a specific tile notification by specifying a tag string:

TileNotification tileNotification = new TileNotification(tileXml) { Tag = "MSFT" };

Now when we want to replace this tile notification, we just specify the same tag string:

TileNotification tileNotification1 = new TileNotification(tileXml) { Tag = "MSFT" };
tu.Update(tileNotification1);

Tag strings have a 16-character limit, and your app can use tags only to replace or remove tile notifications. Unfortunately, if the user launches your app via its tile, your app will not receive the tag of the currently visible tile notification. So your app can’t display different content based on a specific tile notification. If you want your app to navigate to different content, your app can use secondary tiles (discussed in the Secondary tiles section).

So far, the methods shown require your app to be running in the foreground to update its tile’s content. In addition, your app can implement a background task. (See Chapter 9.) Background tasks can run periodically or when a trigger (for example, a user logon) occurs. Although the system does not allow background tasks to manipulate an app’s user interface in any way, a background task’s code can update the app’s tile or badge, or show a toast notification.

In addition, there are several techniques allowing your app to update its tile’s content while no code is running. The next section, Updating a tile at a scheduled time shows how to schedule a tile notification to activate itself in the future. The Updating a tile periodically section shows how to have the system periodically poll a web server for a new XML template. And, much later in this chapter, the Windows Push Notification Service (WNS) section shows how you can manage your own web server in the cloud that can push XML templates down to your app’s tile for a particular user on a particular machine.

In your app, you can use ScheduledTileNotification to have the system update your app’s tile sometime in the future:

XmlDocument tileXml =
   TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquare150x150Text01);
tileXml.GetElementsByTagName("text")[0].AppendChild(tileXml.CreateTextNode("Eat lunch"));
ScheduledTileNotification stn =
   new ScheduledTileNotification(tileXml, DateTimeOffset.Now.AddHours(2)) {
      ExpirationTime = DateTimeOffset.Now.AddMinutes(30)
   };
TileUpdateManager.CreateTileUpdaterForApplication().AddToSchedule(stn);

Here we schedule a tile notification that activates itself in two hours. Additionally, the tile notification expires 30 minutes from the time it is scheduled. You can schedule up to 4,096 tiles in advance. This is useful if you want to implement a countdown timer.

Your app can tell the system to get tile notifications from a web server periodically. Here is an example that has the Start screen poll a web server of your app’s choosing every 30 minutes for a new tile template:

TileUpdater tu = TileUpdateManager.CreateTileUpdaterForApplication();
tu.StartPeriodicUpdate(
   new Uri("http://WintellectNOW.blob.core.windows.net/public/TileTemplates.xml"),
   DateTimeOffset.UtcNow.AddSeconds(10), PeriodicUpdateRecurrence.HalfHour);

Your app can, of course, use the URL to pass additional information to the web server in a query string. For example, your app can send a ZIP code to indicate location information that the web server can use to return an XML template targeted for your app’s specific needs (“http://SomeWeatherService.com?Zip=98033”).

Call TileUpdateManager’s StopPeriodicUpdate method to have the Start screen stop polling your web server.

In your app’s package manifest, you can enable periodic updates for your app’s tile. This allows your app’s tile to start showing useful information right after the user installs your app. See the Tile Update section on the Application tab in Visual Studio’s package manifest designer.

In addition to an app’s main tile, an app can have one or more secondary tiles on the Start screen. Secondary tiles have the same capabilities as the app’s main tile, including badges, peek templates, queuing up to five tile notifications, scheduled updates, periodic updates, and also Windows Push Notifications. When a user launches your app from a secondary tile, the system passes in a launch parameter to your app so that your app can display different content depending on which tile the user tapped. Examples of secondary tiles are stock-ticker apps with several tiles for different stocks or a weather app with a tile for each geographic location. Having a secondary tile launch your app to a specific stock or location within your app is sometimes referred to as deep linking.

Because users are always in control of their Start screen, your app can’t just add a secondary tile to it. Instead, your app calls a WinRT API that prompts the user to pin a secondary tile to the Start screen. The user can approve or deny this operation. Most apps expose functionality to add secondary tiles through a Pin To Start button in the app bar, but this is not a requirement. Here is an example of how you create a secondary tile for your app:

String baseUri = "ms-appx:///Assets/";
String tileId = "SecondaryTile";
SecondaryTile tile = new SecondaryTile(tileId) {    // ID passed to OnLaunched
   Arguments = "Some argument",                     // Args passed to OnLaunched (can't be "")
   DisplayName = "2nd tile-Display Name",
   RoamingEnabled = true                            // Default is true
};
// Properties common to all tile sizes:
tile.VisualElements.BackgroundColor = Colors.Green;
tile.VisualElements.ForegroundText = ForegroundText.Light;  // Dark=#2A2A2A, Light=#FFFFFF
tile.VisualElements.Square30x30Logo = new Uri(c_baseUri + "SmallLogo.png"); // Optional
// Select tile sizes to offer the user:
tile.VisualElements.Square150x150Logo = new Uri(c_baseUri + "Logo.png"); // Mandatory
tile.VisualElements.ShowNameOnSquare150x150Logo = false;
// The following logos are optional:
tile.VisualElements.Square70x70Logo = new Uri(c_baseUri + "Square70x70Logo.png");
tile.VisualElements.Wide310x150Logo = new Uri(c_baseUri + "WideLogo.png");
tile.VisualElements.ShowNameOnWide310x150Logo = true;
tile.VisualElements.Square310x310Logo = new Uri(c_baseUri + "Square310x310Logo.png");
tile.VisualElements.ShowNameOnSquare310x310Logo = true;
// Ask user to create the secondary tile:
Boolean userCreated = await tile.RequestCreateAsync();

Because you can’t define any settings for secondary tiles in the manifest, you have to specify all the properties in code. Secondary tiles have two string properties, called TileId and Arguments. When a user launches your app from its secondary tile, the system passes these strings to your app’s OnLaunched method as members of the LaunchActivatedEventArgs parameter. The TileId identifies the secondary tile, and the Arguments property is a string with a maximum length of 2,048 characters that your app can use to distinguish further between a launch from a primary tile and a secondary tile.^[65]

A cool feature of secondary tiles is that they are allowed to roam across all of a user’s machines. When creating a secondary tile, its RoamingEnabled property defaults to true. Now, if the user installs the app on another PC, the secondary tile will appear on the other PC’s Start screen automatically. Of course, this requires that the user log in to both PCs using her Microsoft account. Secondary tiles only roam on first installation. After this, the user can modify the secondary tiles independently on her PCs; this allows the user to have some secondary tiles on one PC but not on a different PC.

The call to RequestCreateAsync shows the user a dialog box like the one shown in Figure 8-6. From this dialog box, the user scrolls through the offered tile sizes and can edit the name displayed on the tile. Your app can also prompt the user to remove a secondary tile from the start screen by calling RequestDeleteAsync.

Figure 8-6. Secondary tile approval dialog box.

A user can unpin a tile from the Start screen at any time even if its app is not running. Later, when the app does run, it can determine if a particular secondary tile is still pinned by calling this method:

Boolean tileOnStartScreen = SecondaryTile.Exists(tileId);

And an app can discover all the secondary tiles it still has pinned on the Start screen by calling

IReadOnlyList<SecondaryTile> pinnedSecondaryTiles = await SecondaryTile.FindAllAsync();

When your app is in the foreground, the usefulness of showing toast notifications is somewhat limited. The purpose of toasts notifications is to notify the user of something important happening in an app that is not in the foreground. For this, your app can show a toast from a background task that runs when certain events happen, such as logon or a network status change. (See Chapter 9.) Additionally, your app can schedule a toast to pop up at a very specific time—for example, an appointment reminder. Here’s how to schedule a toast to display one hour from when the code executes:

ScheduledToastNotification scheduledToastNotification = new ScheduledToastNotification(toastXml,
   DateTimeOffset.UtcNow.AddHours(1),  // Delivery time
   TimeSpan.FromMinutes(1),               // Snooze interval (minimum=1 minute)
   2) { Id = "Meeting" };                 // Max display count & ID
tn.AddToSchedule(scheduledToastNotification);

We also set a snooze interval that tells the system to show the toast again if the user ignores or dismisses the toast notification. With the recurrence setting of 2, the toast will actually appear three times. You can use the ToastNotifier to iterate through the scheduled toasts and remove them from the schedule if they are no longer applicable.

Because it is unlikely that your app will be running when the scheduled toast comes up, the system does not support the Activated, Dismissed, and Failed events for scheduled toasts. When the user taps a scheduled toast, the system calls OnLaunched regardless of whether your app was running, suspended, or terminated.

Working with the raw XML to create your tile, badge, and toast notifications can become tedious. The code that accompanies this book has a library to help you focus on the notifications instead of the XML.^[70] The library gives you type-safety and IntelliSense support. Using the library, the code to produce the XML toast template shown in the previous section looks like this:

var toastXml = new Wintellect.WinRT.Notifications.ToastTemplate(
   ToastTemplateType.ToastImageAndText01) {
   Images = { "ms-appx:///Assets/snowday.jpg" },
   Text = { "This is a toast notification." },
   Launch = "Launch argument goes here",
   Audio = new ToastAudio { Loop = true, Source = SoundEvent.LoopingCall },
   Duration = ToastDuration.Long,
};

Additionally, the library also checks whether images exist at the specified URLs and that they are in a supported format and size. If a violation is discovered, the library throws an exception right away, greatly improving your debugging experience.

Table 8-1 listed four ways to update tiles, badges, and toast notifications. In this section, we focus on the last technique, Windows Push Notification Service (WNS).

Periodic updates with URLs go a long way in updating your app’s tiles and badges, especially because you can personalize the notifications by using query strings. I already mentioned providing a ZIP code for weather apps. You also can provide a list of stock symbols to adjust the tile to the user’s preferences, and so on. Periodic updates suffer from their resolution; they can update no quicker than once every 30 minutes. For some scenarios, you want to notify the user immediately that something has occurred. Examples include flight updates, incoming messages, social updates, and investment changes. WNS sends real-time tile, badge, or toast notifications to a specific user on a specific PC. Whereas periodic updates use a polling mechanism, WNS allows you to push a notification to a user/machine when you need to. Because WNS doesn’t waste network bandwidth or CPU cycles for potentially unfruitful requests, it is more efficient than polling. This is great news for both your user’s battery as well as his network bandwidth.

In addition to tiles, badges, and toast notifications, WNS can also send a raw string to a background task (or to your app if it happens to be running). Your app subscribes to these raw notifications, and because a raw string is an app-defined string payload, your server can send whatever it wants. You’ll learn about this more in Chapter 9.

You can see the flow of events for WNS in Figure 8-10. The architecture consists of three pieces: Windows and your app, WNS, and your app’s web service. At a high level, here are the workflow steps you need to perform to push notifications from your app’s web service to your app on a user’s PC:

Figure 8-10. Windows Push Notification Service workflow.

PushNotificationChannel channel =
   await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
// channel has 2 properties: Uri and ExpirationTime

https://db3.notify.windows.com/?token=AQI8iP%2OtQE%3d...

channel.PushNotificationReceived += PushNotificationReceived;

void PushNotificationReceived(PushNotificationChannel sender,
   PushNotificationReceivedEventArgs e) {
   XmlDocument xml = null;
   switch (e.NotificationType) {
      case PushNotificationType.Tile:  xml      = e.TileNotification.Content;  break;
      case PushNotificationType.Badge: xml      = e.BadgeNotification.Content; break;
      case PushNotificationType.Toast: xml      = e.ToastNotification.Content; break;
      case PushNotificationType.Raw:   String s = e.RawNotification.Content;   break;
   }
   // e.Cancel = true;  // If true (default=false), notification ignored
}

Package Security Identifier (SID)
ms-app://s-1-15-2-84216977-2665019123-2024476369-118581892-194604365-2052745452-3234447176
Client secret
6Tbbo0Hv1mQVIXbm7r/X+Q4PVH9IbxYl

Pushing a notification from your app’s web service to the user’s PC

To push a notification, your app’s web service will first have to authenticate with WNS, which will return an OAuth token. The following code demonstrates how to do this:

[DataContract]
private sealed class OAuthToken {
   [DataMember(Name = "access_token")]
   public string AccessToken { get; set; }
   [DataMember(Name = "token_type")]
   public string TokenType { get; set; }
}
private async Task<OAuthToken> GetAuthenticationTokenAsync(
   String packageSid, String clientSecret) {
   var content = new Windows.Web.Http.HttpFormUrlEncodedContent(
      new Dictionary<String, String> {
         { "grant_type", "client_credentials"},
         { "client_id", packageSid },
         { "client_secret", clientSecret},
         { "scope", "notify.windows.com"}
      });
   using (var response =
      await new HttpClient()
         .PostAsync(new Uri("https://login.live.com/accesstoken.srf"), content)
         .AsTask().ConfigureAwait(false)) {
      return (OAuthToken)new DataContractJsonSerializer(typeof(OAuthToken))
         .ReadObject((await response.Content.ReadAsInputStreamAsync()
            .AsTask().ConfigureAwait(false)).AsStreamForRead());
   }
}

WNS returns an OAuth token in JSON format, which the previous code deserializes into an OAuthToken object. The OAuth token (in JSON) looks like this (truncated):

{"token_type":"bearer","access_token":"EgAbAQMAAAAEgAAACoAAJp33aucvS9...==","expires_in":86400}

You can then use the OAuthToken to build the HTTPS POST message:

public async Task<HttpResponseMessage> PushAsync(
   Byte[] payload, String channelUri, OAuthToken token) {
   var msg = new HttpRequestMessage(HttpMethod.Post, new Uri(channelUri));
   // Set mandatory information:
   msg.Headers.Authorization = new HttpCredentialsHeaderValue("Bearer", token.AccessToken);
   msg.Content = new HttpBufferContent(payload.AsBuffer());
   msg.Headers.Add("X-WNS-Type", "wns/tile"); // tile, badge, toast, or raw
   // For "wns/raw", the content type must be "application/octet-stream"
   msg.Content.Headers.ContentType = new HttpMediaTypeHeaderValue("text/xml");
   // Set optional headers:
   msg.Headers.Add("X-WNS-Cache-Policy", "cache");
   msg.Headers.Add("X-WNS-TTL", "60");  // Seconds
   // Assign tag label (max 16 chars) to notification; used by device to detect dups.
   msg.Headers.Add("X-WNS-Tag", "SomeTag");
   // Request for Device Status and Notification Status to be returned in the response
   msg.Headers.Add("X-WNS-RequestForStatus", "true");
   return await new HttpClient().SendRequestAsync(msg).AsTask().ConfigureAwait(false);
}

You need to add an X-WNS-Type header to indicate the type via four values: wns/tile, wins/toast, wns/badge, and wns/raw. You also have to add an Authorization string with the OAuth access token acquired from login.live.com. The last four headers are optional. X-WNS-Tag is the tag we used previously to target specific tiles in the notification queue. Similarly, X-WNS-TTL indicates (in seconds) how long the notification should live before it automatically expires. The cache value indicates what WNS needs to do with a notification if the target machine is offline. The default is to cache one badge and one tile notification, unless your app has tile queuing enabled—in which case, WNS caches up to five tile notifications. The last optional header, X-WNS-RequestForStatus, tells WNS that our web service wants to know the status of the user’s PC.

If you set the X-WNS-RequestForStatus request header to true, you get additional information back in the response:

X-WNS-NOTIFICATIONSTATUS: received
X-WNS-DEVICECONNECTIONSTATUS: connected
X-WNS-MSG-ID: 354223800B2B76E6
X-WNS-DEBUG-TRACE: BN1WNS1011529
Content-Length: 0
Date: Mon, 08 Oct 2012 20:05:14 GMT

The X-WNS-NOTIFICATIONSTATUS response header indicates that WNS has received the notification. If the end user has turned off notifications, this has a status of “dropped.” Your app can also exceed the bandwidth of the channel—in which case, the status will be “channelthrottled.” WNS returns X-WNS-DEVICECONNECTIONSTATUS if your app’s web service asked for it in the request by specifying X-WNS-RequestForStatus. The X-WNS-MSG-ID and the X-WNS-DEBUG-TRACE are used for debugging purposes when you need to ask Microsoft support to trace WNS messages.

To help debug WNS failures, see the following location in the system’s event log:

Applications And Services Log > Microsoft > Windows > PushNotifications-Platform

In addition, you (and your users) can see how much network usage an app is consuming for tiles and notifications by using Task Manager’s Tile Updates column (as shown in Figure 8-11).

Figure 8-11. Task Manager’s Tile Updates column shows network bandwidth used for an app’s tiles and notifications.