Devosaure

Scénarios d’interopérabilité entre une application Moderne et une application de Bureau Part I.

EVBB — Wed, 15 Apr 2015 02:43:10 GMT

Pour développer des applications sur Windows 8 et 8.1, aujourd’hui vous avez deux paradigmes de développement comme illustré sur la figure suivante :

Des applications de bureaux traditionnelles, et des applications pour le Windows store ou dites Modernes, vous remarquerez qu’il existe une frontière entre les deux.

En effet, les applications Modernes sont pour la plus part développées pour un déploiement dans le Windows Store, elles s’exécutent essentiellement dans un conteneur “hyper protecteur”, ou il n’est pas possible de dialoguer aussi facilement qu’on le souhaiterait avec des applications de Bureau via les canaux Interprocessus traditionnels (IPC).

Avec Windows 8, seul deux mécanismes sont mis à notre disposition.

Avec l’arrivée de Windows 8.1 Update 1 deux autres mécanismes sont désormais disponibles.

L’utilisation de composants dits Brokered Components
Et permettre à l’application Moderne d’utiliser le LoopBack réseau

Partant de ces mécanismes, il est possible d’imaginer différents scénarios afin de faire passer des informations entre les deux types d’applications ou entre une application Moderne et un composant qui ne serait pas chargé dans ce container “Hyper protecteur”.

Par exemple, nous pourrions imaginer les scénarios suivants :

Comment lancer votre application Moderne (Windows Store) au chargement de Windows 8.1 ?

Avec Windows il est possible de définir une application qui se lancera dés que l’utilisateur se connecte, il suffit de placer votre application dans le répertoire suivant :

C:\Users\[VOUS]\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup

Le hic, c’est que vous ne pouvez-pas y placer votre application Moderne.

Une des solutions consiste à :

Définir un protocole personnalisé pour votre application moderne, comme illustré sur la figure suivante :

Créer une petite application de bureau qui invoquera ce protocole dans sa méthode Main(), comme illustré dans le code suivant :

static void Main()
         {
             ProcessStartInfo ppi = new ProcessStartInfo("alsdkcs:");
             ppi.WindowStyle = ProcessWindowStyle.Maximized;
             Process pp = new Process();
             pp.StartInfo = ppi;
             pp.Start();              
             
         }

Enfin il faut copier l’application de bureau dans le répertoire de démarrage et le tour est joué.

Lorsque l’utilisateur se connectera, l’application de bureau démarre qui elle même invoque l’application moderne via son protocole.

Comment lancer votre application de bureau à partir d’une application Moderne ?

Si l’application manipule des fichiers, le plus simple sera donc d’utiliser la méthode LaunchFileAsync, le fichier sera passé comme paramètre, à la méthode Main de l’application desktop. Il suffira alors de charger le fichier.
Néanmoins, plusieurs restrictions seront à prendre en compte.

Ce fichier à charger doit être présent :

Soit dans le répertoire courant de l’application

ApplicationData.Current.LocalFolder.GetFileAsync("presentation2.ppsx");

Soit dans un répertoire connu comme Images par exemple.

KnownFolders.PicturesLibrary.GetFileAsync("presentation2.ppsx");

Il ne sera pas possible de passer directement des paramètres (sauf à y être placés dans le fichier lui même).

L’autre méthode, consiste à utiliser un protocole personnalisé pour lancer l’application de bureau.

Tout d’abord il faut enregistrer un protocole personnalisé pour votre application de bureau. C’est très simple, ce n’est que des clés de registre à créer, dont voici un bout de code qui vous simplifiera la tâche.

   public static class CustomProtocol         
    {         
        const string URL_PROTOCOL_STRING     =    "URL:{0} Protocol"           ;         
        const string URL_PROTOCOL             ="URL Protocol"                 ;         
        const string URL_PROTOCOL_DEFAULTICON ="DefaultIcon"                 ;         
        const string URL_PROTOCOL_COMMAND     ="Shell\\Open\\command"         ;         
        const string URL_PROTOCOL_OPEN         ="Shell\\Open"                  ;         
        const string URL_PROTOCOL_SHELL         ="Shell"                         ;         
        public static int Register(string protocolname,string exepath)         
        {         
            RegistryKey HKCR = null;         
            RegistryKey SubKeyProtocolName=null;         
            RegistryKey SubKeyDefaultIcone = null;         
            RegistryKey SubKeyCommand = null;         
            int Status = 0;         
            try         
            {         
                HKCR = Registry.ClassesRoot;                        
                SubKeyProtocolName = HKCR.CreateSubKey(protocolname,         
                                                       RegistryKeyPermissionCheck.ReadWriteSubTree,         
                                                       RegistryOptions.None);         
        
                SubKeyProtocolName.SetValue("", String.Format(URL_PROTOCOL_STRING,protocolname));         
                SubKeyProtocolName.SetValue(URL_PROTOCOL, "");         
                SubKeyDefaultIcone=SubKeyProtocolName.CreateSubKey(URL_PROTOCOL_DEFAULTICON,         
                                                                   RegistryKeyPermissionCheck.ReadWriteSubTree,         
                                                                   RegistryOptions.None);         
        
                SubKeyDefaultIcone.SetValue("", exepath);         
                SubKeyCommand = SubKeyProtocolName.CreateSubKey(URL_PROTOCOL_COMMAND,         
                                                                   RegistryKeyPermissionCheck.ReadWriteSubTree,         
                                                                   RegistryOptions.None);         
                string command = String.Format("{0} %1", exepath);         
        
                SubKeyCommand.SetValue("", command);         
            }         
            catch(Exception ex)         
            {         
                Status = 1;         
            }         
            finally         
            {         
        
                if (SubKeyCommand != null) SubKeyCommand.Close();         
                if (SubKeyDefaultIcone != null) SubKeyDefaultIcone.Close();         
                if (SubKeyProtocolName!=null) SubKeyProtocolName.Close();         
                if (HKCR != null) HKCR.Close();         
            }         
        
            return Status;         
        }         
         public static int UnRegister(string protocolname)         
        {         
            int Status = 0;         
            RegistryKey HKCR = null;                    
             try         
             {         
                 HKCR = Registry.ClassesRoot;         
                 HKCR.DeleteSubKeyTree(protocolname, false);                                          
             }         
             catch(Exception)         
             {         
                 Status = 1;         
             }         
             finally         
             {         
                 if (HKCR != null) HKCR.Close();         
             }         
            return Status;         
        }         
    }

A partir de l’application Moderne, il suffit d’appeler la méthode suivante :

await Windows.System.Launcher.LaunchUriAsync(new Uri(“LauncherProtocol:”));

Lorsque l’application de bureau se lance, Windows passe à la méthode Main la chaine LauncherProtocol qu’il faut intercepter.

static void Main(string[] args)
         {
             string protocol = args[0];
             if (args[0]=="LauncherProtocol:")
             {
                 //code omis
             }
             else
             {
                 //code omis
             }
         }

A la différence de l’association de fichier, vous pouvez également passer des paramètres via le protocole. En partant de ce principe on peu alors imaginer une foultitude de scénarios, comme dans la section suivante.

Comment formater un e-mail dans une application moderne et l’envoyer dans Outlook ?

L’idée ici est de pouvoir ce substituer au contrat de partage de Windows 8.1, et formater un e-mail avec une liste de distribution, des fichiers attachés, et un corps de message au format HTML.

On va donc utiliser la méthode à base de protocole personnalisé et procéder par étapes.

L’application Moderne va sauvegarder dans son répertoire courant un fichier au format XML qui contiendra les éléments du message, comme illustrer sur la figure suivante :

Dans ce fichier on retrouve en gros les destinataires du message, les fichiers attachés, ainsi que le corps du message au format HTML.

Cette application au lieu d’invoquer directement Outlook via le protocole Mailto, invoquera une application de bureau via le protocole personnalisé nommé LauncherProtocol : qui ne prend qu’un seul paramètre, c’est à dire le chemin d’accès au fichier xml au préalablement crée.

string filePath = await CreateMailAsync();
             Uri uri = new Uri(String.Format("LauncherProtocol:{0}", filePath));
             await Windows.System.Launcher.LaunchUriAsync(uri);

L’application de bureau est lancée via son protocole, va traiter la demande lancer Outlook si il n’est pas déjà chargé, puis demander à Outlook de créer un nouveau message factice à l’aide cette fois-ci du protocole MailTo.

 static void Main(string[] args)
         {
                         
             int IndexOf= args[0].IndexOf(':');
             var file = args[0].Remove(0, IndexOf+1);            
             InvokeAppByProtocol(file);            
         }
         public static void InvokeAppByProtocol(string file)
         {
             Process[] Processes= Process.GetProcessesByName("outlook");            
             if (Processes.Count() > 1)
             {
                 StartNewMessage(file);
                 return; //no need to restart outlook;
             }                
             ProcessStartInfo pi = new ProcessStartInfo("Outlook.Exe");            
             pi.CreateNoWindow = false;
             pi.UseShellExecute = true;
             pi.WindowStyle = ProcessWindowStyle.Maximized;
             Process p = new Process();
             p.StartInfo = pi;
             
             if (p.Start())
             {
                 
                 StartNewMessage(file);
             }            
         }
         static void StartNewMessage(string file)
         {
 
 
             ProcessStartInfo ppi = new ProcessStartInfo(String.Format("mailto:fake@contoso.com?subject={0}", file));
             ppi.WindowStyle = ProcessWindowStyle.Maximized;
             Process pp = new Process();
             pp.StartInfo = ppi;
             pp.Start();
             Program.ShowWindow(pp.MainWindowHandle, 3);
         }

Enfin, l’astuce consiste à développer un Add-In Outlook qui va :

