# Wednesday, December 10, 2014

"Small Gods" is the thirteenth book in Terry Pratchett's Discworld series.

Pratchett's Discworld universe contains a plethora of gods. The vast majority of these gods are tiny, swarming invisibly and unnoticed in the desert. But a few gain a following of worshippers, which increases both the size and the power of these fortunate gods.  One such god was Om, who was so powerful in the country of Omnia that the priests who ruled the country would tolerate the worship (or even mention) of any other god. Om would typically manifest himself as a giant bull; but, when the story opens, he has somehow been transformed into a small tortoise. Om is preoccupied with his reduction in status - from powerful being to to tiny reptile - and with avoiding the talons of hungry eagles circling overhead.

One of Om's problems is that the people of Omnia don't really believe in him - they only go through the motions of their religion out of fear of the priests and the mysterious Quisition, who capture, judge, and torture accused heretics. Another of Om's problems is that he cares very little for the lives and fates of those who worship him - he only desires their faith because it brings him greater power, but he cannot even remember the names of his own prophets.

While struggling in his tortoise form, Om encounter Brutha, an illiterate student/servant with a good heart. Brutha is the only one in Discworld who can see or hear Om because he is the only one who believes in him without the threats from the Omnian church. Brutha is troubled to discover his god is not omnipresent or omniscient or caring or even polite. But he agrees to help him return to his former glory.

Small Gods is filled with quirky characters and witty prose. Like all the Discworld novels, every scene overflows with silliness. Pratchett describes a philosopher with the following:

His philosophy was a mixture of three famous schools -- the Cynics, the Stoics and the Epicureans -- and summed up all three of them in his famous phrase, "You can't trust any bugger further than you can throw him, and there's nothing you can do about it, so let's have a drink."

Or this witty exchange between the leaders of two countries:

"Slave is an Ephebian word. In Om we have no word for slave," said Vorbis.
"So I understand," said the Tyrant. "I imagine that fish have no word for water."

But Small Gods also biting satire about the dangers of religious zealotry and the emptiness of blindly following tradition. With Small Gods, Pratchett reaches beyond making us laugh and makes us think.

Wednesday, December 10, 2014 2:49:00 PM (GMT Standard Time, UTC+00:00)
# Tuesday, December 9, 2014

I spend a lot of time learning new skills and new technologies. After learning something new, my first reactions are to apply it that knowledge and to share that knowledge. When I was a consultant, I spent more time applying knowledge; generally, I was learning things that I needed to do my job, such as a technology that fit my current project.

Today, I am a Technical Evangelist and I spend more time passing on that knowledge to others.

I have found the following to be the most useful ways to pass on the knowledge I've learned: blog posts; technical presentations at user groups and conferences; screen casts; and hands-on labs.

Each of these media tend to appeal to different groups. There are a number of software developers, for example, who read blogs every day but never attend a code camp or user group. There are also different learning styles: some people learn more by reading; others by seeing it done; still others by doing it for themselves. (For me, a combination of all three works best).

Knowing that these different audiences exist has given me permission to package the same information into a variety of formats.

For example, for the past few months, I've developed and delivered a presentation on Azure Mobile Services. The presentation lasts about 90 minutes, which is perfect for a user group. I can cut it down to 60 or 75 minutes for a conference time slot.

Many people who saw this presentation told me they like the content because it covers all the basic features of Mobile Services and explains why they are important.

A few weeks ago, I had some extra time so I decided to commit to a adding more technical content to my blog. I was struggling to come up with ideas when I thought of the Mobile Services presentation. As often as I gave this presentation, only a few hundred people had seen it due to the fact that people had to travel to a user group or conference on a specific date and time to catch it.

I decided to transcribe the contents of my presentation into a series of blog posts. So far, I've written 9 different blog posts and I still haven't covered all the material in the 90-minute presentation.  Writing blog posts makes the content available to people who prefer written material over in-person delivery; and it also makes it available to a much larger audience - you don't need to travel to where I'm speaking in order to learn what I am teaching. (I’ve linked to the posts at the end of the article)

