Introduction à Microsoft Surface - Version 1.0
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Introduction à Microsoft Surface
Version 1.0
Adrien OLIVENCIA
Jérémy BASCANS
James RAVAILLE
http://blogs.dotnet-france.com/jamesr
2 Introduction à Microsoft Surface
Sommaire
1 Présentation .................................................................................................................................... 3
1.1 Qu’est-ce que Microsoft Surface ? .......................................................................................... 3
1.2 La reconnaissance tactile ........................................................................................................ 4
1.2.1 Le fonctionnement .......................................................................................................... 4
1.2.2 Les Tags............................................................................................................................ 5
2 Le kit de développement ................................................................................................................. 6
2.1 Installation ............................................................................................................................... 6
2.2 Utilisation du simulateur ......................................................................................................... 6
2.2.1 Les outils .......................................................................................................................... 7
2.2.2 La fonction d’enregistrement .......................................................................................... 7
2.3 Cas exceptionnel : Installer Surface SDK sur un Windows non supporté ............................... 7
3 Microsoft Surface et le Framework .Net ....................................................................................... 12
3.1 WPF et XNA ........................................................................................................................... 12
3.2 Portage WPF vers Microsoft Surface ..................................................................................... 12
3.3 Développer pour Microsoft Surface ...................................................................................... 14
3.3.1 Quelques détails ............................................................................................................ 14
3.3.2 Création de projets ........................................................................................................ 14
4 Conclusion ..................................................................................................................................... 16
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
3 Introduction à Microsoft Surface
1 Présentation
1.1 Qu’est-ce que Microsoft Surface ?
Sorti en 2008, et présenté à plusieurs reprises par Microsoft, Surface est
un des rares produits issu d’un projet Microsoft Research, à avoir trouvé
une utilisation commerciale.
Microsoft Surface est un ensemble de technologies logicielles et matérielles utilisant une
interface tactile multipoints. Le principe est d’offrir une interface entièrement pilotable de manière
tactile, sans souris ni clavier, et par plusieurs utilisateurs simultanément. Il est ainsi possible
d’interagir avec plusieurs éléments en même temps, que ce soit des menus, boutons, images,…
Techniquement, Microsoft Surface
n’a que peu de différences avec un
ordinateur (3) classique. Le produit
fonctionne avec un processeur Intel Core 2
Duo (ou Core 2 Quad selon les modèles) et
d'une carte graphique gérant la
composition de l’affichage de Vista (Aero).
L’affichage est effectué par un projecteur
(4) sur un écran de 30’’(en 1024x768) (1), et
la reconnaissance tactile par différentes
caméras et capteurs infrarouges (2). Le tout
est intégré dans une table. Enfin,
l’ensemble fonctionne avec une version
Source : Popular Mechanics
adaptée de Windows Vista SP1, intégrant
l’interface de Surface, et ses API (utilisables
par les développeurs).
Voici quelques images montrant une utilisation d’une table, intégrant la technologie
Microsoft Surface :
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
4 Introduction à Microsoft Surface
Le coût d’acquisition de cette table est très onéreux. Le prix d’une table décrite ci-dessus,
pour les développeurs d’applications .NET est de 13 000 € (au 24/03/2009), incluant une licence
Microsoft Surface Software et 5 licences d’utilisation du SDK (voir la prochaine partie de ce cours).
Lors de la réunion DemoFest (réunion annuelle avec des universitaires américains), Microsoft
a présenté un nouveau type d’écran sous le nom de « Sphere », directement inspiré de Microsoft
Surface. Comme son nom l’indique, cet écran n’est pas plat, mais sphérique. Voici une illustration de
ce bijou de technologie :
1.2 La reconnaissance tactile
1.2.1 Le fonctionnement
Plutôt que d’utiliser un écran tactile tel qu’une tablette PC, Microsoft Surface exploite,
comme précisé précédemment, des caméras et capteurs
infrarouges. Ceux-ci récupèrent la lumière renvoyée par ce qui
se rapproche de l’écran. Microsoft Surface ne récupère donc
pas de simples points, mais une véritable image en niveaux de
gris, reflétant les différents contacts. A partir de cela, il est
capable de reconnaitre trois catégories d’empreintes :
- les doigts
- les objets taggués (décrits dans la prochaine
partie)
- les autres empreintes que nous appellerons « blob ».
Cela permet d’éviter les sélections non désirées (quand le contact n’est pas reconnu comme
un doigt par exemple). De plus, cela permet de différencier certains évènements dans le code.
Par extension, il est aussi potentiellement possible de scanner un document, bien que la
résolution de l’image ne soit pas assez importante pour avoir une qualité correcte.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
5 Introduction à Microsoft Surface
1.2.2 Les Tags
Nous avons vu que Microsoft Surface était capable de reconnaître des objets, néanmoins,
cela n’est possible que par le biais de tags associés aux objets. Un tag est une image particulière qu’il
est nécessaire de coller sur l’objet devant être reconnu. Une fois l’objet posé sur la table, Microsoft
Surface pourra lire l’information donnée par l’image, et pourra reconnaitre l’objet. Sans ce tag,
Surface considèrera l’objet comme un blob.
Il existe deux types de tags : les Byte Tags et les Identity Tags. Les Byte Tags sont codés sur 8
bits et peuvent donc avoir 256 valeurs différentes. Les Identity Tags sont codés sur 128 bits, ce qui
permet des milliards de valeurs différentes.
Les deux types de Tags utilisent des modèles différents.
- Un Byte Tags :
- Un Identity Tags :
On remarquera surtout que les modèles ne sont pas symétriques, et permettent donc
d’obtenir l’orientation de l’objet. Sur chacun de ces modèles sont ajoutés d’autres points blancs (8
pour un Byte Tag, 128 pour un Identity Tag) servants à coder la valeur du Tag.
En pratique, un Byte Tag sert plutôt à détecter la nature de l’objet posé (verre, outil,…). En
effet, on peut utiliser dans la pratique un tag identique ; on installe un tag unique sur plusieurs
objets semblables. Par exemple lors d’une conférence, plusieurs personnes pourront utiliser des
objets identiques afin d’exécuter des actions semblables simultanément.
Tandis qu’un Identity Tag permet de réellement identifier chaque objet, notamment si ceux-ci
communiquent avec Microsoft Surface (un téléphone portable par Bluetooth par exemple).
Lors du développement d’applications avec Microsoft Surface, il faudra donc bien faire attention à
utiliser le bon type de Tag afin d’éviter de se retrouver :
- Soit limité par le nombre d’empreintes.
- Soit avec une application trop lourde.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
6 Introduction à Microsoft Surface
2 Le kit de développement
2.1 Installation
Afin de pouvoir concevoir et développer des applications pour Microsoft Surface, il est
nécessaire d’installer le kit de développement (SDK). Celui-ci intègre tout ce qui est nécessaire pour
développer et tester les applications, tel que Microsoft Surface Simulator. Au besoin, il peut être
nécessaire d’installer aussi le Framework XNA 2.0.
Avec le SDK, sont inclus plusieurs exemples. Par défaut, ils ne sont pas accessibles dans
l’Application Launcher du simulateur. On peut accéder à ces exemples depuis le menu démarrer (MS
Surface SDK 1.0 -> Samples), en les extrayant de l’archive, puis en exécutant le script batch
« InstallSample.bat » pour les installer dans Surface.
2.2 Utilisation du simulateur
Au lancement du Simulateur, une application est automatiquement lancée. On accède aux
applications par les quatre coins du simulateur (l’orientation de l’Application Launcher dépend du
coin par lequel on y a accédé). On obtient alors la fenêtre suivante :
En haut de la fenêtre se trouve une barre d’onglets donnant accès aux outils et aux fonctions
d’enregistrement. La partie outil permet de sélectionner les options d’interaction avec la fenêtre.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
7 Introduction à Microsoft Surface
2.2.1 Les outils
La première icône, en forme de croix, permet de sélectionner les contacts présents sur la
table, afin de pouvoir interagir avec eux.
La deuxième icône permet de simuler les doigts. Comme nous l’avons vu, Microsoft Surface
différencie les formes, mais sur le simulateur, pour que le contact soit reconnu comme un doigt, il
faudra passer obligatoirement par cet outil.
La troisième icône sert à simuler les contacts quelconque, qui ne sont ni des tags, ni des
doigts.
Les deux autres parties sont dédiées à la simulation des Tags. La première correspond aux
Byte Tags, auquel on peut assigner une valeur (en hexadécimal, parmi les 256 possibles). La seconde
partie correspond donc aux Identity Tags, pour lesquels on peut préciser la Série et la Valeur.
Pour bien comprendre les différences, il est possible d’utiliser l’application DataVisualizer.
L’application affiche des informations sur chaque contact. Pour pouvoir utiliser plusieurs contacts
simultanément, le simulateur gère plusieurs souris (dont le touchpad des ordinateurs portables), il
est aussi possible de fixer un contact en maintenant le clic gauche, puis en effectuant un clic droit
(manipulable ensuite avec l’outil de sélection).
Enfin, les deux icônes à droite permettent respectivement de supprimer l’ensemble des
contacts fixés, ou de les cacher.
2.2.2 La fonction d’enregistrement
Cette fonction est assez simple. Elle permet d’enregistrer l’ensemble des contacts effectués
et de les refaire automatiquement.
Le début de l’enregistrement se fait en cliquant sur le bouton « Enregistrer ». Ensuite, tous
les contacts seront enregistrés. En arrêtant l’enregistrement (bouton « Stop »), le simulateur
demande à l’utilisateur où enregistrer le fichier.
Pour lire une séquence enregistré, il faut simplement charger le fichier enregistré avec le
bouton Ouvrir, puis cliquer sur Play.
2.3 Cas exceptionnel : Installer Surface SDK sur un Windows non supporté
Le SDK n’est officiellement compatible qu’avec Windows Vista SP1 32 bits et Windows 7 32
bits, édition Professionnelle, Entreprise et Intégrale. Sur n’importe quelle autre version de Windows,
notamment les Windows 64 bits, l’installeur refusera tout simplement de se lancer.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
8 Introduction à Microsoft Surface
Il est possible d’outrepasser ces conditions en utilisant Orca. L’installeur d’Orca se trouve
dans le dossier C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\Orca.msi (uniquement si Visual
Studio 2008 est installé). S’il n’y est pas, téléchargez-le à cette adresse :
http://www.technipages.com/download-orca-msi-editor.html, et installez-le.
Contrairement à sa première version, le SP1 du SDK est fourni sous la forme d’un fichier
exécutable qui extrait l’installeur MSI. Comme il n’est pas évident de récupérer cet installeur dans les
fichiers temporaires, nous allons extraire le fichier manuellement. Pour cela, il suffit d’ouvrir le fichier
exécutable avec Visual Studio. Nous obtenons alors ceci :
En développant la partie RCDATA, une liste d’élément apparait, dont un est nommé
« MSI00 ». Faites clic-droit dessus, puis Exporter. Enregistrez-le où vous souhaitez, et modifiez
l’extension en .msi à la place .bin.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
9 Introduction à Microsoft Surface
Nous pourrions dès lors utiliser directement Orca pour supprimer la condition d’installation.
Le problème c’est que, durant l’installation, une exécutable est exécutée en 64 bits alors qu’elle
devrait se lancer en 32 bits, causant une erreur et annulant l’installation. Nous avons besoin de
modifier le comportement de cette exécutable. Pour cela, nous allons extraire tout le contenu de
l’installeur MSI. Lancez un invité de commandes (cmd.exe) en mode Administrateur, placez-vous
dans le dossier contenant l’installeur MSI, puis tapez la commande suivante : « msiexec /a
SurfaceSDK_SP1.msi /qb TARGETDIR=c :\sdk », en étant dans le dossier contenant l’installeur, et
adaptant bien sûr le nom du fichier MSI. Le paramètre TARGETDIR indique le dossier où seront extrait
les fichiers, adaptez-le (en évitant espaces et accents).
Dans ce dossier, nous avons toujours un installeur MSI, mais aussi plusieurs autres dossiers.
Lancez l’invite de commandes de Visual Studio en mode Administrateur, puis placez-vous dans le
dossier où vous avez extrait l’installeur, puis dans le dossier « Microsoft Surface\v1.0\ ». Enfin,
exécutez la commande :
corflags setupcustomaction.exe /32bit+ /force
Il nous reste enfin à supprimer la condition d’installation avec Orca. Faites clic-droit sur
l’installeur MSI (celui présent avec les fichiers extraits du premier MSI), puis « Edit with Orca ».
Cherchez et sélectionnez la table « LaunchCondition » dans la partie de gauche dans Orca.
Supprimez-la en effectuant un clic-droit dessus puis Drop Table.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE
10 Introduction à Microsoft Surface
Sauvegardez ensuite le fichier (File -> Save). L’installation devrait alors pouvoir se faire sans
soucis.
Pour les utilisateurs de Windows 64 bits, bien que le SDK se soit bien installé, le simulateur
ne fonctionne pas, cela se traduit simplement par un crash du simulateur au lancement. Il est
néanmoins possible de résoudre le problème en forçant l’application à se lancer en 32 bits et non en
64 bits. Pour cela, lancez l’invite de commandes de Visual Studio, placez -vous dans le dossier du
simulateur (Program Files (x86)\Microsoft SDKs\Surface\v1.0\Tools\Simulator), et exécutez la
commande :
corflags SurfaceSimulator.exe /32bit+ /force
Cette même commande doit être utilisée pour tous les fichiers exécutables du dossier
« Program Files (x86)\Microsoft Surface\v1.0 » (Attract.exe, AttractConfig.exe, SurfaceInput.exe,
SurfaceOutOfOrder.exe et SurfaceShell.exe). Une fois fait, le simulateur devrait pouvoir se lancer
sans problème.
Au même titre que le simulateur, si l’application se lance en 64 bits, elle plantera au
démarrage. Ce qui fait que l’ensemble de vos applications devront être compilés en 32 bits. Par
défaut, Visual Studio compile en utilisant la plateforme Any CPU, qui fait que l’exécutable se lance
dans la même architecture que l’OS (donc 64 bits avec un Windows 64 bits). Pour modifier ce
comportement, une fois le projet chargé, il faut aller sur Générer -> Gestionnaire de configurations.
Dans la fenêtre : « Plateforme de la solution active -> Nouveau ». Sélectionnez x86 comme
nouvelle plateforme.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE11 Introduction à Microsoft Surface
Vérifiez que la plateforme du projet soit bien « x86 » puis fermez la fenêtre. Recompilez
votre application. Elle ne devrait plus planter au lancement (à noter que les binaires compilées en
x86 se trouvent dans le dossier \bin\x86).
Pour les exemples du SDK, après avoir utilisé le script batch pour les ajouter à l’Application
Launcher, il est nécessaire de recompiler toute la solution en mode Release et en 32 bits depuis
Visual Studio (avec les modifications vues précédemment), puis de déplacer la nouvelle exécutable
de chaque application de {nom_application}\bin\x86\Release vers {nom_application}\bin\Release
(par exemple de E:\VS2008\Surface\WPF\DataVisualizer\bin\x86\Release\DataVisualizer.exe vers
E:\VS2008\Surface\WPF\DataVisualizer\bin\Release\DataVisualizer.exe).
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE12 Introduction à Microsoft Surface
3 Microsoft Surface et le Framework .Net
3.1 WPF et XNA
Microsoft Surface étant bâti sur Windows Vista SP1, a été conçu de manière à ne pas changer
les habitudes de développement. Ainsi Microsoft Surface utilise le Framework .Net, notamment WPF
et XNA. Les applications peuvent être développées entièrement depuis Visual Studio 2008 avec le
SDK de Surface. Néanmoins, quelques modifications doivent être effectuées pour rendre une
application WPF compatible avec Surface. On trouve alors des contrôles adaptés à Surface (que ce
soit des boutons, sliders, listes,…) ainsi que d’autres contrôles supplémentaires, conçus
spécifiquement pour Surface. L’utilisation de ces deux technologies permet à Surface d’exploiter au
mieux la carte graphique pour l’affichage.
3.2 Portage WPF vers Microsoft Surface
Lors d’un portage d’une application WPF vers Surface, les changements sont minimes. Dans
l’ordre des changements à effectuer :
- Ajouter la référence pour Microsoft.Surface.Presentation (Projet -> Ajouter une référence)
- Ajouter les espaces de nom suivant dans le code C# :
o Microsoft.Surface.Presentation
o Microsoft.Surface.Presentation.Controls
- Renommer dans le code C# le type de classe Window en SurfaceWindow
- Ajouter le namespace xmlns:s="http://schemas.microsoft.com/surface/2008" dans le
XAML
- Modifier les contrôles pour leurs équivalents Surface dans le XAML
Par exemple, voici un bloc de code XAML (WPF) :
// XAML
Button
CheckBox
CheckBox
RadioButton
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE13 Introduction à Microsoft Surface
Voici le bloc de code équivalent pour Microsoft Surface :
// XAML
Button
CheckBox
CheckBox
RadioButton
Nous pouvons observer que :
- Des espaces de noms sont à ajouter.
- Les noms des contrôles doivent être modifiés.
Le défaut d’un portage sans ces modifications, ne permettra pas d’exploiter au mieux les
fonctionnalités de Microsoft Surface.
Voici un tableau de correspondance des contrôles entre WPF et Surface :
WPF Surface
Button SurfaceButton
CheckBox SurfaceCheckBox
ContentControl SurfaceContentControl
ContextMenu SurfaceContextMenu
Control SurfaceControl
FrameworkElement SurfaceFrameworkElement
InkCancas SurfaceInkCancas
ItemsControl SurfaceItemsControl
ListBox SurfaceListBox
ListBoxItem SurfaceListBoxItem
Menu SurfaceMenu
MenuItem SurfaceMenuItem
PasswordBox SurfacePasswordBox
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE14 Introduction à Microsoft Surface
Popup SurfacePopup
RadioButton SurfaceRadioButton
RepeatButton SurfaceRepeatButton
ScrollBar SurfaceScrollBar
ScrollViewer SurfaceScrollViewer
Slider SurfaceSlider
TextBox SurfaceTextBox
Thumb SurfaceThumb
ToggleButton SurfaceToggleButton
Track SurfaceTrack
UserControl SurfaceUserControl
Window SurfaceWindow
Les contrôles WPF classiques restant accessibles, il faudra faire veiller à utiliser ceux de
Surface si un équivalent existe.
3.3 Développer pour Microsoft Surface
3.3.1 Quelques détails
Développer pour Microsoft Surface implique quelques changements dans le fonctionnement
de l’application. Bien qu’utilisant un concept multi-utilisateurs, Surface ne peut afficher qu’une
application à la fois. Cela implique que l’application lancée occupe l’intégralité de l’espace d’affichage
(qui pour rappel a une résolution de 1024*768). Il n’est pas donc pas nécessaire de spécifier la
hauteur ou la largeur de la fenêtre. Plusieurs applications peuvent toutefois être lancées, mais elles
ne pourront s’afficher en même temps. Il faut alors utiliser l’Application Launcher pour passer d’une
application à une autre.
De plus, une application Surface n’est pas forcément destinée à une utilisation spécifique.
Par exemple, elle peut donner la possibilité à deux utilisateurs d’effectuer des tâches différentes en
même temps (un utilisateur trie des photos pendant que l’autre regarde ses mails).
3.3.2 Création de projets
Commencer un projet pour Surface se fait de manière classique sur Visual Studio 2008. C'est-
à-dire en utilisant le menu Nouveau -> Projet. Il reste ensuite à aller sur Visual C# et à sélectionner le
type de projet «Surface».
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE15 Introduction à Microsoft Surface
Comme nous l’avons vu précédemment, il est possible d’utiliser WPF ou XNA pour
développer notre application. Nous nous contenterons de WPF pour le moment.
Une fois le projet créé, le fonctionnement à l’intérieur de Visual Studio est identique à celui
d’un projet WPF. On trouve toujours le code XAML et le code C#. A noter qu’avant d’exécuter
l’application, il est nécessaire de lancer le simulateur.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLE16 Introduction à Microsoft Surface
4 Conclusion
Il est évident que Microsoft Surface est une technologie d’avenir. Même si son coût onéreux
freine son déploiement dans les entreprises et dans notre vie courante, cette technologie permettra
d’utiliser les matériels et logiciels informatiques autrement, par rapport à leurs utilisations actuelles.
Microsoft propose un kit de développement, permettant d’utiliser pleinement les possibilités
de cette technologie, et de pouvoir développer des applications .NET s’intégrant pleinement dans
l’environnement.
Dotnet France Association / Adrien OLIVENCIA - Jérémy BASCANS - James RAVAILLEVous pouvez aussi lire
