When implementing push notification solutions for your Windows Store apps many people will implement the basic flow you typically see in a demo then consider their implementation as job done. While this works well in demos and apps that are running at a small scale with few users those that are successful will likely want to optimize their solution to be more efficient to reduce compute and storage costs. While this post is not a complete guide I am providing it to at least give you enough information to get you thinking about the right things.
A few quick up front questions you should ask yourself are:
- Is push appropriate? Should I be using Local, Scheduled or Periodic notifications instead?
- Do I need updates at a more granular frequency then every 30 minutes?
- Am I sending notifications that are personalized for each recipient or am I sending a broadcast style notification with the same content to a group of users?
A typical implementation
If you figured out push is the right choice and implemented the basic flow it will normally look something like this:
- Requesting a channel
using Windows.Networking.PushNotifications;
…
var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
- Registering that channel with your cloud service
var token = Windows.System.Profile.HardwareIdentification.GetPackageSpecificToken(null);
string installationId = Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(token.Id);
var ch = new JObject();
ch.Add("channelUri", channel.Uri);
ch.Add("installationId", installationId);
try
{
await App.pushdemoClient.GetTable("channels").InsertAsync(ch);
}
catch (Exception exception)
{
HandleInsertChannelException(exception);
}
- Authenticate against WNS and sending a push notification
//Note: Mobile Services handles your Auth against WNS for your, all you have to do is configure your Store app and the portal WNS credentials.
function SendPush() {
var channelTable = tables.getTable('channels');
channelTable.read({
success: function (channels) {
channels.forEach(function (channel) {
push.wns.sendTileWideText03(channel.uri, {
text1: 'hello W8 world: ' + new Date().toString()
});
});
}
});
}
And for most people this is about as far as the push implementation goes. What many are not aware of is that WNS actually provides two useful pieces of information that you can use to make your push implementation more efficient – a Channel Expiry time and a WNS response that includes both notification status codes and device status codes using this information you can make your solution more efficient. Let’s take a look at the first one
Handling Expired Channels
When you request a channel from WNS it will return to you both a channel and an expiry time, typically 30 days from your request. Consider that your app over time is popular but you do have users that over time end up deciding either to not use your app for extended periods or delete it all together. Over time these channels will hit their expiry date and will no longer be of any use and there is no need to a) send notifications to these channels and b) keep these channels in your datastore. Let’s have a look at a simple implementation that will cleanup your expired channels.
Using a Scheduled Job in Mobile Services we can perform a simple clean of your channels but first we must send the Expiry to your Mobile Service. To do this you must update step 2 of the above implementation to pass up the channel expiry as a property in your JObject – you will find the channel expiration in the channel.ExpirationTime property. For my channel table I have called this Expiry.
Following that once you have created your scheduled push job at say an interval of X (I am using 15 minutes) you can then add a function that deletes the expired channels similar to the following
function cleanChannels() {
var sql = "DELETE FROM channels WHERE Expiry < GetDate()";
mssql.query(sql, {
success: function (results) {
console.log('deleting expired channels:', results)
},
error: function (error) {
console.log(error);
}
});
}
As you can see there is no real magic here and you probably want to handle UTC dates – but in short it demonstrates the concept that the expired channels are not useful for sending notifications so delete them, flag them as deleted or anything else that keeps them out of the valid set that you will push to… moving on
Handling the WNS response codes
When you send a notification to a channel via WNS, WNS will send a response. Within this response are many useful response headers. Today i’ll just focus on X-WNS-NotificationStatus but it’s worth noting that you should also consider X-WNS-DeviceConnectionStatus – more details here
Let’s look at a typical response:
{
headers:
{ ‘x-wns-notificationstatus': ‘received’,
‘x-wns-msg-id': ‘707E20A6167E338B’,
‘x-wns-debug-trace': ‘BN1WNS1011532′ },
statusCode: 200,
channel: ‘https://bn1.notify.windows.com/?token=AgYAAACghhaYbZa4sqjJ23pWp3kGDcEOEb3JxxdeBahCINn15fc11TiG0mlTpR5heYQmEaQrgZc3TSSwoUllW9s4Lsn3eyvSn19DcrX%2bOvSOY4Bq%2bPKGWbdy3mjTmaRi2Yb1dIM%3d’
}
Of interest in this response is X-WNS-NotificationStatus which can be one of three different states:
- received
- dropped
- channelthrottled
As you can probably guess if you are sending notifications when you are either throttled or dropped it is probably not a good use of your compute power and as such you should really handle channels that are not returning received status in a fitting way. Consider the following when the scheduled job runs delete any expired channels and send notifications to channels in (the status of received) OR (that are not in the status of received AND that last had a push sent over an hour ago). This can be easily achieved by tracking the X-WNS-NotificationStatus every time a notification is sent. Code follows:
function SendPush() {
cleanChannels();
doPush();
}
function cleanChannels() {
var sql = "DELETE FROM channel WHERE Expiry < GetDate()";
mssql.query(sql, {
success: function (results) {
console.log('deleting expired channels:', results)
},
error: function (error) {
console.log(error);
}
});
}
function doPush() {
//send only to received channels OR channels that are not in the state of received that last had a push sent over an hour ago
var sql = "SELECT * FROM channel WHERE notificationStatus IS NULL OR notificationStatus = 'received'
OR ( notificationStatus <> 'received'
AND CAST(GetDate() - lastSend AS float) * 24 >= 1) ";
mssql.query(sql, {
success: function (channels) {
channels.forEach(function (channel) {
push.wns.sendTileWideText03(channel.uri, {
text1: 'hello W8 world: ' + new Date().toString()
}, {
success: function (response) {
handleWnsResponse(response, channel);
},
error: function (error) {
console.log(error);
}
});
});
}
});
}
// keep track of the last know X-WNS-NotificationStatus status for a channel
function handleWnsResponse(response, channel) {
console.log(response);
var channelTable = tables.getTable('channel');
// http://msdn.microsoft.com/en-us/library/windows/apps/hh465435.aspx
channel.notificationStatus = response.headers['x-wns-notificationstatus'];
channel.lastSend = new Date();
channelTable.update(channel);
}
That’s about it I hope this post has helped you to start thinking about how to handle your Push Notification implementation beyond the basic 101 demo push implementation
Enjoy, Nick Harris