After a couple weeks of blog posts, I scheduled a hands-on workshop at a large university in order to show students how to use Mobile Services. I decided to start the workshop by delivering my presentation. Afterwards, I wanted the students to try the technology themselves, so I wrote a set of Hands-On labs with step-by-step instructions for creating and configuring Azure Mobile Services. The labs were similar to some of the blog posts I had already written but I re-wrote them with a different audience and a different goal in mind - The blog posts could simply be read; but with the labs, I was expecting the reader to follow along, so I had to make each step as explicit as possible. You can download the current version of these labs at https://github.com/DavidGiard/Azure-Mobile-Services-Labs.

I haven't yet decided if I'll record a set of screencasts showing developers how to manage Azure Mobile Services, but doing so would not involve a huge amount of time, since I already have most of the script written (from either the blog posts or the labs).

I'm not sure what is my next step - expanding the labs, continuing the blog post series, or creating screencasts. Of course, there are other demands on my time that will keep me from doing all of the above.

My point is that I don't see any problem repackaging the same content in multiple formats. Different people learn in different ways, so it's a great way to scale your knowledge transfer. If you are in the business of educating people, I'd love to hear your opinion. Is it cheating to repackage the same content? Or is it effective use of time and good scaling of delivery?


Azure Mobile Services Blog Posts (so far)

Tuesday, December 9, 2014 11:50:00 AM (GMT Standard Time, UTC+00:00)
# Monday, December 8, 2014
# Sunday, December 7, 2014

12/5
Today I am grateful to all the Purdue students who came out to my Azure Mobile Services workshop last night.

12/4
Today I am grateful for lunch with Adina yesterday. in Wicker Park.

12/3
Today I am grateful for the audience at my final Cloud Dev Camp yesterday in Indianapolis.

12/2
Today I am grateful for my final 2014 trip to Indianapolis.

12/1
Today I am grateful I spent most of the past 24 hours with my son Tim.

11/30
Today I am grateful for another Michigan State football season with double-digit wins! #GoGreen

11/29
Today I am grateful for a home-cooked meal last night and leftovers for lunch today.

11/28
Today I am grateful for Thanksgiving dinner with my family yesterday.

11/27
Today I am grateful for my family - both near and far.

11/26
Today I am grateful that I have heat restored to my house on this chilly morning.

11/25
Today I am grateful I made it back to Michigan in time to take care of a couple emergencies with my house.

11/24
Today I am grateful to Jason Farrell, who loaned me his laptop power cord for over a week, making it possible for me to get some actual work done.

11/23
Today I am grateful for all the energy at the Northwestern University WildHacks hackathon this weekend.

11/22
Today I am grateful to be heading back home for the first time in over 10 days.

11/21
Today I am grateful to attend and speak at M3Conf for the first time yesterday and today http://m3conf.com .

11/20
Today I am grateful to those who came to the Cloud Dev Camp yesterday and to George, who helped me out by delivering an excellent Azure SQL Database presentation.

11/19
Today I am grateful for lunch yesterday with Kent in Franklin, TN.

11/18
Today I am grateful for a network of smart people I can call on for technical assistance.

11/17
Today I am grateful for: 1. The hospitality of Darlene and Kevin. 2. Getting to see an exciting Rams-Broncos game in St. Louis yesterday. 3. Fitz's root beer.

11/16
Today I am grateful for: 1. My first visit to St. Louis Day of .NET, and all the organizers, speakers, and attendees, who made it a great experience. 2. An exciting basketball game at St. Louis University last night.

11/15
Today I am grateful for all the great people I am meeting my first time at St. Louis Days of .NET.

11/14
Today I am grateful for; * Making it onto the last flight to St. Louis via standby. * My first-ever visit to Houston, TX * A great turnout at the Cloud Dev Camp yesterday * Finding my phone

