-

MetroEvenToCommand v2.1

Sun, 16 Jun 2013 18:11:40 GMT

Just a quick update of MetroEventToCommand.

Now it has a “HandleEvent” property. When true, it will set the event to Handled (providing the event args support it).

Exemple :

        <Button Grid.Column="1" Grid.Row="1" Content="Parameter" HorizontalAlignment="Center">
            <metroEventToCommand:EventToCommandManager.Collection>
                <metroEventToCommand:EventToCommand Command="{Binding Test2Command}" HandleEvent="True"
                     CommandParameter="{Binding SimpleParam}" Event="Click">
               </metroEventToCommand:EventToCommand>
            </metroEventToCommand:EventToCommandManager.Collection>
        </Button>

If the eventarg doesn’t have an Handled property, it will just do nothing.

http://nuget.org/packages/MetroEventToCommand/

That’s all for this time, next posts will be during //build/.

MetroEvenToCommand v2.1

Sun, 16 Jun 2013 18:11:40 GMT

Juste une petite mise à jour de MetroEventToCommand.

Il y a maintenant une propriété “HandleEvent”. Quand elle est à True, ça va mettre l’évènement à Handled (Si l’évènement gère cette propriété).

Exemple :

        <Button Grid.Column="1" Grid.Row="1" Content="Parameter" HorizontalAlignment="Center">
            <metroEventToCommand:EventToCommandManager.Collection>
                <metroEventToCommand:EventToCommand Command="{Binding Test2Command}" HandleEvent="True"
                     CommandParameter="{Binding SimpleParam}" Event="Click">
               </metroEventToCommand:EventToCommand>
            </metroEventToCommand:EventToCommandManager.Collection>
        </Button>

Si l’évènement (Ou, pour être exact, le eventarg de l’évènement) n’a pas de propriété Handled, il ne se passe rien.

http://nuget.org/packages/MetroEventToCommand/

C’est tout pour cette fois, le prochain post est durant le //build/.

Nokia Developer Champion

Fri, 17 May 2013 13:55:47 GMT

Got a nice email from Nokia last week : they awarded me the Nokia Developer Champion title !

It was an amazing surprise, thanks to the Nokia team !

So, what is the Nokia Developer Champion (NDC) program ? Well, you can see it as the MVP program for Nokia. It is also awarded for 1 year renewable.

The key benefits are :

Nokia recognition
A device as Welcome Gift (Waiting for the 925)
Nokia Developer Premium membership
Technical support
Support for developer events
Invitations to some Nokia events

More information here : https://www.developer.nokia.com/Community/Champions/

The best OS, the best devices. I feel blessed I can be of some help. Now I have to take up the challenge !

Nokia Developer Champion

Fri, 17 May 2013 13:55:46 GMT

J’ai reçu un email bien sympathique de Nokia la semaine passée : une invitation pour être Nokia Developer Champion !

Une surprise tout à fait inattendue (pléonasme), un grand merci à l’équipe de Nokia !

Mais qu’est-ce que le programme Nokia Developer Champion (NDC) ? En gros, on peut le voir comme l’équivalent Nokia du programme MVP de Microsoft. On est nommé pour un an, renouvelable.

Les avantages sont :

Reconnaissance de Nokia
Un mobile offert par an (J’attends le 925)
Un an sur le Nokia Developer Premium
Support technique
Aide à l’organisation d’événements développeurs
Invitations à des évènements Nokia

Plus d’info ici : https://www.developer.nokia.com/Community/Champions/

Le meilleur OS, les meilleurs mobiles. Je suis chanceux de pouvoir aider ! Maintenant, il faut assurer !

Developping a Lens app for Windows Phone 8

Thu, 09 May 2013 13:13:19 GMT

Some WP devices are known for their excellent camera (*hum* Lumia 920 *hum*), so let’s play a bit with a feature introduced with Windows Phone 8 : the camera lenses.

Basically, it is a software that can be called from the camera Lens page and that will (most probably) process images taken with the camera in a certain way. It can be effect like black/white, panorama composition,etc…. In fact, it is not especially different from a regular app, though. It still appears on the application list of your phone, and can be launched like any other app.

Declaring the app as Lens

In the app manifest, you must add those two capabilities : “ID_CAP_ISV_CAMERA” and “ID_CAP_MEDIALIB_PHOTO” so you can have access to the camera and the Medial Library to save images.

Open now the manifest in XML and, after the Tokens element, declare your app as Lens app with :

<Extensions>
  <Extension ExtensionName="Camera_Capture_App" ConsumerID="{5B04B775-356B-4AA0-AAF8-6491FFEA5631}" TaskID="_default" />
</Extensions>

One more thing to do, is to add the icon that will appears in the Lens page. You must add 3 icons images in the Assets directory :

Lens.Screen-720p.png (173 x 173)
Lens.Screen-WVGA.png (259 x 259)
Lens.Screen-WXGA.png (277 x 277)

If you deploy the app now and go to the Lens page, you’ll see the icon :