Intercepter le nouveau message factice.
Récupérer le chemin d’accès au fichier dans le champ Subject.
De sérialiser le vrai message à partir du fichier xml.
Et enfin, créer un nouveau message, comme illustré dans le listing suivant :

     void Inspectors_NewInspector(Microsoft.Office.Interop.Outlook.Inspector Inspector)
         {
             try
             {
 
                 Outlook.MailItem currentMailItem = Inspector.CurrentItem as Outlook.MailItem;
                 if (currentMailItem != null)
                 {
 
                     if (currentMailItem.Subject == null) return;
                     StreamReader reader = new StreamReader(currentMailItem.Subject);
                     Mail mail = new Mail(reader.BaseStream);
                     
                     if (currentMailItem.EntryID == null)
                     {
                         Outlook.Attachments mailAttachments = currentMailItem.Attachments;
                         Outlook.Attachment newAttachment = null;
                         foreach (var attachment in mail.Attachments)
                         {
                             newAttachment = mailAttachments.Add(attachment);
 
                         }
                         currentMailItem.Save();
                         if (newAttachment != null) Marshal.ReleaseComObject(newAttachment);
                         if (mailAttachments != null) Marshal.ReleaseComObject(mailAttachments);
 
                         currentMailItem.Subject = mail.Subject;
                         currentMailItem.HTMLBody = mail.HTMLBody;
                         currentMailItem.Importance = (Outlook.OlImportance)mail.Importance;
                         currentMailItem.CC = mail.Cc;
                         currentMailItem.To = mail.To;
                         currentMailItem.BCC = mail.Bcc;
                         Marshal.ReleaseComObject(currentMailItem);
                     }
                 }
             }
             catch (Exception ex)
             {
                 var Message = ex.Message;
             }
         }

ce qui donne un message Outlook du style de la figure suivante :

Bon ok, c’est un peu tordu, mais c’est une idée…

Comme je le disais au début de ce billet, avec Windows 8.1 update 1, Microsoft a ouvert un peu les vannes en proposant deux autres mécanismes les Brokered Components et l’utilisation du LoopBack réseau
qui permet à des applications Modernes de dialoguer plus largement avec des applications de bureau, voir d’utiliser des librairies qui ne sont disponibles que pour le modèle de développement de bureau, mais si et seulement si ces applications modernes sont “sideloadées”, c’est à dire qu’elles ne soient PAS installées via le Windows Store.

Dans la deuxième partie de cet article nous aborderons la manière d’utiliser le Loopback réseau via un mécanisme Interprocessus comme les Sockets ainsi que la manière d’autoriser l’application de bureau à y accéder.

Eric

Développeurs, connaissez vous UMDH l’outil pour détecter les fuites mémoire ?

EVBB — Thu, 02 Apr 2015 01:05:00 GMT

UMDH (User mode Dump Heap) est un outil qui s’utilise en mode console en tant qu’administrateur et permet de tracer de manière très précise les fuites mémoire.

Comment ça marche ?

Tout d’abord, vous devez créer une "User Stack Trace Database" à l’aide de l’outil GFLAGS en lui donnant une taille de 50 Méga-octets par exemple.

GFLAGS –i +ust
GFLAGS –i -tracedb 50
dans ce contexte, est le nom de votre application (ex : App1.exe)

Si vous ne l’avez pas déjà fait, il faut positionner la variable d’environnement _NT_SYMBOL_PATH pour que l’outil puisse charger les symboles.
Set _NT_SYMBOL_PATH=SRV*c:\LocalSymbolCache

Lancez votre application et prenez une première photo à un instant T1 de la mémoire consommée par votre application.
UMDH –p : -f:LogFile1.log

Note : PID, est le numéro du processus de votre application, que vous retrouverez soit à l’aide du gestionnaire de tâches, ou avec l’utilitaire tlist, livré avec la suite d’outils de débogage)
tlist –p

Utilisez votre application, puis prenez une seconde photo.
UMDH –p : -f:LogFile2.log

Enfin comparez les deux fichiers de log.
UMDH logfile1.log logfile2.log > comparaison.txt

Le fichier de comparaison contiendra les informations de fuites mémoires. Par exemple j’ai dans mon exemple un BackTrace3E18904F qui consomme +0x140000104 Octets non libérés entre les deux photos (( 140000104 - 0)

+140000104 ( 140000104 - 0) 5 allocs BackTrace3E18904F
+ 5 ( 5 - 0) BackTrace3E18904F allocations

Et la pile des appels m’indique que cela ce passe dans la méthode Execute.

ntdll!RtlpCallInterceptRoutine+40
ntdll!RtlAllocateHeap+7B5F8
msvcr120d_app!heap_alloc_base+5D
msvcr120d_app!free_dbg_nolock+96B
msvcr120d_app!nh_malloc_dbg+B9
msvcr120d_app!nh_malloc_dbg+49
msvcr120d_app!malloc+2A
App1!App1::MainPage::Execute+DA (d:\app1\mainpage.xaml.cpp, 51)
App1!App1::MainPage::Button_Click+32 (d:\app1\mainpage.xaml.cpp, 39)
App1!`Windows::UI::Xaml::RoutedEventHandler::RoutedEventHandler'::`3'::__abi_PointerToMemberWeakRefCapture::Invoke+10A
App1!Windows::UI::Xaml::RoutedEventHandler::Invoke+91 (d:\app1\generated files\mainpage.g.h, 15732480)
App1!Windows::UI::Xaml::RoutedEventHandler::[Windows::UI::Xaml::RoutedEventHandler::__abi_IDelegate]::
__abi_Windows_UI_Xaml_RoutedEventHandler___abi_IDelegate____abi_Invoke+4D (d:\app1\generated files\mainpage.g.h, 16707566)
Windows.UI.XamlDirectUI::CRoutedEventSourceBaseXaml::IRoutedEventHandler,IInspectable,Windows::UI::Xaml::IRoutedEventArgs>::Raise+3FC (d:\9144\windows\dxaml\xcp\dxaml\lib\joltclasses.h, 1139)
Windows.UI.Xaml!DirectUI::ButtonBase::OnClick+AD

Pour en savoir plus sur l’utilisation d’umdh, suivez le guide.

https://support.microsoft.com/kb/268343 et
https://msdn.microsoft.com/en-us/library/windows/hardware/ff558947(v=vs.85).aspx

Cet outil fait partie de la suite d’outils de débogage que vous pouvez télécharger à partir de cette adresse https://msdn.microsoft.com/en-us/library/windows/hardware/ff551063(v=vs.85).aspx

Eric

Point sur les langages et Visual Studio

EVBB — Tue, 24 Mar 2015 01:48:46 GMT

Dans le monde du développement Microsoft, Visual Studio est la pierre angulaire, que dis-je la clé de voute pour tous les développeurs. C’est un outil polymorphe, qui s’adresse à tous types de développeurs, que l’on soit développeur Cloud, client, Mobile, Web, Office, de solutions collaboratives, de jeux, de base de données, voir même développeur de drivers.

Si vous êtes plutôt développeur d’applications clientes traditionnelles de bureau, le modèle qui s’impose aujourd’hui c’est de développer en utilisant la plate-forme .NET.).
Plusieurs langages sont à votre disposition, dans la boite.

C#, langage le plus populaire sur la plate-forme .NET, non de code Cool c’est pour dire, et VB.NET le mal aimé, qui contrairement à ce que l’on pourrait penser, permet d’écrire le même code et avoir les mêmes performances que du code écrit en C#.
En dehors de la boite, c’est à dire disponible sous forme d’extension à Visual Studio, il existe d’autres langages, tel que Python par exemple.

Mais la liste des langages .NET disponibles avec Visual Studio, ne s’arrête pas là. Il en existe d’autres tels que F# langage pour de la programmation fonctionnelle, C++/CLI (C++ pour le Common Language Infrastructure), plus destiné à créer des assemblages .NET, qui feront la colle entre les langages .NET traditionnels et le monde Natif. Le compilateur qui est utilisé est le même que celui pour compiler du code ISO C++, permettant ainsi un mixte des deux langages (C++/CLI et ISO C++) dans le même code source.