11/13
Today I am grateful to spend yesterday hanging out with Sarah, driving around the state of Illinois.

11/12
Today I am grateful for the opportunity to teach my first college class last night.

11/11
Today I am grateful to all the veterans who have served our country, especially my Dad - Lt. Cmdr. E Normand Giard, USN, ret. His photo is my profile picture today in his honor.

11/10
Today I am grateful to Susan Anspaugh, who loaned me her carpet cleaner to shampoo my carpets and wasn't mad that I kept it so long.

11/9
Today I am grateful for a ticket to the MSU game last night, even though the good guys lost.

11/8
Today I am grateful I had a chance to watch the local premiere of "Teenage Ghost Punk" last night.

11/7
Today I am grateful for my first Office Hours at Chicago Innovation Exchange yesterday and to all those who showed up.

11/6
Today I am grateful that the sharp stomach cramps I took to bed last night were gone this morning.

11/5
Today I am grateful to return to Chicago and get back to what I do.

11/4
Today I am grateful I was able to stay in one place for a week, where I had a chance to catch my breath.

11/3
Today I am grateful for a walk along the river on an Autumn afternoon.

Sunday, December 7, 2014 12:05:50 PM (GMT Standard Time, UTC+00:00)
# Wednesday, December 3, 2014

Stephen R. Donaldson introduced Thomas Covenant in his 1977 novel Lord Foul's Bane. He continued the story in The Ilearth War and concluded the Trilogy with The Power That Preserves. Donaldson went on to write a second Trilogy about this character, followed by a 4-part series titled "The Last Chronicles of Thomas Covenant". This review covers only the first Trilogy.

Thomas Covenant was a bestselling author with a good home and a loving wife and infant son, when he was suddenly struck ill with leprosy. The disease cost him 2 fingers on his right hand and his wife, who left Thomas for fear their son would catch his disease. His neighbors rejected him out of fear and ignorance, but he defied them by walking into town each week to collect his mail.

On one such trip, Thomas was crossing the street and nearly run down by a police car. When he awoke, he found himself in a strange world, known only as The Land, facing the horrific villain Lord Foul, who commanded him to deliver a message to the people of The Land.

The Lords and commoners of The Land noticed Covenant's missing fingers and his white gold wedding ring and assumed he was the reincarnation of Berek Halfhand, a heroic figure from The Land's past, who lost his fingers battling the evil Lord Foul with the powerful force of white gold. They believed that Covenant was sent to The Land to protect them and to defeat Lord Foul.

Their faith in Covenant and their non-violent code caused them to forgive Covenant's every sin and shortcoming. And he has many.

When he enters the Land, Covenant's leprosy is magically cured, restoring feelings to his nerve endings. The rush of long-unfelt sensation is so overwhelming that he rapes Lena, a young woman who had shown kindness to him. Even this betrayal does not shatter the faith of either the people of The Land or of Lena herself.

Time and again throughout the trilogy, the Land's inhabitants sacrifice themselves for Covenant, hoping he will use his power and defeat Lord Foul; but, Covenant repeatedly defers, making no effort to learn how to harness the power of his white gold ring and often pushing his responsibility onto others.

Covenant is magically transported back to his own world; but is drawn back to The Land two more times with the expectation that he will rescue its inhabitants. Most of the time, the inhabitants are disappointed. Each time, he returns to The Land years have passed in this magical world, even though only a few weeks have passed in his own.

In the world of high fantasy, there are many unlikely heroes, but few as unlikeable as Thomas Covenant.

Covenant is reluctant to take on the responsibility of battling Lord Foul. During his years as a leper, he has learned to be extremely cautious because he no longer has nerve endings to warn him of impending danger. He carries this caution into The Land, despite no longer needing it. Worse, Covenant seems incompetent as The Land's heroes and does not even recognize the powers he has such as the magic that white gold holds in The Land. He leaves disappointment and betrayal almost everywhere he goes, until his final encounter with Lord Foul at the end of the third book.