When your app is called from the Lens page, the OS adds “?Action=ViewfinderLaunch” to the start uri of your app (example : “Mainpage.xaml?Action=ViewfinderLaunch”. That is how you can detect if your app was launched from the Lens page or not.

If you want the user to land on different page depending of launched from Lens page or from start menu, you can do it using a custom UriMapper. For instance :

class CustomUriMapper : UriMapperBase
    {
        public override Uri MapUri(Uri uri)
        {
            string tempUri = uri.ToString();
            if (tempUri.Contains("ViewfinderLaunch"))
            {
                return new Uri("/LensPage.xaml", UriKind.Relative);
            }
            else
            {
                return uri;
            }
        }
    }

This mapper will redirect to the page LensPage.xaml if coming from the Lens page. To activate this wrapper, you can put it in the InitializePhoneApplication method in App.cs :

RootFrame.UriMapper = new CustomUriMapper();

You need now to create a new page in your project called LensPage.xaml.

Lens exemple

Now we have a Lens, app, but it doesn’t to anything…Let’s do something about that.

The example I’ll show here is a Lens app where you can see the camera feed (nothing revolutionary) and can draw on it. Then you can take a snapshot.

For the drawing part, I’ll use the InkPresenter control for the drawing, and the WriteableBitmapEx Nuget package for the image processing.

My LensPage.xaml will look like this :

<phone:PhoneApplicationPage x:Class="DrawLens.LensPage"
                            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                            xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
                            xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
                            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                            FontFamily="{StaticResource PhoneFontFamilyNormal}"
                            FontSize="{StaticResource PhoneFontSizeNormal}"
                            Foreground="{StaticResource PhoneForegroundBrush}"
                            SupportedOrientations="Landscape"
                            Orientation="Landscape"
                            mc:Ignorable="d"
                            shell:SystemTray.IsVisible="True">

    <!--LayoutRoot is the root grid where all page content is placed-->
    <Grid x:Name="LayoutRoot"
          Background="Transparent">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"></ColumnDefinition>
            <ColumnDefinition Width="*"></ColumnDefinition>
        </Grid.ColumnDefinitions>

        <StackPanel Orientation="Vertical"
                    x:Name="ButtonsSP"
                    Visibility="Collapsed">
            <Button Content="Clear"
                    Margin="10,10"
                    Width="100"
                    Click="Clear_OnClick"></Button>
            <Button Content="Save"
                    Width="100"
                    Click="Save_OnClick">
            </Button>
        </StackPanel>
        <TextBlock Text="Processing..."
                   Visibility="Visible"
                   x:Name="ProcessingLabel"></TextBlock>
        <InkPresenter Width="640"
                      Height="480"
                      MouseLeftButtonDown="TheInkPresenter_MouseLeftButtonDown"
                      LostMouseCapture="TheInkPresenter_LostMouseCapture"
                      MouseMove="TheInkPresenter_MouseMove"
                      x:Name="TheInkPresenter"
                      Grid.Column="1">
            <InkPresenter.Background>
                <VideoBrush x:Name="CameraBrush"></VideoBrush>
            </InkPresenter.Background>
        </InkPresenter>
    </Grid>

</phone:PhoneApplicationPage>

So I have two columns. One with the buttons Clear and Save and the other with an InkPresenter that has a video brush. I will stream camera feed to this brush. I will not explain how the InkPresenter is drawing the strokes, it is not the purpose of this article and it is explained in the InkPresenter link above.

First, when the page is loaded, we initialize the camera and redirect the feed to the InkPresenter videobrush background :

private PhotoCamera _camera;

public LensPage()
{
  InitializeComponent();

  this.Loaded += LensPage_Loaded;
}

void LensPage_Loaded(object sender, RoutedEventArgs e)
{
  if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary))
  {
       // Initialize camera, and show buttons only when camera ready
       _camera = new PhotoCamera(CameraType.Primary);
       // Event launched when the camera as taken a picture
       _camera.CaptureImageAvailable += _camera_CaptureImageAvailable;
        CameraBrush.SetSource(_camera);
  }

}

When the user press on the Save button, I capture an image:

private void Save_OnClick(object sender, RoutedEventArgs e)  
{
  _camera.CaptureImage();
}

When the image is captured, the camera CaptureImageAvailable event is launched. There you get the bitmap stream.

I will make a bitmap from that stream. Then I’ll take all the strokes data of the InkPresenter and redraw those strokes on the bitmap (The DrawLineBresenham method in the code is based on the WritebeableBitmapEx one and allow to draw lines thicker than 1 pixel. See source code at the end of the post). As the InkPresenter size is different than the size of the image, I compute the magnification ratio by dividing the image size by the InkPresenter size.

After drawing all the strokes, I save the bitmap to the Media Library.

Enough words, enter code :

/// <summary>
/// Called when image is available
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _camera_CaptureImageAvailable(object sender, ContentReadyEventArgs e)
{
    Dispatcher.BeginInvoke(() => CreateAndSave(e.ImageStream));
}
/// <summary>
/// Process the image
/// </summary>
/// <param name="stream"></param>
private void CreateAndSave(Stream stream)
{
    // Get bitmap from stream
    var _bitmap = new WriteableBitmap(1, 1);

    _bitmap = _bitmap.FromStream(stream);

    var width = _bitmap.PixelWidth;

    var height = _bitmap.PixelHeight;

    // Get ration between the inkpresenter size and the bitmap size
    var ratiox = width / TheInkPresenter.Width;

    var ratioy = height / TheInkPresenter.Height;

    // Draw each strokes on the bitmap
    foreach (var stroke in TheInkPresenter.Strokes)
    {
        var x1 = stroke.StylusPoints[0].X * ratiox;
        var y1 = stroke.StylusPoints[0].Y * ratioy;

        foreach (var point in stroke.StylusPoints.Skip(1))
        {
            var x2 = point.X * ratiox;

            var y2 = point.Y * ratioy;

            DrawLineBresenham(_bitmap, (int)x1, (int)y1, (int)x2, (int)y2, Colors.Red, (int)ratiox, (int)ratioy);

            x1 = x2;
            y1 = y2;
        }
    }
    // Save into library
    _bitmap.SaveToMediaLibrary("DrawLensGenerated.jpg");


    MessageBox.Show("Image saved !");
}

A pic of the lens in action :

And the result image :

The source code is here

Développer une application Lens pour Windows Phone 8

Thu, 09 May 2013 13:13:00 GMT

Certains WP sont connus pour leur excellente caméra (*hum* Lumia 920 *hum*), alors jouons un peu avec un petit truc sympa qui est apparu avec Windows Phone 8 : les camera lenses.

En gros, c’est une application qui peut être appelée depuis la page des camera lenses et qui (pas obligé, mais bon…) va retravailler les photos prises. Cela peut être une composition d'image (Photosynth est un exemple), ou juste une modification de l’image (par exemple filtre noir/blanc, ),etc…. En fait, ce n’est pas fort différent d’une application normale car une camera lens peut être lancée depuis le menu démarrer comme n’importer quelle application.

Déclarer l’application comme Lens

Pour déclarer l’application comme lens, il faut commencer par lui ajouter les capacités “ID_CAP_ISV_CAMERA” et “ID_CAP_MEDIALIB_PHOTO” afin d’avoir accès à la camera, et à Media Library pour sauver l’image.

Ouvrez maintenant le manifeste en XML et, après l’élément Tokens déclarer votre application comme lens en ajoutant :

<Extensions>
  <Extension ExtensionName="Camera_Capture_App" ConsumerID="{5B04B775-356B-4AA0-AAF8-6491FFEA5631}" TaskID="_default" />
</Extensions>

Encore une chose à faire : ajouter les icônes qui apparaitrons dans la page des lens. Il faut ajouter 3 icones dans le répertoire Assets :

Lens.Screen-720p.png (173 x 173)
Lens.Screen-WVGA.png (259 x 259)
Lens.Screen-WXGA.png (277 x 277)

Si vous déployez l’application et que vous allez sur la page lens, vous verrez votre icône apparaitre :

