Créer un add-in pour Windows Live Messenger

Saviez-vous que Windows Live Messenger contient maintenant un support pour les add-ins (qui à la différence des plug-ins s'intègrent directement dans Windows Live Messenger). Mais au fait, un add-in, c'est quoi ? Et bien, c'est tout simplement une assembly (dll) .Net (hum, ça sent bon ça…) qui permet d'étendre les fonctionnalités de Messenger.

Au moment où cet article a été écrit, le support des add-ins n'était pas activé par défaut sur WLM. Microsoft attendait en effet les avis des développeurs sur le sujet. Et justement ça tombe bien, développeurs, n'est-ce pas ce que nous sommes ? Pour activer le support des add-ins, il suffit de se rendre dans la base de registre (en tapant « regedit.exe » dans la boite exécuter du menu démarrer) après avoir préalablement quitté WLM. Une fois dans l'éditeur de registre, allez à cette clé : HKEY_CURRENT_USER\Software\Microsoft\MSNMessenger. Créez ou modifiez la valeur de type DWORD nommée AddInFeatureEnabled et attribuez-lui la valeur 1.

Relancez WLM et rendez-vous dans le menu Outils, Options. Un nouvel onglet nommé Compléments est normalement apparu :

Vous pouvez maintenant ajouter un nouvel add-in dans la liste des add-ins disponibles en cliquant sur « Ajouter à Messenger… » et en allant chercher la dll correspondant à l'add-in.

L'utilisateur ne peut en revanche activer qu'un seul add-in à la fois. Lorsqu'il est activé, l'identité de l'add-in remplace celle de l'utilisateur (image, statut, etc.). Pour activer un add-in, rendez-vous dans liste déroulante de l'interface principale qui permet de changer le statut :

L'installation d'un add-in sur un client WLM n'affectera pas les autres utilisateurs (login différent) de ce même client. Chaque login WLM possède ses propres ensembles d'add-ins.

Nous allons voir ici les étapes de base nécessaires pour créer un add-in.

Ouvrez Visual Studio 2005 et créez un nouveau projet de type Bibliothèque de classes. Ajoutez ensuite une référence à la librairie MessengerClient.dll qui se trouve dans le dossier C:\Program Files\MSN Messenger :

Créez ensuite une nouvelle classe que nous appellerons MonAddin (dans le namespace WLMAddin). Voici ce à quoi cela devrait ressembler :

namespace WLMAddin
{
    public class MonAddin
    {
    }
}

Il nous faut ensuite changer les propriétés du projet (clic droit sur le nom du projet puis propriétés) afin que le nom de notre assembly soit égal au nom complet de notre classe (namespace+classe). Pensez à bien le faire sinon l'add-in ne fonctionnera pas. WLM utilise en effet le nom de l'assembly pour déterminer qu'elle est la classe à l'intérieur de l'assembly à instancier.

Voilà ce que cela donnera dans notre cas :

L'assembly MessengerClient contient une interface (IMessengerAddIn) qu'il nous faut obligatoirement implémenter. Cette interface ne comporte qu'une méthode (Initialize) qui est appelée à chaque chargement de l'add-in. Elle sert à :

• démarrer et configurer l'add-in ;
• s'abonner aux différents événements que l'on souhaite utiliser dans l'add-in ;
• créer une variable de classe qui servira à référencer le client Messenger.

Revenons donc dans notre classe MonAddin. Importons le namespace Microsoft.Messenger et implémentons l'interface IMessengerAddIn :

using Microsoft.Messenger;

namespace WLMAddin
{
    public class MonAddin : IMessengerAddIn
    {
 /// Référence au client Messenger
        private MessengerClient messenger;

        public void Initialize(MessengerClient messenger)
        {
            this.messenger = messenger;
        }
    }
}

Nous n'avons pas ici configuré l'add-in et nous ne nous sommes pas abonnés aux différents événements, mais vous pouvez tout de même compiler le projet pour générer votre premier add-in (certes non fonctionnel). Le strict minimum pour créer un add-in vient d'être fait.

Cet objet est le point d'entrée pour écrire votre add-in. Il contient un certain nombre de méthodes, de propriétés et d'événements pour accéder à différents éléments de WLM.

Ci-dessous, le diagramme de classe de MessengerClient :

Voici une brève description des propriétés, méthodes et événements disponibles :

• AddInProperties object : contient les propriétés de l'add-in ;
• LocalUser : propriétés de l'utilisateur local ;
• SavedState : pour sauvegarder l'état de l'add-in ;
• SendActionMessage : envoie un message action ;
• SendNudgeMessage : envoie un Wizz à un utilisateur ;
• SendTextMessage : envoie un message texte à un utilisateur ;
• IncomingTextMessage : événement déclenché lors de la réception d'un message ;
• OutgoingTextMessage : événement déclenché lors de l'envoi d'un message ;
• ShowOptionsDialog : événement déclenché lors d'un accès à la fenêtre de configuration de l'add-in ;
• Shutdown : événement déclenché lors de la désactivation de l'add-in ;
• StatusChanged : événement déclenché lors du changement de statut de l'utilisateur.

Revenons à notre add-in que nous avions précédemment créé et personnalisons le un peu. La propriété AddInProperties (objet de type AddInProperties) de l'objet MessengerClient nous permet d'accéder à différents éléments afin de configurer notre add-in.

Voici le diagramme de classe de la classe AddInProperties :

Il est possible de spécifier le créateur de l'add-in, sa description, et son nom (FriendlyName).

PersonalStatusMessage permet de modifier le message personnel de l'utilisateur qui apparait à côté de son pseudo.

Status modifie le statut de l'utilisateur (en ligne, occupé, etc.).

UserTile modifie l'avatar de l'utilisateur.

La propriété Status peut prendre différentes valeurs définies dans l'énumération UserStatus :

Mettons maintenant tout cela en pratique. Modifions notre méthode Initialize afin de définir les propriétés de l'add-in :

public void Initialize(MessengerClient messenger)
{
    this.messenger = messenger;

    //propriétés de l'add-in
    this.messenger.AddInProperties.Creator = "Moi";
    this.messenger.AddInProperties.Description = "Un premier add-in de test";
    this.messenger.AddInProperties.FriendlyName = "MonAddin";
    this.messenger.AddInProperties.PersonalStatusMessage = "J'utilise un add-in !!";
    this.messenger.AddInProperties.Status = UserStatus.Busy;            
    this.messenger.AddInProperties.UserTile = CreerImage();
}

CreerImage() est une méthode que j'ai créé et qui renvoie une image (ici une ellipse à fond rouge). N'oubliez pas d'ajouter la référence à System.Drawing.dll et à importer le namespace System.Drawing :

private Image CreerImage()
{
    Bitmap bmp = new Bitmap(40, 40);
    Graphics g = Graphics.FromImage(bmp);
    g.FillEllipse(new SolidBrush(Color.Red), new Rectangle(0, 0, 40, 40));
    return bmp;
}

Compilons maintenant cet add-in et ajoutons-le à WLM. Activons-le :

Et voici le résultat :

L'avatar, le message personnel et le statut de l'utilisateur ont été changés avec les valeurs définies dans l'add-in.

L'objet MessengerClient possède une propriété LocalUser (en lecture seule) et qui renvoie un objet de type User représentant l'utilisateur local (celui qui utilise votre add-in). L'utilisateur local n'est cependant pas le seul objet User que vous serez amené à manipuler. Tous les autres utilisateurs de WLM (les contacts de l'utilisateur local) seront aussi représentés par cet objet.

Voici le diagramme de classe de la classe User :

Cette classe possède plusieurs propriétés, toutes en lecture seule. Vous pouvez récupérer le courriel, le pseudo, le message personnel, le statut et l'identifiant (unique pour chaque utilisateur de WLM) de l'utilisateur. La méthode GetGroupNames() renvoie un tableau de String contenant la liste des groupes auxquels l'utilisateur appartient.

Nous allons illustrer ici une utilisation possible de l'événement OutgoingTextMessage qui est déclenché à chaque fois que l'utilisateur local envoie un message. Pour cela nous allons créer un filtre de contenu qui se chargera de prévenir l'utilisateur que le message qu'il tente d'envoyer peut contenir certaines informations sensibles (mot de passe, numéro de carte bleue, etc.).

La première chose est de s'abonner à l'événement OutgoingTextMessage :

//filtres
String[] filtres = { "mot de passe", "carte bancaire" };

public void Initialize(MessengerClient messenger)
{
    this.messenger = messenger;

    this.messenger.OutgoingTextMessage += new EventHandler<OutgoingTextMessageEventArgs>(messenger_OutgoingTextMessage);

}

Puis de construire la méthode qui sera appelée :

void messenger_OutgoingTextMessage(object sender, OutgoingTextMessageEventArgs e)
{
    //on récupère le message à envoyer
    string message = e.TextMessage.ToLower();
    foreach (String terme in filtres)
    {
        //si le message contient un terme filtré
        if (message.Contains(terme))
        {
            if (DialogResult.No == MessageBox.Show("Voulez-vous vraiment envoyer ce 
        texte?", "Attention", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, 
        MessageBoxDefaultButton.Button2))
                e.Cancel = true;
            break;
        }
    }
}

On récupère le message que l'utilisateur veut envoyer grâce à e.TextMessage (il est aussi possible de récupérer le destinataire avec e.UserTo) puis on vérifie si l'un des termes du filtre apparait dedans. Si c'est le cas, on affiche une boite de dialogue demandant à l'utilisateur s'il veut vraiment envoyer ce message. En cas de refus on annule l'envoi du message par e.Cancel = true.

Et voici le résultat en image :

L'utilisateur étourdi va commettre une erreur irréparable :

L'envoi du message provoque l'affichage de la boite de dialogue :

Si l'utilisateur choisit « Non », l'envoi du message est annulé :

Cet événement est déclenché à chaque fois que l'utilisateur reçoit un nouveau message. Pour illustrer l'utilisation de cet événement, nous allons développer un petit répondeur. Lorsque l'utilisateur local recevra un message alors qu'il est absent, notre add-in enverra un message afin de prévenir le correspondant.

Tout d'abord, abonnons-nous à l'événement :

public void Initialize(MessengerClient messenger)
{
    this.messenger = messenger;

    this.messenger.IncomingTextMessage += new EventHandler<IncomingTextMessageEventArgs>(messenger_IncomingTextMessage);
}

Puis construisons la méthode qui va être appelée :

void messenger_IncomingTextMessage(object sender, IncomingTextMessageEventArgs e)
{
    String messageAEnvoyer = String.Format("Cher {0}, ",e.UserFrom.FriendlyName);
    switch (this.messenger.LocalUser.Status)
    {
        case UserStatus.Away:

            messageAEnvoyer += "je ne suis pas là";
            break;

        case UserStatus.BeRightBack:

            messageAEnvoyer += "je reviens dans une minute !";
            break;

        case UserStatus.Busy:

            messageAEnvoyer += "je suis occupé";
            break;

        case UserStatus.OnThePhone:

            messageAEnvoyer += "je suis au téléphone";
            break;

        case UserStatus.OutToLunch:

            messageAEnvoyer += "je mange un casse-croute...";
            break;
    }
    //envoi du message
    this.messenger.SendTextMessage(messageAEnvoyer, e.UserFrom);
}

Le résultat en image :

Lorsqu'un correspondant envoie un message, l'add-in lui répond automatiquement que l'utilisateur n'est pas disponible.

Pouvoir changer le message personnel de l'utilisateur peut-être intéressant, mais le définir dans le code n'est pas envisageable. Il serait plus judicieux que l'utilisateur puisse lui-même définir ce genre de paramètres.

Ceci est tout à fait possible grâce à l'événement ShowOptionsDialog. Si l'on s'abonne à cet événement, WLM activera un bouton « Paramètres » dans le panneau « Compléments » :

L'événement ShowOptionsDialog est alors déclenché à chaque fois que l'utilisateur appuie sur ce bouton.

Dans notre exemple, l'appui sur ce bouton fera apparaitre une boite de dialogue permettant à l'utilisateur de saisir son message personnel :

Nous sauvegarderons ensuite ce message grâce à la propriété SaveState de l'objet MessengerClient. Il sera ainsi possible de le recharger à chaque démarrage de l'add-in.

Voici le code pour réaliser cela.

Il nous faut tout d'abord nous abonner à l'événement ShowOptionsDialog dans la méthode Initialize. Cet événement déclenchera la méthode messenger_ShowOptionsDialog dont nous verrons le code juste après :

public void Initialize(MessengerClient messenger)
{
    this.messenger = messenger;

    this.messenger.ShowOptionsDialog += new EventHandler(messenger_ShowOptionsDialog);

    //chargement de la sauvegarde
    this.messenger.AddInProperties.PersonalStatusMessage = messenger.SavedState; 
}

Nous en profitons aussi pour charger le message sauvegardé.

Passons maintenant à la méthode messenger_ShowOptionsDialog. Celle-ci doit afficher la boite de dialogue et récupérer le texte saisi par l'utilisateur. Une fois récupéré, le texte est sauvegardé et le message de l'utilisateur est mis à jour dans WLM :

private void messenger_ShowOptionsDialog(object sender, EventArgs e)
{
    try
    {
        MesParams mesParams = new MesParams();
        mesParams.MonMessage = this.messenger.SavedState;
        if (mesParams.ShowDialog() == DialogResult.OK)
        {
            this.messenger.SavedState = mesParams.MonMessage;
            this.messenger.AddInProperties.PersonalStatusMessage = mesParams.MonMessage;
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Et enfin le code de la boite dialogue :

namespace WLMAddin
{
    public partial class MesParams : Form
    {
        public MesParams()
        {
            InitializeComponent();
        }

        public String MonMessage
        {
            get { return textBoxMessage.Text; }
            set { textBoxMessage.Text = value; }
        }
    }
}

Nous venons de faire un petit tour dans le monde encore caché des add-ins pour Windows Live Messenger. Comme vous vous en êtes aperçu, la création d'un add-in est vraiment très facile et il vous est ainsi possible de rajouter quelques fonctionnalités intéressantes sur WLM. Néanmoins, l'API disponible manque encore de fonctionnalités pour pouvoir contrôler totalement WLM.

Téléchargez les sources de la solution donnée en exemple.

Windows Live Messenger Add-In API

Messenger Add-ins :: Development Space and Discussion

J'adresse ici tous mes remerciements à l'équipe de rédaction de « developpez.com » pour le temps qu'ils ont bien voulu passer à la correction et à l'amélioration de cet article.

Si vous constatez une erreur dans le tutoriel, dans les sources, dans la programmation ou pour toutes informations, n'hésitez pas à me contacter par le forum.