Overall, I enjoyed this trilogy. The Land suffered under Lord Foul and their chosen hero could not help them; but ultimately Covenant found his strength and did what he needed to do.  The characters were interesting enough to hold my attention for three books; but I don't know if or when I'll return to The Land and read the remaining seven.

Wednesday, December 3, 2014 9:49:00 AM (GMT Standard Time, UTC+00:00)
# Tuesday, December 2, 2014

Writer/Director Michael Cramer describes Teenage Ghost Punk as a "supernatural punk rock romantic comedy" - a string of adjectives and nouns that make it tough to categorize.

The movie debuted in October at the Spooky Movie International Horror Film Festival in Washington, DC. I saw it a month later at its Chicagoland premiere at the School of Rock in Oak Park, IL.

Teenage Ghost Punk tells the story of a family moving into a haunted house. Amanda is a popular high school cheerleader from Spring Lake, MI, whose newly-divorced mother moves the family to suburban Chicago, hoping for a fresh start. Amanda feels out of place in her new home and she is stressed because she misses her cheerleader friends and tall-but-rockhead boyfriend. Things get worse when she begins to hear bumps in the night and family items turn up missing. It turns out that the house is inhabited by the ghost of Brian - a teenager who was struck by lightning while playing guitar on the house's roof during a thunderstorm in the early 1980s. Brian is convinced this is still his house and that Amanda and family are intruding. Only Amanda can see and hear Brian and his ghostly pals. They talk and become close and Amanda decides to invite Brian to the school dance, where she hopes to introduce her friends to her new boyfriend. And then it gets weird.

WP_20141107_20_48_06_Pro
Cramer, along with some of the cast and crew answer audience
questions after the Chicagoland debut viewing November 7

In 2009, Michael Cramer released his first movie - Dear Mr. Fidrych - about a kid who idolized Detroit Tigers Pitcher Mark "The Bird" Fidrych, then grew up to address his midlife crisis by taking his son across country to meet his boyhood idol Fidrych.

I liked Dear Mr. Fidrych. It reminded me of my own childhood - and not just because Cramer and I grew up together in a Detroit suburb during the 1970's when The Bird had his burst of fame. However, Dear Mr. Fidrych was an independent film created on a shoestring budget and there was no hiding these facts.  Technical aspects of the movie were lacking - in particular the sound was inconsistent throughout the film and nearly all the actors were amateurs, with the leading roles going to the director and his immediate family. The story, the energy, and the charm of Dear Mr. Fidrych were enough to more than make up for any technical weaknesses.

Teenage Ghost Punk is far more polished. One could easily believe it was produced and created by a Hollywood studio. The sound is better, the cinematography is better and the acting is better. But the script retains the humor and the humanness of Dear Mr. Fidrych. Even Jack Cramer (son of the director), who plays the title character, has grown into a solid actor. He has an engaging smile that resonates on screen as he charms both Amanda and the audience. I can't think of any aspect of moviemaking that did not improve between Cramer's first movie and this one.

Teenage Ghost Punk is filled with memorable characters. A bumbling Ghostbusters-like team fails to defeat any ghosts but end up being right about their supernatural presence; the neighborhood ghosts spend their days recreating moments from their lives and spend their evenings playing cards; The over-the-top gay neighbors bicker and cuddle shamelessly; Amanda's little brother Adam includes 4-syllable words in nearly every sentences; and Madame Lidnar has little success at her own séances, but relates as well as anyone to the ghosts when she encounters them.

The silliness of the characters adds to the story, rather than distracting from it. The theme of TGP comes together very well at the end. Ultimately, the movie is about letting go of the past and moving on. Most of the characters - living and dead - are unable to do so until the end of the movie. They grew and matured as time passed.

And so did Michael Cramer and his crew.

Tuesday, December 2, 2014 10:45:00 AM (GMT Standard Time, UTC+00:00)
# Monday, December 1, 2014
Monday, December 1, 2014 11:24:00 AM (GMT Standard Time, UTC+00:00)
# Sunday, November 30, 2014