Quand votre application est appelée depuis la page lens, l’OS ajoute “?Action=ViewfinderLaunch” à l’uri de votre page de départ. (exemple : “Mainpage.xaml?Action=ViewfinderLaunch”. C’est grâce à ça que vous pouvez savoir d’où l’application à été lancée.

Si vous voulez que l’utilisateur arrive sur une page différente suivant la façon dont il a lancé l’application, vous pouvez le faire via un UriMapper. Par exemple :

class CustomUriMapper : UriMapperBase
    {
        public override Uri MapUri(Uri uri)
        {
            string tempUri = uri.ToString();
            if (tempUri.Contains("ViewfinderLaunch"))
            {
                return new Uri("/LensPage.xaml", UriKind.Relative);
            }
            else
            {
                return uri;
            }
        }
    }

Ce mapper va rediriger vers la page LensPage.xaml si l’application à été lancée depuis la page lens. Pour utiliser ce mapper, vous pouvez ajouter cette ligne dans la méthode InitializePhoneApplication de App.cs :

RootFrame.UriMapper = new CustomUriMapper();

Il faut bien évidemment rajouter la page LensPage.xaml au projet.

Un exemple de lens

Nous avons maintenant une application Lens qui ne fait rien…Attaquons-nous à ce problème.

L’exemple que je vais montrer ici est une application lens ou vous pouvez voir le flux caméra (rien d’extraordinaire) et vous pouvez dessiner dessus. Après vous pouvez sauver l’image.

Pour la parie dessin, j’utilise le contrôle InkPresenter et le package nuget WriteableBitmapEx pour le traitement de l’image.

Ma LensPage.xaml ressemble à ceci :

<phone:PhoneApplicationPage x:Class="DrawLens.LensPage"
                            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                            xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
                            xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
                            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                            FontFamily="{StaticResource PhoneFontFamilyNormal}"
                            FontSize="{StaticResource PhoneFontSizeNormal}"
                            Foreground="{StaticResource PhoneForegroundBrush}"
                            SupportedOrientations="Landscape"
                            Orientation="Landscape"
                            mc:Ignorable="d"
                            shell:SystemTray.IsVisible="True">

    <!--LayoutRoot is the root grid where all page content is placed-->
    <Grid x:Name="LayoutRoot"
          Background="Transparent">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"></ColumnDefinition>
            <ColumnDefinition Width="*"></ColumnDefinition>
        </Grid.ColumnDefinitions>

        <StackPanel Orientation="Vertical"
                    x:Name="ButtonsSP"
                    Visibility="Collapsed">
            <Button Content="Clear"
                    Margin="10,10"
                    Width="100"
                    Click="Clear_OnClick"></Button>
            <Button Content="Save"
                    Width="100"
                    Click="Save_OnClick">
            </Button>
        </StackPanel>
        <TextBlock Text="Processing..."
                   Visibility="Visible"
                   x:Name="ProcessingLabel"></TextBlock>
        <InkPresenter Width="640"
                      Height="480"
                      MouseLeftButtonDown="TheInkPresenter_MouseLeftButtonDown"
                      LostMouseCapture="TheInkPresenter_LostMouseCapture"
                      MouseMove="TheInkPresenter_MouseMove"
                      x:Name="TheInkPresenter"
                      Grid.Column="1">
            <InkPresenter.Background>
                <VideoBrush x:Name="CameraBrush"></VideoBrush>
            </InkPresenter.Background>
        </InkPresenter>
    </Grid>

</phone:PhoneApplicationPage>

J’ai donc deux colonnes. Une avec les boutons Clear et Save, et l’autre avec un contrôle InkPresenter. Ce contrôle à une VideoBrush comme image de fond. Je vais rediriger le flux vidéo vers ce VideoBrush. Je ne parlerais pas du contrôle InkPresenter et de comment l’utiliser, ce n’est pas le but de l’article et tout est expliqué dans le lien que j’ai donné précédemment.

Premièrement, quand la page est chargé, j’initialise la camera et je redirige le flux vers le VideoBrush de fond du InkPresenter videobrush :

private PhotoCamera _camera;

public LensPage()
{
  InitializeComponent();

  this.Loaded += LensPage_Loaded;
}

void LensPage_Loaded(object sender, RoutedEventArgs e)
{
  if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary))
  {
       // Initialize camera, and show buttons only when camera ready
       _camera = new PhotoCamera(CameraType.Primary);
       // Event launched when the camera as taken a picture
       _camera.CaptureImageAvailable += _camera_CaptureImageAvailable;
        CameraBrush.SetSource(_camera);
  }

}

Quand l’utilisateur presse le bouton Save, je capture une photo:

private void Save_OnClick(object sender, RoutedEventArgs e)  
{
  _camera.CaptureImage();
}

Quand l’image est capture, l’évènement CaptureImageAvailable est lancé par l’objet camera. C’est là qu’on récupère un Stream de l’image.

Je vais créer un Bitmap de ce Stream. Puis je rajoute un à un les Strokes qui ont étés tracées sur le InkPresenter. (La méthode DrawLineBresenham utilisée dans le code est une version maison de celle de WritebeableBitmapEx qui permet de dessiner des lignes de plus de 1 pixel d’épaisseur. Voir le code source donné en fin d’article). Comme la taille du InkPresenter est différente de la taille de l’image prise, je calcule un ratio d’agrandissement en divisant la taille de l’image par celle du InkPresenter.

Après avoir redessiné les Strokes, je sauve l’image dans la Media Library.

Assez de discours, place au code :

/// <summary>
/// Called when image is available
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _camera_CaptureImageAvailable(object sender, ContentReadyEventArgs e)
{
    Dispatcher.BeginInvoke(() => CreateAndSave(e.ImageStream));
}
/// <summary>
/// Process the image
/// </summary>
/// <param name="stream"></param>
private void CreateAndSave(Stream stream)
{
    // Get bitmap from stream
    var _bitmap = new WriteableBitmap(1, 1);

    _bitmap = _bitmap.FromStream(stream);

    var width = _bitmap.PixelWidth;

    var height = _bitmap.PixelHeight;

    // Get ration between the inkpresenter size and the bitmap size
    var ratiox = width / TheInkPresenter.Width;

    var ratioy = height / TheInkPresenter.Height;

    // Draw each strokes on the bitmap
    foreach (var stroke in TheInkPresenter.Strokes)
    {
        var x1 = stroke.StylusPoints[0].X * ratiox;
        var y1 = stroke.StylusPoints[0].Y * ratioy;

        foreach (var point in stroke.StylusPoints.Skip(1))
        {
            var x2 = point.X * ratiox;

            var y2 = point.Y * ratioy;

            DrawLineBresenham(_bitmap, (int)x1, (int)y1, (int)x2, (int)y2, Colors.Red, (int)ratiox, (int)ratioy);

            x1 = x2;
            y1 = y2;
        }
    }
    // Save into library
    _bitmap.SaveToMediaLibrary("DrawLensGenerated.jpg");


    MessageBox.Show("Image saved !");
}

Une image de l’application en action :

Et le résultat :

Le code source est ici

Awaitable WCF calls with TaskCompletionSource

Fri, 03 May 2013 07:10:55 GMT

A nice little gem of the TPL is the TaskCompletionSource<T>. It creates a Task<T> you can control from outside the task.

Example :

I create a new TaskCompetionSource<bool> :

var tcs = new TaskCompletionSource<CompositeType>();

I get the Task<bool> from it :

tcs.Task

