Créer un add-in pour Windows Live Messenger

Nous allons voir ici la façon de créer un add-in pour Windows Live Messenger, le tout en C#.

N'hésitez pas à commenter cet article ! Commentez Donner une note à l'article (5)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Introduction

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.

I. Activer les add-ins sur Windows Live 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 quitter 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.

registre


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

optionsMSN

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 :

activation

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.

II. Les bases d'un add-in pour WLM

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 :

reference


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

 
Sélectionnez

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 :

config


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 :

 
Sélectionnez

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é 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.

III. L'objet MessengerClient

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 :

AddInProperties


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 : Evènement déclenché lors de la réception d'un message
  • OutgoingTextMessage : Evènement déclenché lors de l'envoi d'un message
  • ShowOptionsDialog : Evènement déclenché lors d'un accès à la fenêtre de configuration de l'add-in
  • Shutdown : Evènement déclenché lors de la désactivation de l'add-in
  • StatusChanged : Evènement déclenché lors du changement de statut de l'utilisateur

IV. Propriétés de l'add-in

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 à coté 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 :

UserStatus


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

 
Sélectionnez

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 :

 
Sélectionnez

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 :

activer


Et voici le résultat :

msn


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

V. Propriétés d'un utilisateur

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.

VI. Utilisation de l'évènement OutgoingTextMessage

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 :

 
Sélectionnez

//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 :

 
Sélectionnez

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 :

envoiePass


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

alerte


Si l'utilisateur choisi "Non", l'envoi du message est annulé :

filtre

VII. Utilisation de l'évènement IncomingTextMessage

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 :

 
Sélectionnez

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 :

 
Sélectionnez

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 ";
            break;

        case UserStatus.BeRightBack:

            messageAEnvoyer += "je renviens 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 :

repondeur


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

VIII. Configuration de l'add-in par l'utilisateur

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" :

proprietes


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 :

message


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 :

 
Sélectionnez

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 :

 
Sélectionnez

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 :

 
Sélectionnez

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

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

Conclusion

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.

Sources

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

Liens

Remerciements

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.

Contact

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

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2007 Florian Casabianca. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Droits de diffusion permanents accordés à Developpez LLC.