In my last article, I described how to use Visual Studio to create and deploy an Azure Mobile Service with server-side code written in a .NET language. I chose C# for that example. In this article, we will walk through the boilerplate C# code generated when you create a new Azure Mobile Services project.

Figure 1 shows the newly-created Azure Mobile Services project in Visual Studio’s Solution Explorer

Zumo9-Figure 01 - ZuMo Project
Figure 1

Let’s go through the key parts of the code.

Global.asax.cs

The Application_Start code runs at the very beginning of the application so any startup code goes here. In this case, we call the static method WebApiConfig.Register (Listing 1).

protected void Application_Start()
{
    WebApiConfig.Register();
}

Listing 1

WebApiConfig.cs

Let's take a look at the Register method in the WebApiConfig class.  WebApiConfig.cs is in App_Start folder.

This project uses the Entity Framework to interact read and write data. The most important line of the Register method (Listing 2) is

Database.SetInitializer(new MobileServiceInitializer());

which initializes Entity Framework settings. The new MobileServiceInitializer is found in the same file and it has the ability to seed the sample TodoItem table with a couple records (Listing 3)

public static void Register()
{
    // Use this class to set configuration options for your mobile service
    ConfigOptions options = new ConfigOptions(); 
 
    // Use this class to set WebAPI configuration options
    HttpConfiguration config = ServiceConfig.Initialize(new ConfigBuilder(options)); 
 
    // To display errors in the browser during development, uncomment the following
    // line. Comment it out again when you deploy your service for production use.
    // config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; 
 
    Database.SetInitializer(new MobileServiceInitializer());
} 
 


Listing 2

public class MobileServiceInitializer : DropCreateDatabaseIfModelChanges<MobileServiceContext>
{
    protected override void Seed(MobileServiceContext context)
    {
        List<TodoItem> todoItems = new List<TodoItem>
        {
            new TodoItem { Id = "1", Text = "First item", Complete = false },
            new TodoItem { Id = "2", Text = "Second item", Complete = false },
        }; 
 
        foreach (TodoItem todoItem in todoItems)
        {
            context.Set<TodoItem>().Add(todoItem);
        } 
 
        base.Seed(context);
    }
}

Listing 3

TodoItem.cs

Next, we'll look at the TodoItem class (Listing 4), which can be found in DataObjects folder. This is the data model and will. It has 2 explicit properties - Text: the text of a Task that we need to complete; and Complete: a flag indicated whether or not we have completed this task. This object will will map to columns in the TodoItem table.
We don't need to explicitly provide an ID property because the class inherits this property from the EntityData class.

public class TodoItem : EntityData
{
    public string Text { get; set; } 
 
    public bool Complete { get; set; }
}
 

Listing 4

MobileServiceContext.cs

This is a Context used to manage database updates and retrievals via Entity Framework. It knows where to connect to the database and what model to send to the database. The Controller class will instantiate this to interact with the database table.

TodoItemController.cs

TodoItemController is the main controller class that maps HTTP Verbs (POST, PATCH, GET, and DELETE) to specific actions. It inherits from the TableController class, which has an IDomainManager named DomainManager that is used to retrieve and update data using Entity Framework. All the controller methods need to do is to call TableController methods, such as Lookup, UpdateAsync, InsertAsync, and DeleteAsync.

For example, if a client sends a request to our mobile service’s HTTP endpoint with the POST verb, the routing engine will run the PostTodItem method in TodoItemController (Listing 5).

public async Task<IHttpActionResult> PostTodoItem(TodoItem item)
{
    TodoItem current = await InsertAsync(item);
    return CreatedAtRoute("Tables", new { id = current.Id }, current);
}

To add business logic to your service, you will add code to the Controller methods (GetAllTodoItems, GetTodoItem, PatchTodoItem, PostTodoItem, and DeleteTodoItem.)

In this article, we covered the code that is automatically generated in a C# Azure Mobile Service.