I can set the Task result this way :

tcs.TrySetResult(true);

You can set an exception like this :

tcs.TrySetException(new Exception("This is an error"));

Or cancel it:

tcs.TrySetCanceled();

OK…So what ?

It doesn’t sound very interesting, does it?

Well it can become quite useful with WCF if you can’t have awaitable calls (Like on Windows Phone, for instance).

You can make any of those WCF calls awaitable like this :

private Task<CompositeType> CallService()
        {

            var tcs = new TaskCompletionSource<CompositeType>();

            var client = new ServiceReference1.Service1Client();

            client.GetDataUsingDataContractCompleted += (o, args) =>
                                                            {
                                                                if (args.Error != null)
                                                                {
                                                                    tcs.TrySetException(args.Error);
                                                                    return;
                                                                }
                                                                if (args.Cancelled)
                                                                {
                                                                    tcs.TrySetCanceled();
                                                                    return;
                                                                }

                                                                tcs.TrySetResult(args.Result);
                                                            };

            client.GetDataUsingDataContractAsync(new CompositeType());

            return tcs.Task;
        }

What I do is creating a TaskCompletionSource of the service return type.

In the service callback event, I set the TaskCompletionSource depending on the service result.

Now I just have to call the service, and to return the TaskCompletion Task.

That method created is awaitable, so you can call it that way :

var result = await CallService();

Et voilà, now you can make WCF awaitable calls ! And it works with any call that has this callback event pattern.

Appels WCF Awaitable avec TaskCompletionSource

Fri, 03 May 2013 07:10:54 GMT

Un petit joyau de la TPL est TaskCompletionSource<T>. Cela crée une Task<T> qui peut être contrôlée en dehors de cette tâche.

Exemple :

Je crée un TaskCompetionSource<bool> :

var tcs = new TaskCompletionSource<CompositeType>();

Je peux avoir la tâche Task<bool> associée :

tcs.Task

Je peux définir le résultat de la tâche de cette façon :

tcs.TrySetResult(true);

Je peux lui faire lancer une exception :

tcs.TrySetException(new Exception("This is an error"));

Ou l’annuler:

tcs.TrySetCanceled();

OK…Et alors ?

Vu comme ça, ça ne semple pas trop excitant…

Mais ça peut devenir intéressant si vous avez des appels services WCF qui ne sont pas awaitable (Comme sur Windows Phone, par exemple)

Voici une façon de rendre ces appels awaitable :

private Task<CompositeType> CallService()
        {

            var tcs = new TaskCompletionSource<CompositeType>();

            var client = new ServiceReference1.Service1Client();

            client.GetDataUsingDataContractCompleted += (o, args) =>
                                                            {
                                                                if (args.Error != null)
                                                                {
                                                                    tcs.TrySetException(args.Error);
                                                                    return;
                                                                }
                                                                if (args.Cancelled)
                                                                {
                                                                    tcs.TrySetCanceled();
                                                                    return;
                                                                }

                                                                tcs.TrySetResult(args.Result);
                                                            };

            client.GetDataUsingDataContractAsync(new CompositeType());

            return tcs.Task;
        }

Je crée d’abord un TaskCompletionSource<T> du type de retour du service.

Dans l’événement callback du service, je la défini l’état de la TaskCompletionSource en fonction du résultat de l’appel.

Maintenant, je n’ai plus qu’à appeler le service lui-même et renvoyer la Task<T> liée à la TaskCompletionSource.

La méthode ainsi crée est, vous pouvez donc l’appeler comme ça :

var result = await CallService();

Et voilà, vous pouvez maintenant faire des appels WCF awaitable ! Cette méthode marche aussi avec n’importe quel appel qui à ce pattern de de callback par évènement.

Windows Phone 8 Push Notifications Callback

Tue, 16 Apr 2013 09:42:00 GMT

Attention: Le team WP m’a prévenue qu’ils ont l’intention de rentre les callback obsolètes. Je ne peux donner aucune date, mais leur utilisation est découragée par Microsoft.

Alors pourquoi cet article? Tout simplement parce que je l’avais déjà presque fini quand j’ai contacté MS pour un détail et qu’ils m’ont annoncé qu’ils ont l’intention d’abandonner les callback. Et je ne voulais pas perdre le travail déjà accompli…

Une option pas très connue (ni fort utilisée, de ce fait…) des notifications push authentifiées et la possibilité d’avoir un callback qui est appelé lorsque que le serveur WPNS détecte que l’appareil est déconnecté (Perte de réseau, par exemple).

Quand le WPNS détecte la déconnection, il envoie (Après un timeout qui peut être choisi) une requête POST vers un URL spécifique, avec un payload spécifique, le tout déterminé lorsque vous avez registré le callback.

Registrer le callback

Pour registrer un callback sur un channel, il faut juste envoyer une requête au WPNS. Requête similaire à une notification push, excepté :

Dans le header "X-CallbackURI”, il faut mettre l’URL de channel auquel le callback va se rapporter, avec “/callback” à la fin.
Dans le header “X-CallbackTimeout” vous pouvez mettre un timeout (en minute) après lequel le callback sera appellé. (Optionnel, par défaut le timeout est de 90 minutes. Le maximum est de 24h).
Dans le body de la requête, vous pouvez mettre un payload, qui sera envoyé au callback. Ce payload est limité à 1k.
Le payload est soit du texte, soit du binaire.

Un exemple

Voila la classe qui représente le payload que je veux envoyer:

public class PhoneInfo
{
  public int ID { get; set; }

  public string DeviceID { get; set; }

  public string DeviceModel { get; set; }

  public DateTime InactiveTime { get; set; }

}

Et voila un exemple de registration de callback utilisant JSON.NET pour la sérialisation :

(remarque : channel est de type Uri et est le channel de notification. La registration se passe idéalement lorsque le téléphone envoie le channel vers un web service pour commencer à recevoir les notifications)

var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);

store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);

var certificate = store.Certificates.Find(X509FindType.FindByThumbprint, Thumbprint, false)[0];

store.Close();