L’autre modèle pour développer des applications de bureau, est le modèle historique de Windows, à savoir, à base d’API Win32, affublé de son petit frère le Common Object Model. Dans ce cas-là, on utilisera plutôt le langage C++, qui suit la norme ISO C++14. (A noter, que bien qu’il soit possible de faire du C pure, nous ne supportons pas l’intégralité des fonctionnalités C99. Herb Sutter en donne une bonne explication dans son billet Reader Q&A: What about VC++ and C99?

Il est également possible pour les puristes qui souhaiteraient optimiser ce que fait le compilateur, sortir un listing Assembleur à partir du code C++ et de le réassembler avec MASM.

Pour le développeur Web (HTML), le langage qui s’impose dans Visual Studio, est bien évidement Javascript. Néanmoins, si vous êtes plutôt enclin à utiliser un mode de programmation plus classique, TypeScript est le langage fait pour vous. Le code TypeScript est transcompilé en Javascript, pouvant ainsi être interprété par n'importe quel navigateur web ou moteur Javascript. Il a pour but d'améliorer et de sécuriser la production de code Javascript.

Pour des développements d’applications pour le Windows Store, le modèle de développement se fait sur la base d’un nouveau modèle, le Windows Runtime qui permet de développer des applications dites Universelles, c’est-à-dire qu’elles tourneront à la fois sur du Windows Phone que sur du Windows (PC, Tablettes, ou Microsoft Surface HUB).
Sans surprise nous retrouverons les langages C# et VB.NET, un petit nouveau, C++/CX, (Extension propriétaire de Microsoft à l’ISO C++). Sa particularité c’est qu’on peut le mixer aussi avec de l’ISO C++, ce qui en fait un bon candidat pour réutiliser du code ou des librairies C++ déjà éprouvés. Enfin, il est possible d’utiliser ses compétences acquises en Javascript, pour développer également ce type d’application.

Pour finir, Visual Studio doit faire face aujourd’hui, à une demande croissante de développement sur des plates-formes et des systèmes autres que ceux de Microsoft. On trouvera donc des extensions à Visual Studio tel que Xamarin, qui vous permettra de réutiliser vos compétences C# pour développer aussi bien sur Windows, Windows Phone, que sur IOS et Android.

Dans le même ordre d’idée avec l’outil Visual Studio pour Apache Cordova vous pourrez sans aucun problème développer sur les différentes plates-formes mobiles, mais cette fois-ci en réutilisant vos compétences Javascript.

Développeurs, connaissez-vous Microsoft Message Analyser, l’outil indispensable pour tout décortiquer ?

EVBB — Wed, 18 Mar 2015 10:12:00 GMT

Dans le temps j’utilisais Microsoft Network Monitor, pour capturer tous les paquets réseau afin d’analyser le trafique lorsque des problèmes survenaient.

Aujourd’hui, Microsoft Message Analyser, va encore plus loin, il permet de capturer à peu prêt tout et n’importe quoi.

Dans cette figure je sniff l’appel au protocole HTTP. Vous me direz mais Fiddler le fait très bien. Soit, mais ici, je peut aller encore plus loin dans l’analyse et descendre dans les couches basses.

Je peux également analyser mon trafic USB, si j’ai un problème.

Par exemple dans cette figure, je n’ai fait que connecter mon téléphone à mon port USB 3.0, et j’ai pu tracer les différentes étapes. Ca peut aider c’est ton jamais !!

Je pourrais également tracer les connections Bluetooth, les appels RPC, mais également les appels Systèmes.

Il est capable, de lire des Dumps, des fichiers ETL (Windows Event Tracing) et autres, que je vous laisse découvrir dans la documentation qui ne fait pas moins de 450 Pages !!

En un mot il sait tout faire, on peut même l’étendre et participer à son amélioration.

C’est une grosse artillerie à dégainer, si les autres outils et méthodes ne suffisent plus.

Eric

Développeurs, connaissez-vous l’outil Windows powercfg.exe l’outil indispensable pour être un Green Développeur ?

EVBB — Thu, 12 Mar 2015 11:51:59 GMT

A l’heure ou tout doit être green, le développeur aussi à un rôle à jouer dans ce domaine. Lancer la commande powercfg /energy , elle vous permettra d’obtenir un rapport d’efficacité énergétique sur votre système et donc également sur votre application.

En voici un extrait

Enregistreur d’action Utilisateur PSR.EXE

Eric

Développeurs, connaissez-vous l’outil Windows, PSR.EXE, l’enregistreur d’actions utilisateurs ?

EVBB — Mon, 02 Mar 2015 02:20:43 GMT

Dans cette série de billets, je me propose de faire le tour d’un certain nombre d’outils de Windows qui sont relativement méconnus, mais qui peuvent vous aider, vous développeurs, dans votre démarche de résolution de problèmes.

Aujourd’hui nous allons manipuler l’outil PSR.EXE (Problem Steps Recorder), qui permet d’enregistrer des actions utilisateurs.

Imaginons que l’un de l’utilisateur de votre application, ne soit pas en mesure de vous expliquer clairement le problème qu’il rencontre. Il suffit alors de lui demander de lancer sur la ligne de commande l’outil PSR.EXE et d’enregistrer les actions, et éventuellement d’ajouter des commentaires.

Appuyer sur “Commencer l’enregistrement”

L’idée ici est d’enregistrer le lancement d’une application comme Excel par exemple, de taper dans une cellule une formule de calcule =100+100, et d’ajouter un commentaire, qui permettra de donner plus d’informations aux développeurs.

Une fois que l’enregistrement est fait, un rapport est crée, dont voici un extrait.

Note : L’utilisateur peut sauvegarder le rapport, sous forme d’un ZIP, et vous l’envoyer.

Extrait de rapport :

Étapes enregistrées

Ce fichier contient toutes les étapes et informations enregistrées pour vous aider à les décrire aux autres.

Avant de partager ce fichier, vérifiez les éléments suivants :

Les étapes ci-dessous décrivent précisément l’enregistrement.
Toutes les informations ci-dessous et les captures d’écran peuvent être dévoilées aux autres.

Les mots de passe et le texte tapé n’ont pas été enregistrés, à l’exception des touches de fonction et de raccourci utilisées.

Vous pouvez procéder comme suit :

Étapes

Précédent Suivant

Étape 1: (‎02/‎03/‎2015 10:38:28) Cliqué(e) avec le bouton gauche par l’utilisateur

Précédent Suivant

Étape 2: (‎02/‎03/‎2015 10:38:34) Saisie au clavier par l’utilisateur sur « Search (fenêtre) » dans « Search » [... ENTREE]

Précédent Suivant

Étape 3: (‎02/‎03/‎2015 10:38:42) Début du glissement de la souris par l’utilisateur sur « Excel (fenêtre) » dans « Excel »

Précédent Suivant

Étape 4: (‎02/‎03/‎2015 10:38:44) Fin du glissement de la souris par l’utilisateur sur « Excel (fenêtre) » dans « Excel »

Précédent Suivant

Étape 5: (‎02/‎03/‎2015 10:38:48) Clic avec le bouton gauche par l’utilisateur sur « Nouveau classeur (Lien hypertexte) » dans « Excel »

Précédent Suivant

Étape 6: (‎02/‎03/‎2015 10:38:51) Clic avec le bouton gauche par l’utilisateur sur « Classeur1 () » dans « Classeur1 - Excel »

Précédent Suivant

Étape 7: (‎02/‎03/‎2015 10:38:54) Saisie au clavier par l’utilisateur sur « Classeur1 () » dans « Classeur1 - Excel » [...]

Précédent Suivant

Étape 8: (‎02/‎03/‎2015 10:38:55) Saisie au clavier par l’utilisateur sur « Modifier l’élément (Modifier) » dans « Classeur1 - Excel » [... ENTREE]

Précédent Suivant

Étape 9: (‎02/‎03/‎2015 10:39:09) Commentaire de l’utilisateur: "Ceci est mon commentaire"

Retourner en haut de la page...

Développeurs, connaissez-vous l’outil Windows powercfg.exe l’outil indispensable pour être un Green Développeur ?.

Eric

Windows Management Instrumentation avec du code C++

EVBB — Thu, 19 Feb 2015 09:28:00 GMT

Il y a quelques semaines, j’ai travaillé sur un bout de code, afin d’activer le contrôle parental d’un compte utilisateur sur Windows 8.1. Naïvement je pensais qu’il existait une API Win32 simple pour le faire du style :

BOOL EnableParentalControl(LPWSTR username).

Mais en y regardant de plus près, cette simple API n’existe pas. En fouillant plus en profondeur, il faut passer par l’infrastructure Windows Management Instrumentation (WMI).

Ce billet a donc juste pour vocation, non pas de vous expliquer ce qu’est WMI, mais à vous montrer comment faire un appel WMI en C++. Vous allez voir c’est existant.

Tout d’abord, il faut savoir ou trouver les différentes informations, espace de nom, signature des méthodes, propriétés, en gros le schéma utile pour nos différents appels. Pour le contrôle parental, il faut ouvrir le fichier wpcsprov.mof, dans le répertoire c:\windows\system32.

Dans ce fichier, vous pourrez y trouver l’espace de nom racine d'où nous partirons pour effectuer nos requêtes.
#pragma namespace(\\\\.\\ROOT\\CIMV2\\Applications\\WindowsParentalControls)

Nous y retrouverons le nom de la classe WpCSystemSettings, avec ces méthodes associées AddUser et RemoveUser et leurs signatures.

//**************************************************************************
//* Class: WpcSystemSettings
//* Derived from:
//**************************************************************************
[Singleton: DisableOverride ToInstance ToSubClass, Description("Stores system-wide Wpc settings"): ToInstance ToSubClass, provider("WpcSProv"): ToInstance, dynamic: ToInstance]
class WpcSystemSettings
{
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("Link to the current games rating system in force for the machine"): ToInstance ToSubClass] string CurrentGamesRatingSystem;
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("HTTP app filter exemption list"): ToInstance ToSubClass] string HTTPExemptionList[];
    [read: ToInstance ToSubClass, Description("Windows HTTP app filter exemption list"): ToInstance ToSubClass] string WinHTTPExemptionList[];
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("HTTP URL filter exemption list"): ToInstance ToSubClass] string URLExemptionList[];
    [read: ToInstance ToSubClass, Description("Windows HTTP URL filter exemption list"): ToInstance ToSubClass] string WinURLExemptionList[];
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("Number of days until a balloon reminder for checking the logs"): ToInstance ToSubClass] uint32 LogViewReminderInterval;
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("Last time the admin checked the log viewer"): ToInstance ToSubClass] DateTime LastLogView;
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("ID of current web filter"): ToInstance ToSubClass] string FilterID;
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("Name of current web filter"): ToInstance ToSubClass] string FilterName;
    [Description("Creates settings for a new User SID"): ToInstance ToSubClass, Implemented: ToInstance ToSubClass, Static: ToInstance ToSubClass] uint32 AddUser([Description("SID to create settings for"): ToInstance ToSubClass, IN] string strSID);
    [Description("Removes settings for a user account"): ToInstance ToSubClass, Implemented: ToInstance ToSubClass, Static: ToInstance ToSubClass] uint32 RemoveUser([Description("SID of the account to delete settings for"): ToInstance ToSubClass, IN] string strSID);
};

Puis la classe WpcUserSettings, qui possède les propriétés et leurs signatures que nous utiliserons pour paramétrer et activer le contrôle parental.

//**************************************************************************
//* Class: WpcUserSettings
//* Derived from:
//**************************************************************************
[Description("Per-account Windows Parental Controls Settings"): ToInstance ToSubClass, provider("WpcSprov"): ToInstance, dynamic: ToInstance]
class WpcUserSettings
{
    [key, read: ToInstance ToSubClass, Description("SID of the user account owning these settings"): ToInstance ToSubClass] string SID;
    [read: ToInstance ToSubClass, write: ToInstance ToSubClass, Description("Is WPC enabled for this user"): ToInstance ToSubClass] boolean WpcEnabled;
    [write: ToInstance ToSubClass, Description("Is logging enabled for this user"): ToInstance ToSubClass, read: ToInstance ToSubClass] boolean LoggingRequired;
    [write: ToInstance ToSubClass, Description("Are hourly restrictions enabled for this user"): ToInstance ToSubClass, read: ToInstance ToSubClass] boolean HourlyRestrictions;
    [write: ToInstance ToSubClass, Description("Are time allowance restrictions enabled for this user"): ToInstance ToSubClass, read: ToInstance ToSubClass] boolean TimeAllowanceRestrictions;
    [write: ToInstance ToSubClass, Description("Are override requests enabled for this user"): ToInstance ToSubClass, read: ToInstance ToSubClass] boolean OverrideRequests;
    [write: ToInstance ToSubClass, Description("Logon Hours mask for this user"): ToInstance ToSubClass, read: ToInstance ToSubClass] uint32 LogonHours[7];
    [write: ToInstance ToSubClass, Description("Logon Half-Hours (30 minute offset) mask for this user"): ToInstance ToSubClass, read: ToInstance ToSubClass] uint32 LogonHalfHours[7];
    [write: ToInstance ToSubClass, Description("Daily minute allowance"): ToInstance ToSubClass, read: ToInstance ToSubClass] uint32 AllowanceMinutes[7];
    [write: ToInstance ToSubClass, Description("Are application restrictions enabled for this user"): ToInstance ToSubClass, read: ToInstance ToSubClass] boolean AppRestrictions;
};