Sunday, November 30, 2014 2:19:16 PM (GMT Standard Time, UTC+00:00)
# Saturday, November 29, 2014

In a previous article, I described how to create an Azure Mobile Service built on top of node.js - with all the server-side code written in JavaScript. You can also create a Mobile Service with server-side code written in C# or Visual Basic. You will probably prefer this method if you are more  proficient in .NET than in JavaScript.

This article will walk you through the creation of an Azure Mobile Service, written in C#.

Launch Visual Studio 2013 and select File | New | Project from the menu. The New Project dialog displays, as shown in Figure 1.

Zumo8-Figure 01 - FileNew
Figure 1

Under the Templates list at the left of the dialog, expand either Visual Basic or C#; then, select the Cloud template category. Select "Azure Mobile Service" from the Cloud templates listed at the center of the dialog. Give the project a Name and Location and click the [OK] button.

The New ASP.NET Project dialog displays, as shown in Figure 2.

Zumo8-Figure 02 - NewProject Template
Figure 2

The Azure Mobile Service template should be selected and the "Web API" checkbox should be checked. Leave these selected and check and check the Host in the cloud checkbox; then, click the [OK] button.

Because you elected to host this service in the cloud, the Create Mobile Service dialog displays next, as shown in Figure 3.

Zumo8-Figure 03 - Create Mobile Service
Figure 3

Select an Azure subscription to deploy the Mobile Service; enter a name for your Mobile Service (it must be unique);  select a Region; select a database; and enter login credentials for that database. Then click the [Create] button. This should create a project on your local machine and an empty Mobile Service in your Azure subscription.

The Mobile Service project is shown in Figure 4.

Zumo8-Figure 04 - ZuMo Project
Figure 4

To publish your Mobile Service, right-click the project in the Solution Explorer and select Publish from the context menu. The "Publish Web" wizard displays with the "Profile" page activated as shown in Figure 5.

Zumo8-Figure 05 - Publish Web
Figure 5

Under "Select a publish target", click "Microsoft Azure Mobile Service". The "Select Existing Mobile Service" dialog displays as shown in Figure 6.

Zumo8-Figure 06 - Publish Web-Profile
Figure 6

From the dropdown, select the Azure Mobile Service you created above and click the [Next] button.

The Profile page of the "Publish Web" wizard displays as shown in Figure 7.

Zumo8-Figure 07 - Publish Web-Connection
Figure 7

Verify the information on the Profile page is correct and click the [Next] button.

The "Settings" page of the "Publish Web" wizard displays as shown in Figure 8.

Zumo8-Figure 08 - Publish Web-Settings
Figure 8

Select "Release" from the Configuration dropdown and click the [Next] button.

The "Preview" page of the "Publish Web" wizard displays as shown in Figure 9.

Zumo8-Figure 09 - Publish Web-Publish
Figure 9

Click the [Publish] button to publish the Mobile Service to your Azure subscription.

Now, you should be able to log onto the portal and view your new mobile service (Figure 10). Its status may be listed as “Creating…” if you go to the portal too quickly; but, within a couple minutes, you will be able to manage the service from the Azure portal.

Zumo8-Figure 10 - Service in Portal
Figure 10

You can manage this service almost exactly the same way that you managed a JavaScript mobile service. The difference is that the .NET mobile service does not contain a DATA tab. Data configuration in a .NET service is done in the Visual Studio project.

In this article, we showed the steps to create and publish a new Azure Mobile Service with server-side code in a .NET language.

Saturday, November 29, 2014 2:20:36 PM (GMT Standard Time, UTC+00:00)
# Friday, November 28, 2014

Azure Mobile Services provides a simple way to expose server-side data to clients. In previous articles, we exposed data via a REST service and we created a client application that called that service to retrieve or update data.

But what if we want our service to push data down from the server to a client device without that device making a call each time? For example, you may want to tell send a message telling your app to change the text displayed on its tile, displaying the total number of orders entered in your e-commerce app; or you may want a "toast" popup notification to display on the app's device whenever someone scores in the Top 10 on a game you wrote.