try
{
  // Serialize an object to JSON
  var infojsonstring = JsonConvert.SerializeObject(info);

  // Encode JSON to a byte array
  var encoding = new UTF8Encoding();

  var infojsonbytes = encoding.GetBytes(infojsonstring);

  // The cloud service must append "/callback" to the notification channel URI.  
  var callbackURI = channel.OriginalString + "/callback";

  // The URI to post the set callback request to.
  // CHANGE WITH YOUR URL
  var callbackUri = string.Format("http://{0}/MvcApplication/api/Notifications/CallbackMethod", Website);

  // Create a web request to send the register callback request to the Push Notification Service.
  var webRequest = (HttpWebRequest)WebRequest.Create(callbackURI);

  // Add the certificate because it is authenticated push notification
  webRequest.ClientCertificates.Add(certificate);

  // A mandatory custom header that specifies the URI to post the callback message to when any registered event with the associated subscription triggers.
  webRequest.Headers.Add("X-CallbackURI", callbackUri);

  // Set timeout to 1 minute
  webRequest.Headers.Add("X-CallbackTimeout", "1");

  // HTTP POST is the only allowed method to send the notification.
  webRequest.Method = "POST";

  // Sets the web request content length.
  webRequest.ContentLength = infojsonbytes.Length;

  // Set the content type according to the type of callback message being sent.
  webRequest.ContentType = "application/*";

  // Set the body
  using (Stream requestStream = webRequest.GetRequestStream())
  {
    requestStream.Write(infojsonbytes, 0, infojsonbytes.Length);
  }

  // Get the response. This example gets the web response synchronously, but a cloud service can get it asynchronously as well.
  var response = (HttpWebResponse)webRequest.GetResponse();

  // Ensure that the 'HTTP 200 OK' response is received from the Push Notification Service.
  Debug.Assert(response.StatusCode == HttpStatusCode.OK);

}
catch (Exception e)
{
  Console.WriteLine(e);
}

Exemple de Callback

Je vais utiliser ASP.NET MVC 4 Web API (On peut pas trouver plus long ?) pour le callback. Comme les Web API sont REST, c’est parfait pour un callback.

[HttpPost]
public void CallbackMethod(HttpRequestMessage request)
{
  try
  {
    // Read body
    var readtask = ControllerContext.Request.Content.ReadAsStringAsync();

    readtask.Wait();

    if (readtask.IsFaulted)
      throw readtask.Exception;

    // Deserialize
    var info = JsonConvert.DeserializeObject<PhoneInfo>(readtask.Result);

    // Check if null
    if (info == null)
      throw new NullReferenceException("Info is null");

    // Do your stuff

  }
  catch (Exception e)
  {
    // Manage exception
  }
}

Remarques

Cela ne fonctionne qu’avec des channels sécurisés (Voir ce post sur les notifications authentifiées)
Si vous registrez un callback plusieurs fois sur un même channel, seul le dernier sera actif.
Quand le téléphone se reconnecte, il faut de nouveau registrer le callback.
Vous pouvez connaitre l’état du channel et envoyant une notification et en regardant la valeur du header “X-DeviceConnectionStatus” dans la réponse. Si la valeur est “TempDisconnected”, le callback sera lancé (après le timeout)
La façon la plus facile de tester est de mettre le timeout à une minute et simuler une perte de réseau avec le Simulation Dashboard :

Conclusion

Dommage que le WPNS ne transmet pas le header Content-Type au callback, ça aurait été plus simple pour écrire des callbacks comme :

public void CallbackMethod(PhoneInfo info)

J’ai crée un projet exemple, téléchargeable ici

Ce que vous devez faire : changer le certificat pour les notification authentifiées, l’URL de votre web service et l’URL du callback. Comme le callback est appelé par WPNS, il doit , bien évidemment, être appelable depuis internet.

Un grand merci à l’équipe WP pour son aide, en particulier Adam, Karan and Scott

Windows Phone 8 Push Notifications Callback

Tue, 16 Apr 2013 09:42:00 GMT

WARNING : The WP team warned me that they plan to deprecated this feature. I cannot give any timeframe, but the usage is discouraged by Microsoft.

So why did I made this article ? Well because it was written before I contacted the WP team for some details and they told me it will be deprecated. And I didn’t want to lose the work I’ve already done.

A little known (and little used) feature of the authenticated push notifications on WP is the ability to have a callback called when the push notification channel of a device get disconnected (In case of loss of network, for instance).

So when the WPNS detects your device is disconnected, it will send a POST request (after a timeout you can set) to a specific URL you registered as callback, with a payload you gave it during the registration.

Registering the callback

To register a callback, you have to send a request to the WPNS, similar as a regular push request except :

In the "X-CallbackURI” header, you must set the notification channel you want to add callback to, with “/callback” at the end.
In the “X-CallbackTimeout” header, you can enter a timeout (in minutes) to set how many minutes after the disconnection the callback will be called (The default is 90 minutes. The maximum is 24 hours).
In the request body, you can put the payload it will be forwarded to the callback. The only limitation is the payload can be 1k maximum.
The payload is either text or binary.

An example

Let’s say the payload I want to send to the call back is this class :

public class PhoneInfo
{
  public int ID { get; set; }

  public string DeviceID { get; set; }

  public string DeviceModel { get; set; }

  public DateTime InactiveTime { get; set; }

}

Here is how to set everything up, using JSON.NET for the serialization :

(Note : channel is of type Uri. It is most convenient to make the callback registration in your web service when the device sends you the channel it is registered to).

var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);

store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);

var certificate = store.Certificates.Find(X509FindType.FindByThumbprint, Thumbprint, false)[0];

store.Close();


try
{
  // Serialize an object to JSON
  var infojsonstring = JsonConvert.SerializeObject(info);

  // Encode JSON to a byte array
  var encoding = new UTF8Encoding();

  var infojsonbytes = encoding.GetBytes(infojsonstring);

  // The cloud service must append "/callback" to the notification channel URI.  
  var callbackURI = channel.OriginalString + "/callback";

  // The URI to post the set callback request to.
  // CHANGE WITH YOUR URL
  var callbackUri = string.Format("http://{0}/MvcApplication/api/Notifications/CallbackMethod", Website);

  // Create a web request to send the register callback request to the Push Notification Service.
  var webRequest = (HttpWebRequest)WebRequest.Create(callbackURI);

  // Add the certificate because it is authenticated push notification
  webRequest.ClientCertificates.Add(certificate);

  // A mandatory custom header that specifies the URI to post the callback message to when any registered event with the associated subscription triggers.
  webRequest.Headers.Add("X-CallbackURI", callbackUri);

  // Set timeout to 1 minute
  webRequest.Headers.Add("X-CallbackTimeout", "1");

  // HTTP POST is the only allowed method to send the notification.
  webRequest.Method = "POST";

  // Sets the web request content length.
  webRequest.ContentLength = infojsonbytes.Length;

  // Set the content type according to the type of callback message being sent.
  webRequest.ContentType = "application/*";

  // Set the body
  using (Stream requestStream = webRequest.GetRequestStream())
  {
    requestStream.Write(infojsonbytes, 0, infojsonbytes.Length);
  }

  // Get the response. This example gets the web response synchronously, but a cloud service can get it asynchronously as well.
  var response = (HttpWebResponse)webRequest.GetResponse();

  // Ensure that the 'HTTP 200 OK' response is received from the Push Notification Service.
  Debug.Assert(response.StatusCode == HttpStatusCode.OK);

}
catch (Exception e)
{
  Console.WriteLine(e);
}

Callback example

I will use ASP.NET MVC 4 Web API (Could this name be longer ?) as callback. Web API are REST Api, so it fits perfectly for a callback

