“IN THE STORY that follows, we explore the practical ideas of relationship awareness theory.”
From the book “Have a Nice Conflict“

When I read that first sentence from “Have a Nice Conflict” I said to myself, “God, I am going to hate this book.”  I’m an engineer by trade.  I have a black and white personality.  Let me come clean on the truth: My book reading (and writing for that matter) for the last decade has been limited to mostly software and fly fishing.  Don’t get me wrong.  It’s my job to read.  A huge portion of my day is spent reading.  But, the sheer thought of reading a management self help book made me cringe.  I have tried to read books like this, but I never finish.

This book “Have a nice Conflict” is climbing the Amazon and NY Times Best seller list.  And now that I have read the book, I can see why. 

From where I write this in my office I can clearly see the books, “Execution”, “Never Eat Alone”, “The Five Dysfunctions of a Team”, and “How Full is your Bucket” among other self help business books in my bookcase.  And I look back at all those like it was a waste of my time to read them.  It’s not that they are not valuable, I know they are very valuable for many people.  They just didn’t feel like reading them was a good spend of my time – Again the weakness / arrogance of my black and white personality.  Well, that, and to be frank, turning turning obvious concepts into books seems like such a waste of trees.

But, the engineer is an interesting breed.  As any PM will tell you they are very hard to manage.  Why?  Well I disdain generalizing any group of humans, but where in the world do we find a group of such arrogant “I’m the smartest person I have ever met and not only do I know everything about engineering I know everything about everything.” and at the same time have such fragile egos that need to be constantly appreciated than engineers?  This group is rife with conflict.  And I’m one of them I fear.  And it’s not like I wasn’t aware of it until reading the book.  I was.  But, the biggest lesson I learned from reading the book is that as a “Red”, I leave a huge calamity of conflict in my wake…and I don’t even realize it.  The book has helped to explain why I am so puzzled at some people’s reactions to the “matter of fact” things I say.  You’ll have to read the book to figure out what a “Red” is and all the other colors of humans that the book classifies.

If you are an engineer or have to work with them directly, I strongly recommend you get your hands on this book.  It’s premise is preventing, managing and leveraging conflict.  But, it is the details around the story told that pulls it together for “black and whites” like me.

Windows Phone 7 push notifications are tricky. Take Microsoft’s clear-as-mudd “overview” diagram, for example…

All sorts of colors and arrows going on there. The green parts represent code that you write, and the blue parts represent what Microsoft already has in place. The numbers and arrows represent the awkward dance between them. I’ll try to explain…

First, in your application (green side of step 1) you have to use Microsoft’s client side portion of their Push Notification Service, which is the HTTPNotificationChannel class (blue side of step 1) , to see if the app already has an open notification channel with Microsoft’s service (that’s the MPNS box in the bottom right). Only one channel per application is allowed, and you can use that single channel for all of your apps Push Notification needs.

If there is no channel open already, you can go ahead and use the aforementioned HTTPNotificationChannel class to set one up. This is step 2 in the diagram above, and here is a sample of it in code….

*I used this tutorial by Ben Cull for most of the code you’re going to see, until we get to the “multi-app” support on the server.

private void RegisterDevice()
		{
			HttpNotificationChannel httpChannel;
			httpChannel = HttpNotificationChannel.Find("TestChannel");

			if (httpChannel != null)
			{
				SubscribeToChannelEvents();
				SubscribeToService();
			}
			else
			{
				httpChannel = new HttpNotificationChannel("TestChannel", "TestService");
				SubscribeToChannelEvents();
				httpChannel.Open();
				if (!httpChannel.IsShellToastBound)
				{
					httpChannel.BindToShellToast();
				}
				if (!httpChannel.IsShellTileBound)
				{
					var c = new System.Collections.ObjectModel.Collection<Uri>();
					c.Add(new Uri("http://0.tqn.com/"));
					httpChannel.BindToShellTile(c);
				}
			}
		}

The call to the “SubscribeToChannelEvents()” method above is represented by step 3 in the diagram, and here’s what it looks like in code…

private void SubscribeToChannelEvents()
		{
			httpChannel.ChannelUriUpdated += new EventHandler<NotificationChannelUriEventArgs>(httpChannel_ChannelUriUpdated);
			httpChannel.HttpNotificationReceived += new EventHandler<HttpNotificationEventArgs>(httpChannel_HttpNotificationReceived);
			httpChannel.ShellToastNotificationReceived += new EventHandler<NotificationEventArgs>(httpChannel_ShellToastNotificationReceived);
			httpChannel.ErrorOccurred += new EventHandler<NotificationChannelErrorEventArgs>(httpChannel_ErrorOccurred);
		}

Step 4 in the diagram is sending your notification channel’s URI (it gets this URI through magic during step 2). This is where you need to have a WCF REST Service set up with a database to hold your device id’s and URI’s. The code below shows how to subscribe to the service from the client side, but if you want the server side setup and registration you can find all of that in Ben Cull’s blog post here