We can use Push Notifications to do these things.

Each mobile vendor has its own service to manage Push Notifications and each service exposes an API to manage those notifications. Apple offers a Push Notification service to send data to registered iPhones and iPads; Google offers a Push Notification service to send data to registered Android phones and tablets; and Microsoft offers two Push Notification services - one to send data to registered Windows Pones and another to send data to registered Windows 8 or 8.1 devices.

Each of these services has an API and we can call each one explicitly for every device that will receive a notification. But this requires passing the address of each device, which is tedious and error-prone. Plus, it requires our server-side application to maintain a list of every device to which we want to push messages.

We can simplify the process by configuring Push Notifications through Azure Mobile Services. Azure Mobile Services Push Notifications automatically works with Azure Notification hubs to manage these messages.

In this article, we will focus on sending a Toast Notification to Windows 8.1 clients, but the process is similar for all Push Notifications.

The steps for setting up Push Notifications to a Windows 8.1 client using Azure Mobile Services are:

1. Create an Azure Mobile Service
2. Create a Windows 8.1 Client App and modify it as follows
    a. Associate app with store
    b. Get Package SID and Client ID from Live Services. Copy these to Mobile Service.
    c. Register notifications channel in OnLaunched (App.xaml.cs)
    d. Enable Toast notifications (Package.appxmanifest)
3. Update the Mobile Service service to send Push Notifications.

Let's walk through an example.

1. Create an Azure Mobile Service

For our example, we'll use the Azure Mobile Service we created in a previous article

2. Create a Windows 8.1 Client App and modify it as follows

For this example, we'll use the Windows 8.1 project in the Universal App generated for us in a previous article.

2a. Associate app with store

You will need a Windows Store account to complete this step. You can register at http://dev.windows.com/. It cost $19 to register for both the Windows Store and the Windows Phone Store and there is no annual renewal fee.
Register your app with the store by opening the Visual Studio Solution; right-clicking on the Windows 8.1 project; and selecting Store | Associate App with the Store from the context menu.
The "Associate App with the Windows Store" dialog (Figure 1) displays. Click the [Next] button.

Zumo7-Figure 01 - Associate App 
Figure 1

If prompted, sign into the Windows Store (Figure 2)

Zumo7-Figure 02 - Sign In 
Figure 2

You may be prompted for your email address (Figure 3). If so, enter it and click [Next]; then check your email account for a Security Code that was sent from the Microsoft Account Team.

Zumo7-Figure 03 - Sign In 
Figure 3

Copy this code and paste it into Sign-In Wizard (Figure 4) and click the [Submit] button.

Zumo7-Figure 04 - Sign In 
Figure 4

The "Select an app name" dialog (Figure 5) displays.

Zumo7-Figure 05 - Select App Name 
Figure 5

Enter a name for your app and click the [Reserve] button; then, click the [Next] button to display the final step in the wizard (Figure 6). Click the [Associate] button.

Zumo7-Figure 06 - Associate App
Figure 6

2b. Get Package SID and Client ID from Live Services. Copy these to Mobile Service.