[HttpPost]
public void CallbackMethod(HttpRequestMessage request)
{
  try
  {
    // Read body
    var readtask = ControllerContext.Request.Content.ReadAsStringAsync();

    readtask.Wait();

    if (readtask.IsFaulted)
      throw readtask.Exception;

    // Deserialize
    var info = JsonConvert.DeserializeObject<PhoneInfo>(readtask.Result);

    // Check if null
    if (info == null)
      throw new NullReferenceException("Info is null");

    // Do your stuff

  }
  catch (Exception e)
  {
    // Manage exception
  }
}

Some remarks

It only works with authenticated push notifications (See this blog post on how to set that up)
If you set the callback several times, only the last one will be taken into account
When the device is active again, you should re-register the callback
You can know the channel current status by sending a notification and check the value of the “X-DeviceConnectionStatus” header in the response. If the value is “TempDisconnected”, the callback will be called after the timeout.
Easiest way to test is to set the timeout to 1 minute, and simulate a loss of network using the Simulation Dashboard :

Conclusion

Too bad you can’t tell the WPNS to forward the Content-Type header to the callback, it would have be easier to write Web API like this :

public void CallbackMethod(PhoneInfo info)

I made a sample project you can download here

What you have to change is your certificate (for the authenticated push notification), the URL of the web service registering the callback and the callback URL. As the callback is called by the WPNS, your callback URL must be, of course, accessible from internet.

Special thanks to the WP team for its help, especially Adam, Karan and Scott

One more year !

Thu, 04 Apr 2013 09:09:11 GMT

Good news beginning of this month! Most important, I got this April 1st (and it’s not a joke ):

Je tiens à nouveau à t’adresser personnellement toutes mes félicitations pour ton renouvellement au programme Microsoft® Most Valuable Professional!

Je suis ravie de passer une nouvelle année à tes côtés, et tiens à te remercier de tes nombreuses contributions communautaires, et de l'aide que tu apportes tout au long de l'année aux utilisateurs des produits Microsoft.

Yes! MVP one more year! Thanks to everybody that supported me!

The other news is the //build/ conference. It was a surprise announcement. And a surprising date also, in June. Same time as TechEd Europe. Lucky me, I was just skipping this one…

I managed to get a ticket. The first //build/ was amazing. The second one was good, but was also a bit disappointment because I hoped we’ll get more interaction with MS teams since it was on campus.

So, what will be the giveaway this time? My ideas: a new 7” (or 8”) Windows Blue tablet or a new Nokia device (Or even a Surface Phone?) or maybe a Durango (XBox 720) dev kit? We’ll see!

Un an de plus !

Thu, 04 Apr 2013 09:09:11 GMT

De bonnes nouvelles ce début de mois ! La plus importante, j’ai reçu cet email le 1er avril (sans blagues!):

Je tiens à nouveau à t’adresser personnellement toutes mes félicitations pour ton renouvellement au programme Microsoft® Most Valuable Professional!

Yes! MVP un an de plus! Merci à tous ceux qui m’ont soutenus !

L’autre nouvelle est la conférence //build/. Elle a été annoncée par surprise. Et à une date surprenante aussi : fin juin. En même temps que le techEd Europe, heureusement que j’avais décidé de passer mon tour cette fois-ci!

J’ai réussi à avoir un ticket. Le premier //build/ était fantastique. Le second était bon, mais un peu décevant parce que j’espérais plus d’interaction avec les équipes MS vu qu’on était sur le campus.

La grande question…le cadeau ? Mes idées : une nouvelle tablette Windows Blue 7” (ou 8”) ou un nouveau Nokia (Rêvons : un Surface Phone?) ou bien peut-être une kit développeur Durango (XBox 720)? On verra!

Async/Await with WCF

Sun, 31 Mar 2013 18:53:04 GMT

A nice little feature of .NET 4.5 is you can use async await with WCF ! The services doesn’t need to be in .NET 4.5, only the client as it is in the proxy.

When you add your service reference be sure to check if the task bases asynchronous operations will be generated by the proxy.

Click on advanced

And check what kind of asynchronous operation will be generated.

So you can call your WCF that way :

private async Task<string> TestAsyncWCF()
{
        var service = new ServiceReference1.Service1Client();

        var response =  await service.GetDataAsync(10);

        Debug.WriteLine(response);

        return response.ToUpper();
}

Goodbye callbacks, it was nice knowing you…

Note : it doesn’t work with WP8

Async/Await avec WCF

Sun, 31 Mar 2013 18:53:04 GMT

Un petit truc sympa de .NET 4.5 est qu’on peut utiliser async await avec WCF ! Les services n’ont pas besoin d’être en .NET 4.5, seulement le client, vu que ça se passe dans le proxy.

Quand vous ajoutez la référence à votre service, vérifiez si les opérations asynchrones générées sont de type Task.

Clicquer sur advanced

Et regardez quel type d’opération asynchrone sera générée.

Après, vous pouvez appeler les services comme ça :

private async Task<string> TestAsyncWCF()
{
        var service = new ServiceReference1.Service1Client();

        var response =  await service.GetDataAsync(10);

        Debug.WriteLine(response);

        return response.ToUpper();
}

Au revoir callbacks, content de vous avoir connu…

Note : ça ne marche pas avec WP8

Belgian super hackathon

Mon, 18 Mar 2013 11:22:23 GMT

Around Belgium the 27th of March ? Enjoy developping Windows 8 app ? Want to win a ticket to Teched Europe 2013 in Madrid ?

Is it a dream ? No, it is :

4 cities ! No excuses !

I’ll be at the Brussels one, day and night. See you there !

http://www.microsoft.com/belux/msdn/apps/windows/superhack.aspx

Super hackathon Belgique

Mon, 18 Mar 2013 11:22:23 GMT

En Belgique le 27 mars ? Tu aimes développer pour Windows 8 ? Tu voudrais gagner un ticket pour le Teched Europe 2013 à Madrid ?

Est-ce un rêve ? Non, c’est :

4 villes! Aucunes excuses !

Je serais à Bruxelles, le jour et la nuit. A bientôt !

http://www.microsoft.com/belux/msdn/apps/windows/superhack.aspx

2013 MVP Summit

Mon, 04 Mar 2013 20:57:11 GMT

Last week (Feb 18th to Feb 21st) the 2013 MVP Summit was held in Redmond and Bellevue. It was the 20th anniversary of the MVP program and we were around 1400 MVPs from all around the world. We were introduced to MVPs that were amongst the first to be awarded. 20 years as MVP, hard to imagine for me, as it is only my first year!

What can you except at the Summit? Well…Information (Under NDA most of the time), networking (With PG or other MVPs) and, very important, FUN! We had great interaction with the teams, so we can provide them face to face feedbacks.

Reception on the first day… Brazil was in the place !