Une fois que l’on a compris que tout est dans ce fichier, on peut commencer à coder.

WMI étant une API issue du monde COM, il faut initialiser COM.

::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);

Ensuite comme il est indiqué dans l’exemple MSDN suivant Getting WMI Data from the Local Computer, il faudrait également initialiser la sécurité COM avec l’API suivante :

CoInitializeSecurity(
         NULL,      // Security descriptor 
         -1,      // COM negotiates authentication service
         NULL,      // Authentication services
         NULL,      // Reserved
         RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication level for proxies
         RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation level for proxies
         NULL,      // Authentication info
         EOAC_NONE,     // Additional capabilities of the client or server
         NULL);      // Reserved

Néanmoins, mon code faisant partie d’un projet beaucoup plus vaste qui sera appelé à partir d’une application C# .NET et comme chacun sait, le CLR de .NET a déjà initialisé COM et sa sécurité pour nous, il n’est donc pas forcément nécessaire de le faire. Tout dépend du contexte.

Venons-en à WMI proprement dit.

La première chose à faire est d’initialiser un IWbemLocator.

  HRESULT hr = S_OK;
   CComPtr<IWbemLocator> pLocator;
   hr=pLocator.CoCreateInstance(CLSID_WbemLocator,
                                NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER);
   if (FAILED(hr))
   {          
       throw StatusException(NERR_CouldNotEnableParentalControl);
   }

J’utilise ici directement un smart pointeur CComPtr qui permet d’éliminer les fuites mémoires en effectuant automatiquement le décompte de références.

Ensuite il faut se connecter au service WMI qui nous intéresse, c’est à dire le contrôle parental. Ce service est symbolisé ici par l’espace de nom :

\\\\.\\ROOT\\CIMV2\\Applications\\WindowsParentalControls

CComPtr<IWbemServices> piWmiServices;
       BSTR bstrServiceNameSpace = SysAllocString(L"\\\\.\\root\\CIMV2\\Applications\\WindowsParentalControls");
       //Connect to the server
       hr=pLocator->ConnectServer(bstrServiceNameSpace,
           NULL,                    // User name. NULL = current user
           NULL,                    // User password. NULL = current
           NULL,                    // Locale. NULL indicates current
           NULL,                    // Security flags.
           0,                       // Authority (e.g. Kerberos)
           NULL,                    // Context object 
           &piWmiServices            // pointer to IWbemServices proxy
           );
       if (FAILED(hr))
       {          
           throw StatusException(NERR_CouldNotEnableParentalControl);
       }

Note : Ne pas oublier de libérer la chaine BSTR une fois utilisée SysFreeString(bstrServiceNameSpace)

La méthode ConnectServer retourne un proxy vers une interface IWbemServices. Ce proxy nous servira pour tous les autres appels. Mais comme nous sommes dans un contexte qui s’exécutera en RPC, il est important avant tout, de pouvoir se faire passer comme la bonne autorité et pour ce faire nous allons utiliser la méthode CoSetProxyBlanket sur notre proxy.

 HRESULT hr = S_OK;
       hr=CoSetProxyBlanket(piWmiServices,
           RPC_C_AUTHN_WINNT,
           RPC_C_AUTHZ_NONE,
           NULL,
           RPC_C_AUTHN_LEVEL_CALL,
           RPC_C_IMP_LEVEL_IMPERSONATE,
           NULL,
           EOAC_NONE
           );
       if (FAILED(hr))
       {          
           throw StatusException(NERR_CouldNotEnableParentalControl);
       }

Sans cet appel, tous les autres appels échoueront.

Maintenant que nous avons notre proxy en bon état de marche, nous allons pouvoir effectuer nos premières requêtes.

La première étant d’exécuter la méthode AddUser, mentionnée plus haut dans le fichier wpcsprov.mof, pour la classe WpcSystemSettings.

Tout d’abord il faut obtenir une instance de cette classe. Nous allons utiliser la méthode GetObject, de notre proxy, en lui passant comme paramètre le nom de la classe sous forme d’une chaine de caractères.

L’instance sera retournée en tant qu’interface IWbemClassObject

HRESULT hr = S_OK;
       CComPtr<IWbemClassObject> pObjectWpcSystemSettings;
       BSTR bstrPath = SysAllocString(L"WpcSystemSettings");
       hr=piWmiServices->GetObject(bstrPath, 0, NULL, &pObjectWpcSystemSettings, NULL);
 
       if (FAILED(hr))
       {          
           throw StatusException(NERR_CouldNotEnableParentalControl);
       }

Ensuite sur l’instance de cette classe, nous allons devoir récupérer pour la méthode AddUser, une autre instance de l’interface IWbemClassObject qui définira les paramètres d’entrée de la méthode. (En regardant dans le fichier mof, cette méthode prend comme paramètre une chaine nommée strSID. Notez le nom il aura son importance par la suite)

uint32 AddUser([Description("SID to create settings for"): ToInstance ToSubClass, IN] string strSID);

Note : Nous n’utiliserons pas le paramètre de retour de type uint32.

CComPtr<IWbemClassObject> piObjectSignatureIn;
       CComPtr<IWbemClassObject> piObjectSignatureOut;
       BSTR bstrMethod = SysAllocString(L"AddUser");
       hr=pObjectWpcSystemSettings->GetMethod(bstrMethod, 0, &piObjectSignatureIn, &piObjectSignatureOut);
 
 
       if (FAILED(hr))
       {          
           throw StatusException(NERR_CouldNotEnableParentalControl);
       }

La méthode GetMethod, récupère une instance de la classe IWbemClassObject (piObjectSignatureIn) pour la méthode AddUser, qui lui est passée en paramètre en tant que chaine de caractères.

Nous allons utiliser l’instance piObjectSignatureIn, afin de lui affecter le paramètre strSID avec la bonne valeur.

HRESULT hr = S_OK;
       VARIANT varSID;
       LPWSTR SID = ::GetUserSID(L"MonServeur", L"NomUtilisateur");
       InitVariantFromString(SID, &varSID);
       
       piObjectSignatureIn->Put(L"strSID", 0, &varSID, 0);
 
       if (FAILED(hr))
       {          
           throw StatusException(NERR_CouldNotEnableParentalControl);
       }
       VariantClear(&varSID);

La méthode Put de notre instance de classe pousse pour le paramètre strSID, la valeur de notre SID.

Note : Il est possible de vérifier si cela a bien fonctionné en utilisant la méthode GetObjectText de notre instance.

BSTR debug;
         hr = piObjectSignatureIn->GetObjectText(0, &debug);
         

Vous devriez obtenir un texte au format mof qui ressemble à cela

[abstract]class __PARAMETERS
{
[Description("SID to create settings for"): ToInstance ToSubClass, IN, ID(0): DisableOverride ToInstance]
string strSID = "S-1-5-21-203241617-564013427-62682210-1111";
};

Un SID (Security Identifier) dans Windows est une valeur unique qui permet d’identifier par exemple un utilisateur.

Voici la méthode qui permet de récupérer un SID pour un utilisateur donné.

 LPWSTR GetUserSID(LPWSTR servername, LPWSTR username)
 {
     DWORD dwStatus = NERR_Success;
       LPUSER_INFO_4lpBufUserInfo = nullptr;
     DWORD LevelUserInfo = 4;
     LPWSTR sid = nullptr;
     try
     {
         //Get the User's SID
         CheckNERRStatusAndThrowNERRStatus(NetUserGetInfo(servername, username, LevelUserInfo, (LPBYTE*) &lpBufUserInfo));
         PSID CurrentPSID = lpBufUserInfo->usri4_user_sid;
         ConvertSidToStringSid(CurrentPSID, &sid);
         //Check if we have an error converting the string
         CheckNERRStatusAndThrowNERRStatus(GetLastError());
     }
     catch (StatusException ex)
     {
         dwStatus = ex.GetStatus();
     }
     if (lpBufUserInfo != NULL)
     {
         NetApiBufferFree(lpBufUserInfo);
     }
     return sid;
 }

Une fois que la propriété est bien initialisée, on peut alors exécuter la méthode AddUser

HRESULT hr = S_OK;
       BSTR bstrPath = SysAllocString(L"WpcSystemSettings");
       BSTR bstrMethod = SysAllocString(L"AddUser");
 
       piWmiServices->ExecMethod(bstrPath, bstrMethod, 0, NULL, piObjectSignatureIn, NULL, NULL)
 
       if (FAILED(hr))
       {          
           throw StatusException(NERR_CouldNotEnableParentalControl);
       }

La dernière chose à faire maintenant est d’activer le contrôle parental pour cet utilisateur.

 HRESULT hr = S_OK;
       CComPtr<IEnumWbemClassObject> piEnumerator;
       CComPtr<IWbemClassObject> piEnableWPC;
       VARIANT varEnableParentalControls;
       ULONG uReturned = 0;
       LPWSTR SID = ::GetUserSID(L"NomServeur", L"Nomutilisateur");
       CComBSTR bstrQuery(L"Select * from WpcUserSettings where SID='"); 
       BSTR bstrWQL = SysAllocString(L"WQL");
       
       bstrQuery.Append(SID);
       bstrQuery.Append(L"'");
      hr= piWmiServices->ExecQuery(bstrWQL, bstrQuery, WBEM_FLAG_FORWARD_ONLY,
                                    NULL, &piEnumerator)
      ///FAILED(hr)
      hr=piEnumerator->Next(0, 1, &piEnableWPC, &uReturned);
      ///FAILED(hr)
      hr=InitVariantFromBoolean(TRUE, &varEnableParentalControls);     
      ///FAILED(hr)
      hr=piEnableWPC->Put(L"WpcEnabled", 0, &varEnableParentalControls, 0);
      ///FAILED(hr)
      hr=piWmiServices->PutInstance(piEnableWPC, 0, NULL, NULL);
 
      SysFreeString(bstrWQL);     
      SysFreeString(bstrQuery);     
      VariantClear(&varEnableParentalControls);
      ///....