public string ParseANID(string anid)
		{
			if (!String.IsNullOrEmpty(anid))
			{
				string[] parts = anid.Split('&');
				IEnumerable<string[]> pairs = parts.Select(part => part.Split('='));
				string id = pairs.Where(pair => pair.Length == 2 && pair[0] == "A").Select(pair => pair[1]).FirstOrDefault();
				return id; } return String.Empty;
		}

		private void SubscribeToService()
		{
			if (!NetworkInterface.GetIsNetworkAvailable())
			{
				return;
			}

			string id = ParseANID(UserExtendedProperties.GetValue("ANID") as string);
			var emulatorUrl = string.Format("http://localhost:55875/notifications/register?deviceid={0}&uri={1}", id, httpChannel.ChannelUri.ToString());
			var wc = new WebClient();
			wc.DownloadStringCompleted += new DownloadStringCompletedEventHandler(wc_DownloadStringCompleted);
			wc.DownloadStringAsync(new Uri(emulatorUrl));
		}

The “ANID” that you see above is pretty much a unique guid generated for each user’s Live ID. Also, the emulatorUrl variable above is assuming that you’re running the WCF service on the same machine that you’re writing the client side phone code on, and that you’re using the phone emulator to debug. If you’re using an actual device to debug than “localhost” will produce nothing but disappointment, so adjust your url as needed. At this point, if you followed the WCF REST Service tutorial i linked to above, you’ll have the infrastructure in place to send push notifications, but no actual way of doing so yet.

For that we’ll need a service running on the server, with a timer that goes out and determines if there’s any updates it needs to send to anyone (for example, a weather service that checks for severe weather wvery 30 minutes based on a zip code sent by the client side phone app). But all of this is for a single app. If I wanted to do push notifications again in the future i would have to do this all over again for each new app. Instead, I decided to use a single REST Service, web service, and central device database. The service doesn’t contain the timer with the application logic. Instead, each app that you want to support is represented by a class that you instantiate in the OnStart() method of the service, and each app class contains its own timer, logic, and its own database with device id’s and any parameters required for it to work. For the sake of simplicity below are 2 examples of test apps that use the AppName property of the central database rather than their own seperate databases….

namespace PushNotificationService.Apps
{
	public class TestApp
	{
		private WP7AppDBEntities _dbContext;
		private readonly string _appName = "TestApp";

		public TestApp()
		{
			_dbContext = new WP7AppDBEntities();
			var t = new Timer();
			t.Interval = 10000;
			t.Elapsed += new ElapsedEventHandler(OnTimerElapsed);
			t.Start();

		}

		private void OnTimerElapsed(object sender, ElapsedEventArgs e)
		{
			_dbContext.Devices.Where(d => d.AppName == _appName).ToList().ForEach(d =>
			                                                                      	{
			                                                                      		try
			                                                                      		{
			                                                                      			PushNotifications.SendToast(d.URI, "Test",
			                                                                      			                            "Hello");
			                                                                      		}
																						catch{}
			                                                                      	});
		}
	}
}

namespace PushNotificationService.Apps
{
	public class TestApp2
	{
		private WP7AppDBEntities _dbContext;
		private readonly string _appName = "TestApp2";

		public TestApp2()
		{
			_dbContext = new WP7AppDBEntities();
			var t = new Timer();
			t.Interval = 20000;
			t.Elapsed += new ElapsedEventHandler(OnTimerElapsed);
			t.Start();

		}

		private void OnTimerElapsed(object sender, ElapsedEventArgs e)
		{
			_dbContext.Devices.Where(d => d.AppName == _appName).ToList().ForEach(d =>
			                                                                      	{
			                                                                      		try
			                                                                      		{
			                                                                      			PushNotifications.SendToast(d.URI,
			                                                                      			                            "TestApp2!",
			                                                                      			                            "It's working!");
			                                                                      		}
																						catch{}
			                                                                      	});
		}
	}
}

The PushNotifications.SendToast method that you see above represents step 5 of the diagram, and is provided in detail here.

And here are the classes being instantiated in the OnStart() method of the service…

protected override void OnStart(string[] args)
		{
			var testApp = new TestApp();
			var testApp2 = new TestApp2();

		}

This was my first time presenting at any code camp. I’d like to thank those that attended and participated. They made the experience very enjoyable. You can download my slide deck here. I hope you find the information useful. Please let me know if you need any links that are not included in the slide deck.

Summary

Interest in the Windows Phone 7 platform is growing quickly and the need for apps is increasing faster still. However, not everything related to a consumer’s Live profile is available on the phone natively. On Dec. 7, 2011 Microsoft released a new Windows Live SDK which allows access to Calendars, Contacts, Documents, and more. We’ll be walking through the SDK and learn how to implement calls to Windows Live in order to support the rich functionality desired by consumers of Windows Phone 7.

Cheers and Happy Coding!