It is a great time, hanging around with the MS team and all those MVPs. I felt like walking amongst the gods (Like a fellow MVP told me)!

Basically the sessions are held on the Bellevue Hyatt conference center, or in the Microsoft Campus. All the C# sessions were on the Hyatt. Quite convenient, as I was staying there. But too bad I didn’t had time to go to the Campus. I was there during the Build 2012, and I hope I’ll have the chance to go there again next Summit. Alway nice to visit THE place where everything is created.

Most of sessions are NDA, so I can’t tell anything except some BIG things are coming for C# and Windows Phone. Stay tuned for the official announcements.

During the Summit Party, at Century Field, we had chance to network and also do some sport (A healthy mind in a healthy body)

Firework @ Century Field The Field itself, with the activities

Live karaoke In case you didn’t know…MVPs are here!

I would like to say a big hello to some fellas I met over there: Jonathan, Samuel, Kevin, Jason, Joost, Rob, Martine,etc…. You know who you are! And a though also for Loïc who, at the last moment, couldn’t join us. Hope to see you all next year!

More info/photos on the official MVP Award blog or the 2013 MVP Summit website or the facebook group of the french speaking MVPs at the Summit

I will put more pics/video on mu flickr account later

2013 MVP Summit

Mon, 04 Mar 2013 20:57:11 GMT

La semaine passée (Du18 au 21février) se tenait, à Redmond et Bellevue le MVP Summit 2013. C’était le 20eme anniversaire du programme, et nous étions environs 1400 MVPs venu des 4 coins du monde. Nous avons eu l’occasion de féliciter des MVP qui faisaient partie de la première fournée. 20 ans comme MVP, ça en jette…

Qu’est-ce qu’on peut attendre du Summit ? Et bien…Des informations (Bien souvent sous NDA), du networking (avec les PG ou d’autres MVPs) et, tout aussi important, du fun ! Nous avons eu l’occasion d’avoir des échanges intéressants avec les teams. C’est important de pouvoir leur donner du feedback en personne.

Réception le premier jour Le brésil est dans la place !

C’est vraiment très sympa, de se retrouver avec tous ces MVPs et les teams MS. On se sent près des dieux (comme me l’a dit un autre MVP ;) )!

Les sessions ont mieux au Hyatt Bellevue, ou sur le campus de Microsoft. Toutes mes sessions étaient au Hyatt. Pratique, vu que je logeais là, mais je n’ai donc pas pu aller au Campus. J’y étais déjà pour le Build 2012 mais j’aurai aimé revenir (C’est quand même le centre du monde !). Pour l’année prochaine…

Les plupart des sessions étant NDA, je ne peux rien dire sinon qu’il y a du lourd qui arrive pour VS, C# et Windows Phone. Il n’y a plus qu’à attendre l’annonce officielle.

Pendant la traditionnelle fête, au Century Field, nous avons eu l’occasion de (encore) faire du networking, ainsi qu’un peu de sport (Un esprit sain dans un corps sain)

Feux d’artifices @ Century Field Le terrain, avec les activités

Live karaoke Au cas ou vous ne le saviez pas…Les MVPs sont là !

J’en profite pour faire un petit “hello” à tous ceux que j’ai rencontré au Summit : Jonathan, Samuel, Kevin, Jason, Joost, Rob, Martine,etc…. Vous vous reconnaitrez ! Une pensée aussi pour Loïc qui, au dernier moment, n’a pas pu nous rejoindre.

Plus d’infos/photos sur le blog officiel MVP Award ou sur le site 2013 MVP Summit ou encore la page facebook des MVPs francophones au Summit

Je mettrais plus de photos/vidéos sur mon compte FlickR plus tard.

Windows Phone authenticated push notifications

Thu, 07 Feb 2013 14:38:26 GMT

There are 2 limitation of the basic push notifications on windows phone :

Limited to 500 notifications per day per subscription (which should be ok for most of us)
Notification is not encrypted

If you want to lift those limitations, you need to use authenticated push notifications.

There are 5 steps to follow :

Buy a certificate
Install the certificate on the server that will send the notifications
Send the certificate to the Windows Phone Dev Center
Register a secure channel (Client side)
Send a secure notification (server side)

Let’s detail it one by one. (I will use the sample from my Raw Notification article as support, but it can be used with any type of notification)

Buy a certificate

You need to buy a certificate from selected vendor. The list is here (I personally went with GoDaddy). You need to buy from them, as their root certificate are pre-installed on all phones.

Send the certificate to the Windows Phone Dev Center

Once you uploaded it, it is valid for 4 months. Once you register an app using it, you can link the app to the certificate (When submitting an app, go to App info, expand More Options and you can select your certificate in the MPNS combobox). It will then become permanent.

Install the certificate on your server

Launch MMC, go to File/Add Remove Snap-In and add the Certificate (Local Machine) one (It is better to install it machine-wide).

Then in Personnal/Certificates, right click and choose All Tasks/Import.

Import the private key with it. I am not totally sure if it is needed, but I made the private key exportable.

Register a secure channel (Client side)

That is very simple. When registering the channel, pass a second parameter. This parameter is the CN name of your certificate. Example :

channel = new HttpNotificationChannel(_channelName, "www.equinoxe-consulting.net");

Now your notification channel should start with HTTPS and have “unthrottled” in it.

Send a secure notification (Server side)

It is the same as sending a notification except you send the certificate (with its private key) with the notification request.

Example getting the certificate from the store

var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);

store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);

// Change with your certificate thumbprint
var certificate = store.Certificates.Find(X509FindType.FindByThumbprint, "F8132A5AAB52469A0B8962FE1E01E2CB0AB64137", false)[0];

store.Close();

Once you have it, you send it with the request using the method ClientsCertificates.Add() :

 var sendNotificationRequest = (HttpWebRequest)WebRequest.Create(uri);

sendNotificationRequest.Method = "POST";

// add the certificate
sendNotificationRequest.ClientCertificates.Add(certificate);

// Set the notification payload to send.
var notificationMessage = Encoding.Default.GetBytes(rawMessage);

// Set the web request content length.
sendNotificationRequest.ContentLength = notificationMessage.Length;
sendNotificationRequest.ContentType = "text/xml";
sendNotificationRequest.Headers.Add("X-NotificationClass", "3");


using (var requestStream = sendNotificationRequest.GetRequestStream())
{   
   requestStream.Write(notificationMessage, 0, notificationMessage.Length);
}

// Send the notification and get the response.
var response = (HttpWebResponse)sendNotificationRequest.GetResponse();

And it’s done! The client should receive a notification. And since the channel uri is using HTTPS and has “unthrottled” in it, it is a secure one.

Troubleshouting

I spent lot of time on a stupid thing.

When I tried to send the notification request from the server, I had an HTTPRequestException:

The request was aborted: Could not create SSL/TLS secure channel