Pour ce faire on utilise la méthode ExecQuery de notre instance de service WMI. On parle ici bien d’une requête qui ressemble à du SQL, mais qui est en fait au format WQL (SQL pour WMI)

Cette méthode va retrouver tout simplement en fonction du SID de l’utilisateur une instance d’un enumérateur IEnumWbemClassObject sur la classe WpcUserSettings.

Ensuite on instancie la propriété au travers de l’interface IWbemClassObject (piEnableWPC) avec la méthode Next.

On indique que l’on veut activer le contrôle parental à l’aide de la propriété WpcEnabled que l’on positionne à TRUE, via la méthode Put.

Enfin on active réellement la propriété à l’aide de la méthode PutInstance de l’instance de notre service et le tour est joué.

Vous me direz beaucoup de travail, pour une simple action

Eric

Sauvegarde par défaut dans OneDrive

EVBB — Thu, 16 Oct 2014 02:19:24 GMT

Sur Windows 8.1 dans une application Windows Store, lorsque vous souhaitez sauvegarder un fichier dans la librairie Documents par exemple comme illustré dans le code suivant :

var docsLib = KnownFolders.DocumentsLibrary;
 var file=await docsLib.CreateFileAsync("MonFichier.txt");

Windows 8.1 utilise OneDrive par défaut. Il est possible dans les paramètres OneDrive | Stockage de fichiers de rendre inactif l’enregistrement automatique dans OneDrive.

Néanmoins, cela demande une action utilisateur, pas toujours souhaitable. Pour remédier à cela voici comment faire par code.

var documents = await StorageLibrary.GetLibraryAsync(KnownLibraryId.Documents);
  foreach (var folder in documents.Folders)
  {
      var providerId = folder.Provider.Id;
      switch (providerId)
      {
          case "computer":
              await folder.CreateFileAsync("Librairie Document Local.txt");
              break;
          case "SkyDrive":
              await folder.CreateFileAsync("Librairie Document OneDrive.txt");
              break;
          default:
              break;
      }
  }

Mots clés Technorati : OneDrive,Document,Librairies

ListBox, ListView et défilement automatique

EVBB — Tue, 14 Oct 2014 09:01:46 GMT

J’alimente un contrôle ListBox avec un UserControl qui affiche une conversation, comme illustré sur la figure suivante :

L’idée c’est d’avoir 0% de code dans la vue, j’utilise donc le modèle MVVM mais le soucis c’est que lorsque le nombre d’éléments dépasse l’espace d’affichage de ma ListBox, aucun défilement automatique n’est effectué pour afficher le dernier élément.

Pour contourner ce problème est n’avoir toujours aucun code derrière ma vue, je suis parti sur la solution qui consiste à créer une ListBox personnalisée (qui dérive de la ListBox standard), d’implémenter une DependencyProperty qui appellera automatiquement la méthode ScrollIntoView de la ListBox .

 class CustomListBox : ListBox
     {
         public static readonly DependencyProperty ScrollViewFromIndexProperty =
             DependencyProperty.Register(
             "ScrollViewFromIndex",
             typeof(int),
             typeof(CustomListBox), new PropertyMetadata(0, new PropertyChangedCallback(OnNewItemAdded))
             );
 
 
         public CustomListBox()
         {
             this.DefaultStyleKey = typeof(CustomListBox);
           
         }
         public int ScrollViewFromIndex
         {
             get { return (int)GetValue(ScrollViewFromIndexProperty); }
             set {
                 SetValue(ScrollViewFromIndexProperty, (int)value);
                             
             }
         }
             
         private static void OnNewItemAdded(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
           
             int CurrentIndex =(int)e.NewValue;
             ListBox CurrentList = d as ListBox;
             if (CurrentList!=null)
             {
 
                 CurrentList.SelectedIndex=CurrentIndex;
                 CurrentList.UpdateLayout();
                 CurrentList.ScrollIntoView(CurrentList.SelectedItem);
             }
             
         }       
     }

Je Bind la DependencyProperty ScrollViewFromIndex à BINDING_PROP_CURRENT_INDEX qui est elle même mis à jour à chaque fois qu’un nouvel élément est ajouté en tant que source de la ListBox.

<ShareViews:CustomListBox  ItemsSource="{Binding BINDING_PROP_LISTMESSAGES}" Background="{x:Null}" 
             ScrollViewFromIndex="{Binding BINDING_PROP_CURRENT_INDEX}"

private int m_CurrentIndex;
         public int BINDING_PROP_CURRENT_INDEX
         {
             get { return m_CurrentIndex; }
             set
             {
                 this.SetProperty(ref m_CurrentIndex, value);
             }
         }
         ObservableCollection<UserControl> m_ListMessages;
         public ObservableCollection<UserControl> BINDING_PROP_LISTMESSAGES
         {
             get { return m_ListMessages; }
             set
             {
                 this.SetProperty(ref m_ListMessages, value);
                 BINDING_PROP_CURRENT_INDEX = m_ListMessages.Count - 1;
             }
 
         }

Sans doute les puristes vont râler, mais bon pour les autres une petite solution simple et rapide à mettre en œuvre et qui fonctionne également pour Windows Phone.

Eric

Capturer le flux vidéo d’une caméra avec MediaFoundation dans une application Windows Forms ou WPF

EVBB — Wed, 05 Mar 2014 11:02:28 GMT

Télécharger le code

Dans mon précédant billet, j’ai abordé la manière d’utiliser les APIs du Windows Runtime afin de prendre une photo et de l’afficher dans une application Windows Forms. Restait alors à implémenter ce que fait la classe XAML CaptureElement du Windows Runtime afin de capturer directement le flux vidéo venant de la caméra.

La classe CaptureElement, utilisant les APIs MediaFoundation, et comme il ne sera pas possible d’utiliser dans le contexte d’une application de bureau, cette classe XAML, nous allons donc aborder la manière de capturer le flux vidéo en utilisant directement MediaFoundation et non pas les APIs du Windows Runtime.

Architecture de la solution.

Dans le code source disponible en téléchargement, vous trouverez 3 projets.

Une librairie C/C++ (Win32MediaCapture.dll) qui appelle les APIs MediaFoundation et qui exporte des méthodes afin qu’elles soient utilisables via la technologie PInvoke de .NET
Une Assembly C# Version 3.5 de .NET (FRDPE.MediaFoundation.Wrapper.dll) qui importe les méthodes de la librairie Win32MediaCapture et permet de faire le pont avec l’interface utilisateur.
Un projet Windows Forms qui utilise l’assembly C# et qui servira de container pour afficher le flux vidéo.

Utilisation de MediaFoundation dans la librairie Win32MediaCapture.dll

MediaFoundation est un jeu d’APIs disponible depuis Windows Vista et qui utilise COM comme modèle de programmation.

Avec Windows 8, de nouvelles interfaces ont été rajoutées, comme IMFCaptureEngine, IMFCapturePreviewSink, IMFCaptureSource et d’autres qui vont nous permettre de capturer et de pré-visualiser le flux vidéo.

Initialisation du moteur de capture vidéo.

Tout d’abord, il faut démarrer MediaFoundation et initialiser le moteur de capture, comme illustré dans le code suivant :

WIN32MEDIACAPTURE_API HRESULT MFInitialize(HWND preview, CBCOMPLETED *cb, UINT32 numdevice)
 {
     HRESULT hr = S_OK;
     //Start the MediaFoundation
     
     m_pCaptureManager = std::unique_ptr<Win32CaptureManager>(new Win32CaptureManager());
     if (m_pCaptureManager == nullptr) return E_OUTOFMEMORY;
     hr=m_pCaptureManager->MFStartup();
 
     CComPtr<IMFActivate> device;
     hr = m_pCaptureManager->MFGetDevice(&device, numdevice);
     if (FAILED(hr)) return hr;
 
     
     hr=m_pCaptureManager->MFInitializeCaptureManager(preview, device, cb);
     if (FAILED(hr)) return hr;
     
     return hr;
 }

La méthode MFInitialize, prend comme paramètre :

HWND preview, est un HANDLE de fenêtre qui servira de container pour pré-visualiser la vidéo.
CBCOMPLETED *cb, est un pointeur de méthode de rappel pour notifier le client qu’une action est finie.
UINT32 numdevice, correspond à un index de caméra à utiliser. (Une tablette peux posséder deux caméras, une frontale et une arrière), il est donc important de pouvoir les sélectionner.

On démarre MediaFoundation (MFStartup()).
On récupère un pointeur IMFActivate MFGetDevice()) en fonction de l’index de la caméra.
Exemple MFGetDevice

HRESULT Win32CaptureManager::MFGetDevice(IMFActivate** device, UINT32 numdevice)
{

    HRESULT hr = S_OK;
    CComPtr<IMFAttributes> pAttributes;
    hr = MFCreateAttributes(&pAttributes, 1);
    if (FAILED(hr)) return hr;

    hr = pAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
        MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID);
    if (FAILED(hr)) return hr;

    // Enumerate devices.
    UINT32 count;
    IMFActivate **ppDevices;

    hr = MFEnumDeviceSources(pAttributes, &ppDevices, &count);
    if (FAILED(hr)) return hr;
    if (count > 0)
    {
        if (0 < numdevice && numdevice >count)
        {
            *device = ppDevices[0];
        }
        else
        {
            *device = ppDevices[numdevice];
        }
    }
    return hr;
}
Enfin on initialise le moteur de capture via la méthode MFInitializeCaptureManager illustré dans le code suivant :