Connect to the store portal (http://dev.windows.com for Windows Store apps and http://dev.windowsphone.com for Windows Phone apps) and click Dashboard. You should see your app listed with "In Progress" below its listing. Figure 7 shows the listing for an app in the Windows Store dashboard

Zumo7-Figure 07 - DevCenter Dashboard 
Figure 7

Click the [Edit] link below your app to display the Submissions Details page (Figure 8).

Zumo7-Figure 08 - App Details
Figure 8

So far, you have only completed Step 1 (Reserve App Name) of the app submission process. Click step 2 (Services) to display the app's Services page (Figure 9)

Zumo7-Figure 09 - App Services 
Figure 9

Click the Live Services site link in the second paragraph to navigate to the Live Services page (Figure 10). You may be prompted to sign in again.

Zumo7-Figure 10 - Live Services
Figure 10

Note the Package SID and Client ID on the Live Services page. Copy each of these in turn and paste them into the appropriate fields of the "Windows Store" section of the "Push" page in the Azure Mobile Services page of the Azure portal. This is demonstrated in Figure 11.

 Zumo7-Figure 11 - Azure Push
Figure 11

Click the [Save] icon to save these values to your Mobile Service. 

Your service is now capable of sending notifications to Windows store client apps.

2c. Register notifications channel in OnLaunched (App.xaml.cs)

Return to your .NET client application and open App.xaml.cs from the Shared project. Add the following 2 lines (Listing 1) to the top of this file:

   1: using Windows.Networking.PushNotifications;
   2: using Windows.UI.Popups;

Listing 1

Add the InitNotificationsAsync method to the bottom of the class (Listing 2)

   1: private async void InitNotificationsAsync()
   2: {
   3:     // Request a push notification channel.
   4:     var channel = await PushNotificationChannelManager
   5:         .CreatePushNotificationChannelForApplicationAsync();
   6:  
   7:     // Register for notifications using the new channel
   8:     System.Exception exception = null;
   9:     try
  10:     {
  11:         await MobileService.GetPush().RegisterNativeAsync(channel.Uri);
  12:     }
  13:     catch (System.Exception ex)
  14:     {
  15:         exception = ex;
  16:     }
  17:     if (exception != null)
  18:     {
  19:         var dialog = new MessageDialog(exception.Message, "Registering Channel URI");
  20:         dialog.Commands.Add(new UICommand("OK"));
  21:         await dialog.ShowAsync();
  22:     }
  23: }

Listing 2

Your client application is now listening for push notifications.

2d. Enable Toast notifications (Package.appxmanifest)

In this example, the service will send a Toast notification, which will tell the client to popup a "Toast" message. A Toast message appears at the top-right of the Windows 8 screen and may contain 1 or more lines of text and an image.

To enable your application to accept Toast notifications, open the Package.appxmanifest file and select the "Application" tab. Under the Notifications section, select the "Toast capable" dropdown and set it to "Yes". (Figure 11)

Zumo7-Figure 12 - Enable Toast
Figure 12

Your client application is now listening for push notifications and capable of creating a Toast popup when it receives a notification.

3. Update the Mobile Service service to send Push Notifications.

The final step is to actually send Push Notifications from your Mobile Service. In this example, we will use the node.js mobile service we created in this article (link) and we'll send a Toast Notification to all Windows Store clients whenever a user enters a new ToDoItem.

In the Azure portal, open your Mobile Service and navigate to the todoitem table's SCRIPT page (Figure 12). 

Zumo7-Figure 13 - Insert Script
Figure 11

Select INSERT from the dropdown and replace the script with the code in Listing 3.

   1: request.execute({
   2:     success: function() {
   3:         // If the insert succeeds, send a notification.
   4:         push.wns.send(null, payload, 'wns/toast', {
   5:             success: function(pushResponse) {
   6:                 console.log("Sent push:", pushResponse);
   7:                 request.respond();
   8:                 },              
   9:                 error: function (pushResponse) {
  10:                     console.log("Error Sending push:", pushResponse);
  11:                     request.respond(500, { error: pushResponse });
  12:                     }
  13:                 });
  14:             }
  15:         });
  16:  
  17: }

Listing 3

Test It Out

Your app is now ready to accept Push Notifications and your Mobile Service is configured to send them each time a new "ToDoItem" is inserted.

To see it in action, launch the application and insert a new ToDo item. Within a few seconds, you should see a "Toast" popup in the top right of your screen, indicating that you entered this item. If other users were also using this same app, they would see the same message.

In this article, we discussed Azure Mobile Services Push Notifications and walked through an example of adding them to a JavaScript Push Notification service and a Windows 8.1 application.

Friday, November 28, 2014 11:07:00 AM (GMT Standard Time, UTC+00:00)