Not much information…So I checked in the Windows Event Viewer and I saw this :

Have error in event viewer schannel, event id 36888 the following fatal alert was generated 80. the internal error state is 301

OK…are we getting closer ?

After some time I realized that, in debug, when I tried to get the certificate private key with the PrivateKey property I got a

System.Security.Cryptography.CryptographicException with a message saying that the provider is not correct.

That is where I though about the security permissions…

There is a nice util where you can check/modify the permissions on the certificates : WinHTTPCertCfg

You can check the permissions that way (in an admin command line) :

WinHttpCertCfg.exe -l -c LOCAL_MACHINE\MY -s "www.equinoxe-consulting.net"

Then I got this :

The user my web service was using (.NET v4.5) has no right on the certificate. To add it :

WinHttpCertCfg.exe -g -c LOCAL_MACHINE\MY -s "www.equinoxe-consulting.net" -a ".NET v4.5"

And then everything went ok…

Conclusion

I made a sample app (well it is the authenticated version of the Raw Notification sample) here.

As with the original sample, you have to change the WCF service IP with your own on the client app and let the emulator connect to your host (check here). You also have to change the certificate CN and Thumbprint with your own.

Windows Phone notifications push authentifiées

Thu, 07 Feb 2013 14:38:26 GMT

Les notifications push de Windows Phone ont deux grandes limitations :

Maximum 500 notifications par jour par souscription (Ce qui, en général, est suffisant)
Les notifications ne sont pas encryptées

Pour supprimer ces limitations, il faut passer aux notifications push authentifiées.

Pour y arriver, il y a 5 étapes :

Acheter un certificat
Installer le certificat sur le serveur qui va envoyer les notifications
Installer le certificat sur son compte dans le Windows Phone Dev Center
Registrer un channel sécurisé (Côté client)
Envoyer une notification sécurisée (Côté serveur)

Voyons ça en détail. (Je vais utiliser mon article précédent sur les notifications raw comme support, mais c’est valable pour tous types de notifications)

Acheter un certificat

Vous devez acheter un certificat chez un vendeur dont le certificat root est préinstallé par défaut sur tous les Windows Phone. La liste est ici. (Perso je suis chez GoDaddy).

Installer le certificat sur le Windows Phone Dev Center

Dans le Dev Center, allez sur votre dashboard. Après, il faut aller sur Account/Certificate. Vous pouvez alors uploader le certificat.

Une fois uploadé, le certificat est valide pour 4 mois. Une fois que vous avez soumis une application qui utilise ce certificat, celui-ci devient valide indéfiniment. Pour lier une app à un certificat, quand vous soumettez l’app, allez dans App info et, dans la partie More Options vous pouvez sélectionner le certificat dans le combobox MPNS.

Installer le certificate sur votre serveur

Lancer MMC, puis File/Add Remove Snap-In et ajouter Certificate (Local Machine) (Il vaut mieux installer le certificat dans le magasin machine que dans celui de l’utilisateur)

Après dans Personnal/Certificates, clique droit et choisir All Tasks/Import.

Importer la clé privée avec. Je ne suis pas sûr que ce soit nécessaire, mais j’ai aussi sélectionné « rendre la clé exportable ».

Registrer un channel sécurisé (Côté client)

Simple. Il suffit, lors de la création du channel, de passer le paramètre CN du certificat. Exemple :

That is very simple. When registering the channel, pass a second parameter. This parameter is the CN name of your certificate. Example :

channel = new HttpNotificationChannel(_channelName, "www.equinoxe-consulting.net");

L’URI du channel devrait commencer par HTTPS et avoir “unthrottled” dedans.

Envoyer une notification sécurisée (Côté serveur)

En gros, c’est la même chose que l’envoi d’une notification “normale”, excepté qu’il faut envoyer le certificat (avec sa clé privée) avec la requête.

Un exemple de récupération du certificat :

var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);

store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);

// Change with your certificate thumbprint
var certificate = store.Certificates.Find(X509FindType.FindByThumbprint, "F8132A5AAB52469A0B8962FE1E01E2CB0AB64137", false)[0];

store.Close();

Une fois que vous l’avez, il faut l’envoyer avec la requête au moyen de la méthode ClientsCertificates.Add() :

 var sendNotificationRequest = (HttpWebRequest)WebRequest.Create(uri);

sendNotificationRequest.Method = "POST";

// add the certificate
sendNotificationRequest.ClientCertificates.Add(certificate);

// Set the notification payload to send.
var notificationMessage = Encoding.Default.GetBytes(rawMessage);

// Set the web request content length.
sendNotificationRequest.ContentLength = notificationMessage.Length;
sendNotificationRequest.ContentType = "text/xml";
sendNotificationRequest.Headers.Add("X-NotificationClass", "3");


using (var requestStream = sendNotificationRequest.GetRequestStream())
{   
   requestStream.Write(notificationMessage, 0, notificationMessage.Length);
}

// Send the notification and get the response.
var response = (HttpWebResponse)sendNotificationRequest.GetResponse();

C’est fait! Le client doit recevoir la notification. Et, si le channel commence bien par HTTPS, c’est qu’il est bien sécurisé.

Un problème possible…

J’ai passé pas mal de temps sur un truc stupide.

Quand j’essayais d’envoyer une requête, j’obtenais une HTTPRequestException:

The request was aborted: Could not create SSL/TLS secure channel

Pas super parlant…J’ouvre le Event Viewer et je vois ceci :

Have error in event viewer schannel, event id 36888 the following fatal alert was generated 80. the internal error state is 301

OK…mais encore ?

Après avoir cherché en vain, j’ai remarqué que, en débug, quand j’essayais de voir la clé privée du certificat j’avais :

System.Security.Cryptography.CryptographicException

avec un message disant que le provider n’est pas correct…

Soudainement j’ai pensé aux permissions (oui, aucun rapport avec un provider…)

Il y a un outil pratique pour voir/modifier les permissions sur les certificats : WinHTTPCertCfg

Vous pouvez voir les permissions avec (En ligne de commande administrateur) :

WinHttpCertCfg.exe -l -c LOCAL_MACHINE\MY -s "www.equinoxe-consulting.net"

Résultat :

Le compte utilise par le web service (.NET v4.5) n’a pas de droit d’accéder à la clé privée. Pour ajouter ce droit :

WinHttpCertCfg.exe -g -c LOCAL_MACHINE\MY -s "www.equinoxe-consulting.net" -a ".NET v4.5"

Et voilà comment perdre une matinée…

Conclusion

J’ai fait une application exemple (En fait juste une version modifiée de mon exemple Raw Notification) ici.

Comme pour la version originale, il faut changer l’adresse IP du service par celui de votre serveur, et laisser l’émulateur se connecter à votre serveur (Voir ici) Il faut en plus changer le nom CN et le Thumbprint du certificat par le vôtre.