HRESULT Win32CaptureManager::MFInitializeCaptureManager(HWND hwndPreview,
                                                        IUnknown* pUnk,
                                                        CBCOMPLETED *cb)
{
    HRESULT hr = S_OK;

    m_pCallback = std::unique_ptr<Win32CaptureEventCallback>(new (std::nothrow)Win32CaptureEventCallback(cb));

    if (nullptr == m_pCallback) return E_OUTOFMEMORY;

    m_hwndPreview = hwndPreview;
    CComPtr<IMFCaptureEngineClassFactory>   pFactory = nullptr;

    hr = CoCreateInstance(CLSID_MFCaptureEngineClassFactory, nullptr,
        CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pFactory));
    if (FAILED(hr)) return hr;

    CComPtr<IMFAttributes> pAttributes = nullptr;

    hr = MFCreateAttributes(&pAttributes, 1);
    if (FAILED(hr)) return hr;

    //Ici DIRECTX
    //Create a D3D Manager
    hr = CreateD3DManager();
    if (FAILED(hr)) return hr;
    hr = pAttributes->SetUnknown(MF_CAPTURE_ENGINE_D3D_MANAGER, g_pDXGIMan);
    if (FAILED(hr)) return hr;

    //// Create and initialize the capture engine.
    hr = pFactory->CreateInstance(CLSID_MFCaptureEngine, IID_PPV_ARGS(&m_pEngine));
    if (FAILED(hr)) return hr;


    hr = m_pEngine->Initialize(m_pCallback.get(), pAttributes, nullptr, pUnk);
    if (FAILED(hr)) return hr;

    return hr;
}

Dans cette méthode, on instancie la classe Win32CaptureEventCallBack, qui dérive de l’interface IMFCaptureEngineOnEventCallback et qui servira d’objet de rappel à l’infrastructure de MediaFoundation. Pour être notifié, il faut implémenter la méthode OnEvent de cette Interface. Vous remarquerez que dans son constructeur, nous lui passons un pointeur CBCOMPLETED *cb, qui permettra de rappeler le client C# comme nous le verrons par la suite.

Exemple de méthode OnEvent

STDMETHODIMP Win32CaptureEventCallback::OnEvent(_In_ IMFMediaEvent* pEvent)
{
    HRESULT hr = S_OK;
    HRESULT hrStatus;
    GUID guidType;
    int status = 1;
    hr = pEvent->GetStatus(&hrStatus);
    if (FAILED(hr))
    {
        status = 0;
        if (m_cb) m_cb(status);
        return hr;
    }

    hr = pEvent->GetExtendedType(&guidType);
    if (FAILED(hr))
    {
        status = 0;
    }
    if (guidType == MF_CAPTURE_ENGINE_INITIALIZED)
    {
        status = 1;//EngineInitialized
    }
    else if (guidType == MF_CAPTURE_ENGINE_PREVIEW_STARTED)
    {
        status = 2; //PreviewStarted
    }
    else if (guidType == MF_CAPTURE_ENGINE_PREVIEW_STOPPED)
    {
        status = 3; //PreviewStopped
    }

    if (m_cb) m_cb(status);
    return hr;
}
Ensuite on crée une fabrique de classe IMFCaptureEngineClassFactory, afin de pouvoir créer une instance de notre moteur de capture (IMFCaptureEngine).
MF_CAPTURE_ENGINE_D3D_ENGINE, indique au moteur, d’allouer les frames vidéos en utilisant DirectX et donc d’utiliser l’accélération matérielle pour l’affichage.
Pour ce faire on utilise une instance de l’interface IMFAttributes, créée par la méthode MFCreateAttributes.
Ensuite, on crée une instance du moteur pFactory->CreateInstance (…)
Enfin on initialise le moteur m_pEngine->Initialize(..) en lui donnant :

un pointeur sur la classe de rappel Win32CaptureEventCallBack
un attribut correspondant au rendu DirectX
un pointeur IUnknown* pUnk, correspondant à la caméra qui sera utilisée.

Démarrer la prévisualisation

Une fois que le moteur est initialisé, il est alors possible de démarrer la prévisualisation.

HRESULT Win32CaptureManager::MFStartPreview(DWORD rotation)
 {
     CComPtr<IMFCapturePreviewSink> pPreview;
     m_rotation = rotation;
     if (m_pEngine == nullptr) return S_FALSE;
 
     HRESULT hr = S_OK;
     CComPtr<IMFCaptureSink> pcaptureSink;
     hr = m_pEngine->GetSink(MF_CAPTURE_ENGINE_SINK_TYPE_PREVIEW, &pcaptureSink);
     if (FAILED(hr)) return hr;
 
     hr = pcaptureSink->QueryInterface(IID_PPV_ARGS(&pPreview));
     if (FAILED(hr)) return hr;
 
     hr = pPreview->SetRenderHandle(m_hwndPreview);
     if (FAILED(hr)) return hr;
 
     
     CComPtr<IMFCaptureSource> pSource;
 
     hr = m_pEngine->GetSource(&pSource);
     if (FAILED(hr)) return hr;
     
     if (m_pProcAmp == nullptr)
     {
         hr = pSource->GetCaptureDeviceSource(MF_CAPTURE_ENGINE_DEVICE_TYPE_VIDEO, &m_pMediaSource);
         if (FAILED(hr)) return hr;
 
         hr = m_pMediaSource->QueryInterface(IID_PPV_ARGS(&m_pProcAmp));
         if (FAILED(hr)) return hr;
 
     }
     
 
     CComPtr<IMFMediaType> pMediaType;
     //CComPtr pMediaType2;
 
     hr = pSource->GetCurrentDeviceMediaType((DWORD) MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_VIDEO_PREVIEW, &pMediaType);
     if (FAILED(hr)) return hr;
     
     
     /*hr = CloneVideoMediaType(pMediaType, MFVideoFormat_ARGB32, &pMediaType2);
     if (FAILED(hr)) return hr;
 
     hr = pMediaType2->SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);    
     if (FAILED(hr)) return hr;
     */
     
     DWORD dwSinkStreamIndex;
     hr = pPreview->AddStream((DWORD) MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_VIDEO_PREVIEW, pMediaType, nullptr, &dwSinkStreamIndex);
     if (FAILED(hr)) return hr;
 
     hr=pPreview->SetRotation(dwSinkStreamIndex, rotation);
     if (FAILED(hr)) return hr;
     
     hr = m_pEngine->StartPreview();
     return hr;
 }

Tout d’abord, il faut instancier un récepteur qui recevra le flux de données provenant de la caméra.
Pour ce faire, on récupère à partir du moteur (m_pEngine->GetSink()) un récepteur (IMFCaptureSink, IMFCapturePreviewSink qui servira à la prévisualisation (MF_CAPTURE_ENGINE_SINK_TYPE_PREVIEW)

Puis on définit sur quelle fenêtre la prévisualisation opèrera
pPreview->SetRenderHandle(m_hwndPreview)
On récupère la source de la capture m_pEngine->GetSource(IMFCaptureSource)
A partir de la source (pSource->GetCurrentDeviceMediaType(IMFMediaType)), on va récupérer une instance IMFMediaType , qui représente une description du format du média. Entre autre un flux qui sera de type prévisualisation vidéo (MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_VIDEO_PREVIEW)
Puis on connecte un flux de données à la source pPreview->AddStream()
Et on démarre la prévisualisation m_pEngine->StartPreview()

Vous aurez également remarqué que nous instancions un pointeur sur le périphérique
pSource->GetCaptureDeviceSource(IMFMediaSource) et ceci afin de pouvoir récupérer une instance de la classe IAMVideoProcAmp (m_pMediasource->QueryInterface()), qui nous permettra de modifier les paramètres de la caméra, tels que le contraste, la luminosité, la saturation, etc..

Modifier les propriétés de la caméra

Pour modifier par exemple, le contraste, la luminosité et la saturation, il suffit d’utiliser la méthode Set de l’interface IAMVideoProcAmp avec le bon paramètre, comme illustré dans le code suivant :

HRESULT Win32CaptureManager::MFSetContrast(long value)
 {
     
     
     HRESULT hr = S_OK;
     if (m_pProcAmp == nullptr) return E_POINTER;
     long lValue, lFlags;
     hr = m_pProcAmp->Get(VideoProcAmp_Contrast, &lValue, &lFlags);
     if (FAILED(hr)) return hr;
     return    m_pProcAmp->Set(VideoProcAmp_Contrast, value, lFlags);        
 }

HRESULT Win32CaptureManager::MFSetBrightness(long value)
 {
 
     HRESULT hr = S_OK;
     if (m_pProcAmp == nullptr) return E_POINTER;
     long lValue, lFlags;
     hr = m_pProcAmp->Get(VideoProcAmp_Brightness, &lValue, &lFlags);
     if (FAILED(hr)) return hr;
     return    m_pProcAmp->Set(VideoProcAmp_Brightness, value, lFlags);
 }

HRESULT Win32CaptureManager::MFSetSaturation(long value)
 {
 
     HRESULT hr = S_OK;
     if (m_pProcAmp == nullptr) return E_POINTER;
     long lValue, lFlags;
     hr = m_pProcAmp->Get(VideoProcAmp_Saturation, &lValue, &lFlags);
     if (FAILED(hr)) return hr;
     return    m_pProcAmp->Set(VideoProcAmp_Saturation, value, lFlags);
 }

Pour récupérer les propriétés il faut utiliser la méthode GetRange de la même interface.

HRESULT Win32CaptureManager::MFGetContrast(CAPABILITIES *contrast)
 {
     HRESULT hr = S_OK;
     if (m_pProcAmp == nullptr) return E_POINTER;
     
     return m_pProcAmp->GetRange(VideoProcAmp_Contrast,
                               &contrast->Minimum,
                               &contrast->Maximum, 
                               &contrast->Step, 
                               &contrast->Default, 
                               &contrast->Caps);
     
 }

HRESULT Win32CaptureManager::MFGetBrightness(CAPABILITIES *brightness)
 {
     HRESULT hr = S_OK;
     if (m_pProcAmp == nullptr) return E_POINTER;
 
     return m_pProcAmp->GetRange(VideoProcAmp_Brightness,
         &brightness->Minimum,
         &brightness->Maximum,
         &brightness->Step,
         &brightness->Default,
         &brightness->Caps);
 }

HRESULT Win32CaptureManager::MFGetSaturation(CAPABILITIES *caps)
 {
     HRESULT hr = S_OK;
     if (m_pProcAmp == nullptr) return E_POINTER;
 
     return m_pProcAmp->GetRange(VideoProcAmp_Saturation,
         &caps->Minimum,
         &caps->Maximum,
         &caps->Step,
         &caps->Default,
         &caps->Caps);
 }

et ainsi de suite pour les autres propriétés.

Création du Wrapper .NET C# (FRDPE.MediaFoundation.Wrapper.dll)

Le wrapper .NET n’est pas indispensable. Il est là uniquement pour simplifier l’utilisation de notre librairie C/C++, dans le contexte d’un client Windows Forms ou WPF.

Nous avons une classe FRDPE.Win32.Import.MediaFoundation, qui :

importe sous forme de méthodes statiques, toutes les APIs de notre librairies C/C++
définit les signatures des délégués qui seront utilisés plus tard comme méthodes de rappels invoquées par le composant C/C++

namespace FRDPE.Win32.Import
 {
     public static class MediaFoundation
     {
         
         [StructLayout(LayoutKind.Sequential)]
         public class Capabilities
         {
             public Int32 Minimum;
             public Int32 Maximum;
             public Int32 Step;
             public Int32 Default;
             public Int32 Caps;
         }
 
 
 
             public delegate void InitializeCompletedHandler(int status);
             public delegate void EnumDeviceHandler( [Out,MarshalAs(UnmanagedType.LPWStr)] String device);
             
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFInitialize(IntPtr hwndPreview, IntPtr cb,UInt32 numDevice);
         
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFEnumDevices(IntPtr cb,[In,MarshalAs(UnmanagedType.SysUInt)] ref UIntPtr count);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFStartPreview(uint rotation);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFStopPreview();
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetContrast(long contrast);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetContrast([Out,MarshalAs(UnmanagedType.LPStruct)] Capabilities contrast);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetBrightness(long brightness);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetBrightness([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities brightness);
 
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetSaturation(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetSaturation([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetHue(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetHue([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetSharpness(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetSharpness([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetColorEnable(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetColorEnable([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetGamma(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetGamma([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetWhiteBalance(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetWhiteBalance([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetGain(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetGain([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFSetBacklightCompensation(long value);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 MFGetBacklightCompensation([Out, MarshalAs(UnmanagedType.LPStruct)] Capabilities caps);
 
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 GetErrorMessage(UInt32 hr, IntPtr message);
 
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]
             public static extern UInt32 GetErrorMessageSize(UInt32 hr);
             
     };

Ensuite, on définit une classe C# FRDPE.MediaFoundation.Wrapper.MediaCapture, qui servira de façade entre l’Interface utilisateur et la librairie C/C+.
Cette classe n’est pas forcement utile, mais elle simplifiera l’utilisation de la librairie C/C++ dans les projets Windows Forms et WPF.

Par exemple, si je prends la méthode MFEnumDevices qui prend comme paramètre :

un pointeur sur une méthode de rappel : CBENUMDEVICES*cb
un pointeur sur un entier non signé : UINT32*count, qui contiendra le nombre de caméras disponibles
et qui retourne un HRESULT.

typedef void(CALLBACK CBENUMDEVICES)(const WCHAR* friendlyname);
 extern "C" WIN32MEDIACAPTURE_API HRESULT MFEnumDevices(CBENUMDEVICES *cb, UINT32 *count);

qui se traduit en C# par :

 public delegate void EnumDeviceHandler([Out, MarshalAs(UnmanagedType.LPWStr)] String device);
             [DllImport("Win32MediaCapture.dll", CallingConvention = CallingConvention.Cdecl)]

que l’appel se fait comme cela :

public UInt32 EnumDevices()
         {
             IntPtr Callback=Marshal.GetFunctionPointerForDelegate(new Import.MediaFoundation.EnumDeviceHandler((String devicename)=>
                 {
 
                     if (m_SyncronisationContext != null)
                     {
                         m_SyncronisationContext.Post(new System.Threading.SendOrPostCallback((o) =>
                         {
 
                             if (OnEnumDevices != null)
                             {
                                 OnEnumDevices(this, devicename);
                             }
 
                         }), null);
                     }
                 }));
                 
                 UIntPtr ptr=new UIntPtr();                
                 Helper.CheckAndThrowException("EnumDevice Error", Import.MediaFoundation.MFEnumDevices(Callback, ref ptr));
                 return ptr.ToUInt32();
         }

Il est alors préférable que l’appelant puisse l’appeler comme suit :

 m_mediaCapture = new MF.MediaCapture(picMediaCapture.Handle);
                     m_mediaCapture.OnEnumDevices += (asender, deviceName) =>
                         {
                             lstEnumDevices.Items.Add(deviceName);
                         };
                     m_CountDevice = m_mediaCapture.EnumDevices();   

Code complet de la classe FRDPE.MediaFoundation.Wrapper.MediaCapture :

namespace FRDPE.MediaFoundation.Wrapper
 {
     public class MediaCapture
     {
         IntPtr m_HwndPreview;
         SynchronizationContext m_SyncronisationContext;
         public delegate void InitializeCompletedEventHandler(Object sender,InitializeCompletedEventArgs e);
         public event InitializeCompletedEventHandler OnInitializationCompleted;
 
         public delegate void EnumDeviceHandler(Object sender, String device);
         public event EnumDeviceHandler OnEnumDevices;
         public SynchronizationContext Dispatcher {
             get { return m_SyncronisationContext; } 
             set { m_SyncronisationContext=value;} 
         }
         public class InitializeCompletedEventArgs:EventArgs
         {
             public AsyncStatus Status;
             public InitializeCompletedEventArgs(AsyncStatus status)
             {
                 Status=status;
             }
         }
         
         public MediaCapture(IntPtr hwndPreview)
         {
             Helper.CheckPointer(hwndPreview);
             m_HwndPreview = hwndPreview;
             m_SyncronisationContext = SynchronizationContext.Current;
             
         }
         public UInt32 EnumDevices()
         {
             IntPtr Callback=Marshal.GetFunctionPointerForDelegate(new Import.MediaFoundation.EnumDeviceHandler((String devicename)=>
                 {
 
                     if (m_SyncronisationContext != null)
                     {
                         m_SyncronisationContext.Post(new System.Threading.SendOrPostCallback((o) =>
                         {
 
                             if (OnEnumDevices != null)
                             {
 
                                 OnEnumDevices(this, devicename);
                             }
 
                         }), null);
                     }
                 }));
                 
                 UIntPtr ptr=new UIntPtr();
                 
                 Helper.CheckAndThrowException("EnumDevice Error", Import.MediaFoundation.MFEnumDevices(Callback, ref ptr));
 
 
 
                 return ptr.ToUInt32();
         }
         public void InitializeAsync(UInt32 numDevice)
         {
             try
             {
                 IntPtr callback = Marshal.GetFunctionPointerForDelegate(new 
                     FRDPE.Win32.Import.MediaFoundation.InitializeCompletedHandler((int statusInfo) =>
                 {
                     
                     if (m_SyncronisationContext!=null)
                     {
                         m_SyncronisationContext.Post(new System.Threading.SendOrPostCallback((o) =>
                         {
 
                             if (OnInitializationCompleted!=null)
                             {
                                 AsyncStatus status = (AsyncStatus)statusInfo;                                
                                 OnInitializationCompleted(this, new InitializeCompletedEventArgs(status));
                             }
 
                         }), null);
                     }
                     
                     
                 }));
                 Helper.CheckPointer(callback);
                 Helper.CheckAndThrowException("Could not initialize MediaFoundation", 
                     Import.MediaFoundation.MFInitialize(m_HwndPreview, callback, numDevice));
                 
             }
             catch(Exception)
             {
                 throw;
             }            
         }
         public void StartPreviewAsync(uint rotation)
         {
             Helper.CheckAndThrowException("Could not Start Preview", Import.MediaFoundation.MFStartPreview(rotation));
 
         }
         public void StopPreviewAsync()
         {
             Helper.CheckAndThrowException("Could not Stop Preview", Import.MediaFoundation.MFStopPreview());
 
         }
        
         public void SetProperty(VideoProcAmpProperty property,long value)
         {
             switch (property)
             {
                 case VideoProcAmpProperty.VideoProcAmp_Brightness:
                     Helper.CheckAndThrowException("Could not set the brightness", Import.MediaFoundation.MFSetBrightness(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Contrast:
                     Helper.CheckAndThrowException("Could not set the contrast", Import.MediaFoundation.MFSetContrast(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Hue:
                     Helper.CheckAndThrowException("Could not set the Hue", Import.MediaFoundation.MFSetHue(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Saturation:
                     Helper.CheckAndThrowException("Could not set the saturation", Import.MediaFoundation.MFSetSaturation(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Sharpness:
                     Helper.CheckAndThrowException("Could not set the Sharpness", Import.MediaFoundation.MFSetSharpness(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Gamma:
                     Helper.CheckAndThrowException("Could not set the gamma", Import.MediaFoundation.MFSetGamma(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_ColorEnable:
                     Helper.CheckAndThrowException("Could not set the Color", Import.MediaFoundation.MFSetColorEnable(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_WhiteBalance:
                     Helper.CheckAndThrowException("Could not set the WhiteBalance", Import.MediaFoundation.MFSetWhiteBalance(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_BacklightCompensation:
                     Helper.CheckAndThrowException("Could not set the Backlight Compensation", Import.MediaFoundation.MFSetBacklightCompensation(value));
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Gain:
                     Helper.CheckAndThrowException("Could not set the gain", Import.MediaFoundation.MFSetGain(value));
                     break;
                 default:
                     break;
             }
         }
         public FRDPE.Win32.Import.MediaFoundation.Capabilities GetProperty(VideoProcAmpProperty property)
         {
             FRDPE.Win32.Import.MediaFoundation.Capabilities Caps = new FRDPE.Win32.Import.MediaFoundation.Capabilities();
             UInt32 hr=0;
             String ErrorMessage=String.Empty;
             switch (property)
             {
                 case VideoProcAmpProperty.VideoProcAmp_Brightness:
                     ErrorMessage="Could not get the brightness";
                     hr=Import.MediaFoundation.MFGetBrightness(Caps);                    
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Contrast:
                     ErrorMessage="Could not get the contrast";
                     hr=Import.MediaFoundation.MFGetContrast(Caps);            
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Hue:
                     ErrorMessage="Could not get the hue"; 
                     hr= Import.MediaFoundation.MFGetHue(Caps);
                     
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Saturation:
                     ErrorMessage="Could not get the saturation";
                     hr = Import.MediaFoundation.MFGetSaturation(Caps);
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Sharpness:
                     ErrorMessage="Could not get the Sharpness";
                     hr=Import.MediaFoundation.MFGetSharpness(Caps);
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Gamma:
                     ErrorMessage="Could not get the gamma";
                     hr=Import.MediaFoundation.MFGetGamma(Caps);
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_ColorEnable:
                     ErrorMessage="Could not get the color";
                     hr=Import.MediaFoundation.MFGetColorEnable(Caps);
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_WhiteBalance:
                     
                     ErrorMessage="Could not get the white balance";
                     hr=Import.MediaFoundation.MFGetWhiteBalance(Caps);
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_BacklightCompensation:
                     ErrorMessage="Could not get the Backlight Compensation";
                     hr=Import.MediaFoundation.MFGetBacklightCompensation(Caps);
                     break;
                 case VideoProcAmpProperty.VideoProcAmp_Gain:
                     ErrorMessage="Could not get the Gain";
                     hr=Import.MediaFoundation.MFGetGain(Caps);
                     break;
                 default:
                     break;
             }
             if (hr == 0x80070490)
             {
                 //Not supported
                 return null;
             }
             else
             {
                 Helper.CheckAndThrowException(ErrorMessage,hr);
             }
 
             return Caps;
         }
         public enum VideoProcAmpProperty
         {
             VideoProcAmp_Brightness    = 0,
             VideoProcAmp_Contrast    = ( VideoProcAmp_Brightness + 1 ) ,
             VideoProcAmp_Hue    = ( VideoProcAmp_Contrast + 1 ) ,
             VideoProcAmp_Saturation    = ( VideoProcAmp_Hue + 1 ) ,
             VideoProcAmp_Sharpness    = ( VideoProcAmp_Saturation + 1 ) ,
             VideoProcAmp_Gamma    = ( VideoProcAmp_Sharpness + 1 ) ,
             VideoProcAmp_ColorEnable    = ( VideoProcAmp_Gamma + 1 ) ,
             VideoProcAmp_WhiteBalance    = ( VideoProcAmp_ColorEnable + 1 ) ,
             VideoProcAmp_BacklightCompensation    = ( VideoProcAmp_WhiteBalance + 1 ) ,
             VideoProcAmp_Gain    = ( VideoProcAmp_BacklightCompensation + 1 ) 
         };
         public enum AsyncStatus
         {
             Error=0,
             EngineInitialized,
             PreviewStarted,            
             PreviewStopped            
         };
     }
     
 }

Ce qu’il faut juste noter ici :

Le constructeur prend un pointeur IntPtr qui sera un HANDLE (HWDN) de fenêtre.
Qu’on convertit les délégués en pointeurs de fonctions à l’aide de la méthode statique GetFunctionPointerForDelegate, de la classe Marshal.
Une fois rappelé par la librairie C/C++, on invoque un évènement auquel se serait abonné le client Windows Forms ou WPF, tout prenant la précaution d’usage, de bien se synchroniser avec le thread appelant à l’aide de l’objet SynchronisationContext.
Qu’on utilise une la méthode CheckAndThrowException(), pour vérifier et lever une exception en fonction du HRESULT retourné.

Note : pour de plus amples informations concernant l’interopérabilité entre C/C++ et C# via l’attribut DLLImport, reportez vous à mon précédant billet.

Une dernière classe nommée Helper, permet de :

vérifier la validité des pointeurs,
vérifier la validité des HRESULTs
de lever des exceptions, avec le bon message d’erreur associé au HRESULT

Code complet de la classe Helper

namespace FRDPE.MediaFoundation
 {
     public static class Helper
     {
         /// 
         /// Check the Pointer
         /// 
         /// 
         public static void CheckPointer(IntPtr ptr)
         {
             unsafe
             {
                 if (ptr.ToPointer() == null)
                 {
                     throw new ArgumentNullException();
                 }
             }
         }
         public static IntPtr GetFunctionPointeurFromInitializeCompletedHandler(MediaCapture mediaCapture)
         {
             return Marshal.GetFunctionPointerForDelegate(new FRDPE.Win32.Import.MediaFoundation.InitializeCompletedHandler((int statusInfo) =>
                     {
                         var s = statusInfo;
                         if (mediaCapture!=null)
                         {
                             if (mediaCapture.Dispatcher!=null)
                             {
                                 mediaCapture.Dispatcher.Post(new System.Threading.SendOrPostCallback((o) =>
                                     {
                                         
                                         
                                     }), statusInfo);
                             }
                         }
                     }));
 
         }
         public static String FormatErrorMessage(String Message,UInt32 hr)
         {
             return String.Format("{0} : 0x{1:X}L", Message, hr);
         }
         public static Boolean FAILED(UInt32 hr)
         {
             return (hr > 0);
         }
         public static Boolean SUCCEEDED(UInt32 hr)
         {
             return (hr == 0);
         }
         public static void CheckAndThrowException(String message,UInt32 hr)
         {
             if (Helper.FAILED(hr))
             {
                 String InternalMessage;
                 Int32 size = 0;
                 IntPtr ptr = IntPtr.Zero ;
                 try
                 {
                     size = (Int32)FRDPE.Win32.Import.MediaFoundation.GetErrorMessageSize(hr);
 
                     ptr = Marshal.AllocHGlobal(size);
 
                     UInt32 errorHR = FRDPE.Win32.Import.MediaFoundation.GetErrorMessage(hr, ptr);
                     if (Helper.FAILED(errorHR))
                     {
                         throw new ApplicationException(Helper.FormatErrorMessage("Catastrophic failure : No pointer !!!", errorHR));
                     }
 
                     InternalMessage = Marshal.PtrToStringUni(ptr);
                     
                 }
                 finally
                 {
                     Marshal.FreeCoTaskMem(ptr);
                 }
                 
 
                 throw new ApplicationException(Helper.FormatErrorMessage(String.Format("{0} : Internal Message : {1}",message,InternalMessage), hr));
             }
         }
     }
 }

Interface Utilisateur Windows Forms ou WPF.

C’est la partie la plus simple, il suffit d’ajouter notre assembly FRDPE.MediaFoundation.Wrapper.dll en tant que référence.

Ensuite pour démarrer la prévisualisation de la vidéo, il suffit tout simplement :

D’instancier notre classe MediaCapture en lui passant un HANDLE de fenêtre.
De s’abonner à l’évènement OnInializationCompleted,
D’initialiser la capture InitializeAsync(m_numDevice) avec le bon index de caméra
Une fois initialisé, de démarrer la capture StartPreviewAsync()

 private void cmdStartPreview_Click(object sender, EventArgs e)
         {
             if (m_CountDevice == 0) return;
 
             try
             {
                 IntPtr ptr = picMediaCapture.Handle;                
                 m_mediaCapture = new MF.MediaCapture(ptr);
                 m_mediaCapture.OnInitializationCompleted += (asender, ae) =>
                     {
                         if (ae.Status==MF.MediaCapture.AsyncStatus.EngineInitialized)
                         {                           
                             try
                             {
                                 m_mediaCapture.StartPreviewAsync(m_ConfigPreview.Rotation);
                                 
                             }
                             catch(Exception ex)
                             {
                                 MessageBox.Show(ex.Message);
                             }
                             
                         }
                         else if(ae.Status==MF.MediaCapture.AsyncStatus.PreviewStarted)
                         {
                             try
                             {
 
                                 Brigtness = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_Brightness);
                                 Contrast = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_Contrast);
                                 Saturation = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_Saturation);
                                 Hue = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_Hue);
                                 Sharpness = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_Sharpness);
                                 Gamma = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_Gamma);
                                 ColorEnable = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_ColorEnable);
                                 BacklightCompensation = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_BacklightCompensation);
                                 Gain = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_Gain);
                                 WhiteBalance = m_mediaCapture.GetProperty(MF.MediaCapture.VideoProcAmpProperty.VideoProcAmp_WhiteBalance);
                             }
                             catch(Exception ex)
                             {
                                 MessageBox.Show(ex.Message);
                                 
                             }
                             finally
                             {
                                 FormatTrackBar();
                             }
 
 
                             
                         }
                         else if (ae.Status == MF.MediaCapture.AsyncStatus.PreviewStopped)
                         {
                             MessageBox.Show("Preview Stopped");
                         }
                         else if (ae.Status == MF.MediaCapture.AsyncStatus.Error)
                         {
                             MessageBox.Show("Engine Error");
                         }
                     };
 
                 m_mediaCapture.InitializeAsync(m_numDevice);
 
                 
             }
             catch (Exception ex)
             {
 
                 MessageBox.Show(ex.Message);
             }
             
 
 
         }

Pour visualiser la vidéo il nous faut un Handle de fenêtre. Avec les Windows Form,s c’est pas trop compliqué, il suffit tout simplement comme dans l’exemple fournit, d’ajouter un PictureBox qui possède la propriété Handle. D’ailleurs tous les objets qui possèderaient cette propriété, comme l’objet Form lui même, sont de bons candidats.

Vous noterez également dans le code associé à cet article, qu’il est possible de modifier certaines propriétés de la caméra, comme, le contraste, la luminosité, la saturation, Hue, Gamma, Sharpness, la rotation, etc..

Si vous souhaitez utiliser cette librairie avec WPF, qui n’a plus réellement de notion de Handle associé aux objets, il suffira d’utiliser l’objet WindowsFormsHost, comme illustré dans l’extrait XAML suivant :

<Window x:Class="ClientWPFMediaCapture.MainWindow"
         xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
          xmlns:wf="clr-namespace:System.Windows.Forms;assembly=System.Windows.Forms" 
         Title="MainWindow" Height="350" Width="525">
     <Grid>
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="86*"/>
             <ColumnDefinition Width="431*"/>
         Grid.ColumnDefinitions>
         <Grid.RowDefinitions>
             <RowDefinition/>
         Grid.RowDefinitions>
         <WindowsFormsHost Margin="0" Grid.Column="1">
             <wf:PictureBox Width="100" Height="100"  x:Name="pctMediaCapture">wf:PictureBox>
         WindowsFormsHost>
         <Button Content="Preview" HorizontalAlignment="Left" Height="19" Margin="6,14,0,0" VerticalAlignment="Top" Width="57" Click="cmdStartPreview_Click"/>
     Grid>
 Window>

Télécharger le code

Eric