In 2007 werd Surface geïntroduceerd. Een revolutionair product dat tot op de dag van vandaag nog geen concurrentie kent. Toch is Surface niet het succes geworden waar iedereen op hoopte: mede door de crisis die kort na de lancering uitbrak is het aantal verkochte eenheden ver onder de maat gebleven.
Maar Microsoft is niet stil blijven zitten. Terwijl de hele wereld zich verwonderde over de mogelijkheden van een dergelijk systeem zijn ze verder gegaan en hebben de volgende versie ontwikkeld.
Wat was Surface ook al weer?
Voor die mensen die Surface niet kennen, of voor hen die al weer vergeten waren wat het nou ook al weer precies was, zal ik eerst even kort uitleggen wat Surface nou weer precies is.
Surface is een vision based, table-computing device. OK, dat moet ik even uitleggen. Veel mensen noemen Surface een grote touch-table maar dat is niet correct. Surface is niet gebaseerd op touches maar op beeldherkenning. In tegenstelling tot andere touch apparaten zoals smartphones en iPads werkt het systeem niet met een aanraakgevoelig scherm. In Surface zitten technieken die de reflectie van infrarood licht herkennen en daar acties op kunnen ondernemen. Hoewel dit op het eerste gezicht niet veel verschil lijkt uit te maken is dit toch een fundamenteel andere benadering dan touch. Immers, met touch kun je ‘zien’ of er een vinger op het scherm geplaatst wordt maar kun je geen onderscheid maken tussen wat er nu precies op het scherm geplaatst wordt. Met een vision-based systeem kan dat wel. Een vinger op het scherm heeft een hele andere vorm dan, laten we zeggen, een koffie kopje. In je code kun je van dit onderscheid gebruik maken door een andere actie uit te laten voeren als je andere vormen op het scherm ziet. Ook is het hierdoor mogelijk om te raden welke gebruiker iets doet. Als je een vinger op het scherm plaatst ziet het systeem het punt waar je je vinger neerzet. Maar aangezien de rest van de vinger (die boven het scherm hangt) een soort van schaduw maakt kan het systeem afleiden in welke richting de vinger is geplaatst. Op die manier kunnen we dus afleiden welke gebruiker iets doet. Dit is iets wat met andere technieken eigenlijk niet te doen is. Verder kun je door het plaatsen van barcode-achtige stickers op objecten deze objecten ook laten herkennen door het systeem. Ieder object heeft zijn eigen, infrarood reflecterende, barcode op de onderkant zitten, zodat Surface kan zien welk object waar geplaatst is en hoe het object geroteerd is op het scherm.
Surface is wat Microsoft noemt een vorm van ‘table-computing’. In gewoon Nederlands: het is een tafel met een computer. De begrip tafel is belangrijk: mensen zitten aan een tafel om dingen te doen en samen een taak te volbrengen. Door het oppervlak van die tafel interactief te maken en te laten reageren op wat de mensen doen kun je het werk van die gebruikers enorm vergemakkelijken. Aangezien een tafel ook voor andere dingen gebruikt wordt dan het besturen van software, denk aan het plaatsen van koppen koffie of het neerleggen van je voeten na een lange dag coderen, is het systeem enorm robuust gemaakt. Surface kan een gewicht van 80 kg hebben voordat het scherm het begeeft. Ook dat is iets wat je met een gewoon touch-systeem liever niet doet!
Samengevat: Surface is een enorm robuust systeem dat objecten kan herkennen. Die combinatie maakt het tot een uniek concept.
Nieuwe hardware
In januari 2011 heeft Microsoft de nieuwe Surface aangekondigd. Helaas loopt de productie ervan wat vertraging op, met als gevolg dat we op het moment van schrijven nog niet over de hardware kunnen beschikken. Verwacht is dat het apparaat in het eerste kwartaal van 2012 te krijgen zal zijn.
Er zijn enorm veel verbeteringen in het systeem aangebracht. Een van de grootste verschillen is de fabrikant. Surface 1.0 is geheel bedacht en gemaakt door Microsoft. Als je zo’n apparaat wilde bestellen moest je dus bij Microsoft zijn. Nu is Microsoft van oudsher een software bedrijf en dus hebben ze besloten om een samenwerking met Samsung aan te gaan. Samsung levert de hardware en Microsoft levert de software. In principe betekent dit dat andere fabrikanten ook Surface hardware zouden kunnen gaan maken op basis van de software die Microsoft levert.
De officiele naam van het apparaat is dan ook niet Surface 2.0 maar de Samsung SUR40 for Microsoft Surface; de software heet officieel Microsoft SDK For Surface. Een hele mond vol; ik blijf het dan ook de rest van dit artikel Surface V2 noemen.
Ik zal de verschillen tussen V1 en V2 even op een rijtje zetten:
|
|
Surface V1
|
Surface V2
|
|
Fabrikant
|
Microsoft
|
Samsung
|
|
Processor
|
Intel Core 2 Duo 2.13 Ghz
|
AMD Athlon X2 245e 2.9Ghz Dual Core
|
|
Schermresolutie
|
1024 x 768
|
1920 x 1080
|
|
Input
|
6 USB poorten, Bluetooth, Audio-in, Ethernet, Wireless
|
4 USB, Bluetooth, SD Card reader, Ethernet, Wireless
|
|
Video Output
|
VGA out
|
HDMI out, VGA Out
|
|
Audio Output
|
Audio Jack
|
2x Audio Jack, HDMI, SPDIF
|
|
Geheugen
|
2 GB (niet uitbreidbaar)
|
4 GB (uitbreidbaar)
|
|
Opslag
|
25GB SATA
|
320GB SATA 2, uitbreidbaar
|
|
Schermgrootte
|
30 inch
|
40 inch
|
|
Gewicht
|
90 Kg
|
39.5 Kg
|
|
Dikte
|
54 cm
|
10 cm
|
Er zijn dus nogal wat verbeteringen doorgevoerd. Maar het verhaal stopt hier niet. Ook op het software gebied zijn er nogal wat veranderingen in V2 ten opzichte van V1.
Figuur 1
Nieuwe software…
Als eerste is het onderliggende besturingssysteem aangepast. Voor veel mensen was het een schok om te ontdekken dat futuristische apparatuur zoals de originele Surface draaide op Windows Vista Professional. In V2 is dat Windows 7 Professional 64 geworden. Inderdaad: onder deze hardware draait gewoon een Windows PC. Uiteraard zie je dit niet als je de machine gebruikt als Surface maar als ontwikkelaar of beheerder is dit goed nieuws: alles is herkenbaar en kan gewoon behandeld worden zoals alle andere computers in je omgeving.
Wat Surface anders maakt dan andere Windows PC’s is uiteraard de Surface laag boven op Windows. Dit is wat de gebruikers zien, een gebruiker zal nooit zien dat Surface een Windows machine is maar werkt met de Surface User Interface. Microsoft heeft veel geleerd van de feedback op de eerste versie en heeft die feedback vertaald in een betere gebruikerservaring. Het voert te ver om alle verbeteringen op te noemen maar het komt er op neer dat de gebruikers nog eenvoudiger met de software kunnen werken dan dat ze konden. Ok, één voorbeeld dan: in de hoeken van het scherm stonden knoppen om naar het hoofdmenu terug te gaan. Nu gebeurde het regelmatig dat een gebruiker met zijn mouw van een jasje over die knoppen heen ging wat als resultaat had dat de applicatie gepauzeerd werd en het menu verscheen. In de nieuwe software is dit vervangen door een schuifknop, welke je moet verschuiven om het menu te openen. De kans dat dit per ongeluk gebeurt is vele malen kleiner dan de originele manier, maar toch snappen gebruikers direct wat de bedoeling is. En dit is wat je verder overal in het systeem ziet: er is voor gezorgd dat de gebruiker van de Surface intuitief weten wat de bedoeling is en wat ze kunnen doen.
De SDK
Nu is een nieuw hardware en software platform best leuk en aardig maar zonder de juiste software die er op draait hebben we er niet zo heel veel aan. Er is helaas geen Marketplace of Appstore beschikbaar met standaard Surface software: die moeten de ontwikkelaars zoals jij en ik gaan schrijven.
Om dat mogelijk te maken heeft Microsoft de Surface SDK uitgebracht. Uiteraard was deze ook al beschikbaar voor Surface 1.0 maar deze is enorm veranderd en uitgebreid voor de nieuwe versie.
De SDK is beschikbaar voor iedereen met een MSDN abonnement en is te downloaden vanaf de MSDN download site. Als je deze download en installeert krijg je een aantal nieuwe applicaties op je systeem en uiteraard een paar nieuwe features in Visual Studio.
De oude versie van de SDK vereiste Windows Vista Pr en Visual Studio 2008 SP1, maar de nieuwe is gelukkig opgewaardeerd naar wat moderner spul: Windows 7 Pro en Visual Studio 2010. Inderdaad, de nieuwe omgeving draait op .net 4.0, in tegenstelling tot de oude versie die gebaseerd was op .net 3.5.
Ondersteuning vanuit .net
Met de introductie van .net 4.0 en Windows 7 is Touch een, zoals ze dat noemen, ‘first-class citizen’ geworden. Als je de SDK van Windows 7 bekijkt kun je zien dat er een tweetal messages bij gekomen zijn: WM_TOUCH en WM_GESTURE. De eerste wordt afgevuurd als het systeem een aanraking detecteert, de tweede is een message die verstuurd wordt als een aanraking of een aantal aanrakingen samen een bekende beweging vormen. Voorbeelden van gestures zijn de pinch (vergroten of verkleining met twee vingers) of de rotate (het draaien door middel van twee vingers). Touch wordt door .net 4.0 volledige ondersteund: een control heeft nu ook TouchDown, TouchUp en dergelijke events. Gestures worden ondersteund door middel van de Manipulation events. Om een rotatie te detecteren gebruik je ManipulationStarted, ManipulationDelta en ManipulationEnded events. Hiervoor hoef je dus niet de Surface SDK geinstalleerd te hebben!
In .net 3.5 en vroeger zaten deze events niet dus moest het Surface team dit volledig zelf implementeren in de Surface SDK. In .net 4.0 zitten ze er standaard in; het Surface team maakte daar dan ook dankbaar gebruik van en hebben de SDK hier op gebaseerd.
De SDK is dan nu ook meer een aantal tools en extra controls dan een uitbreiding op het framework geworden.
Controls
Net als in de oude versie hebben een aantal controls een makeover gekregen. Veel controls hebben een afgeleide gekregen met de prefix Surface. Zo hebben de controls Button, ListBox, RadioButton en dergelijke een broertje met de naam SurfaceButton, SurfaceListBox en SurfaceRadioButton. Het idee hierachter is dat normale controls zoals de radiobutton niet echt geschikt zijn om aangestuurd te worden door een vinger: ze zijn simpelweg te klein. Ook grotere controls zoals een Button hebben problemen. Denk eens aan het volgende scenario. Je plaatst een vinger op een Button. Dit is standaard een MouseDown event. Dan plaats je er een tweede vinger naast. Vervolgens verwijder je de eerste vinger. Wat moet het systeem nu doen? Als we het gewone patroon uit .net volgen krijg je bij de tweede vinger een tweede MouseDown event en op het moment dat de eerste vinger weer weggehaald wordt een MouseUp, wat resulteert in een Click event. Maar in het echte leven werkt dat niet zo. Als ik met een vinger een knop indruk en dan een tweede erbij doe voordat ik de eerste weghaal, blijft de knop ingedrukt. Er volgt pas een click event (voor zover je die hebt in het echte leven) als alle vingers weg zijn.
Dit is precies wat de Surface versie van de controls doen. Ze houden veel meer rekening met het feit dat we weliswaar meestal maar één muis hebben op ons systeem, maar dat de meeste mensen meer dan één vinger hebben en die ook graag willen gebruiken!
Tooling
Het is natuurlijk het beste om Surface applicaties op een Surface machine te schrijven. Dit heeft jammer genoeg wat beperkingen. Ten eerste is een horizontale tafel niet echt de meest ergnomische manier om te werken, ten tweede is de hardware vrij prijzig zodat niet iedere ontwikkelaar een eigen Surface kan hebben om op te werken. Microsoft snapt dat ook en heeft een simulator gemaakt die het gedrag van de Surface nadoet op een gewoon werkstation.
Dit werkstation moet minstens Windows 7 Professional hebben maar hoeft verder geen Touch te ondersteunen. Na installatie heb je een aantal applicaties erbij, één ervan is de Input Simulator (zie figuur 2).
Figuur 2
Deze simulator geeft je de mogelijkheid om verschillende manieren van omgaan met je systeem na te bootsen. Zo kun je vingers nadoen, blobs plaatsen, tags plaatsen en eventueel het scherm kantelen. Surface V2 is in staat om te zien hoe het scherm gebruikt wordt (horizontaal of verticaal) en daar kun je acties op ondernemen: dit gedrag kun je dus simuleren in de simulator. Een ander hulpmiddel is de Input Visualizer.
Figuur 3
Hiermee kun je ziet wat er op het scherm gebeurt als iemand een gesimuleerde vinger neerzet. Het resultaat daarvan zie je in figuur 4. Hierin staat een vinger, met een unieke ID (iedere aanraking krijgt een ID) en de richting waarin de vinger wijst. Die kun je uiteraad ook met blogs, tags en andere aanrakingen doen.
Figuur 4
Je ziet dat je voor het meeste ontwikkelwerk geen Surface nodig hebt om te ontwikkelen. Het is wel aan te raden om voor je je applicatie oplevert het te testen op een echte Surface. De ervaring op zo’n machine is toch altijd anders dan op een gesimuleerde versie, je zult zien dat je bepaalde aspecten over het hoofd ziet. Een voorbeeld hiervan is: hoe ziet de applicatie er uit als je het vanaf de andere kant bekijkt? Een horizontaal geplaatste Surface heeft immers geen boven- en onderkant van het scherm…
Development
Het ontwikkelen op Surface is eigenlijk vrij eenvoudig. Je kunt nog altijd kiezen of je een XNA of een WPF applicatie wilt bij de start van het project. Indien je directe controle wilt over wat de sensoren je teruggeven kies je voor XNA, 90% van de applicaties worden echter geschreven in WPF.
Als je een nieuwe applicatie maakt krijg een je een vrij standaard WPF applicatie te zien. Het enige direct zichtbare verschil is dat je geen Window hebt maar een afgeleide class daarvan: SurfaceWindow.
Zoals je ziet is dit standaard WPF. Je kunt je scherm nu opbouwen zoals je dat zelf wilt. Let er wel op dat je geen gebruik maakt van standaard controls maar liever van de nieuwe Surface versies indien beschikbaar. Dus neem geen Button op in je XAML maar neem SurfaceButton daar voor in de plaats.
Voor de rest is er niets spannends aan. Aangezien het gewoon WPF 4.0 is kun je gebruik maken van alle technieken die je normaal ook gebruikt. Het is vrij standaard om bij een WPF applicatie een MVVM pattern en library te gebruiken, dat doen we bij Surface ook. Ook alle Nuget-packages zullen gewoon werken. En ja, je kunt je applicatie gewoon openen in Expression Blend om daar je scherm te tekenen en al je XAML bestanden te bewerken.
Specifieke Surface Controls
Naast de subclasses zoals SurfaceButton en SurfaceListBox zijn er een paar controls bij gekomen die geen equivalent in normale WPF applicaties hebben. Deze hebben betrekking op de speciale functionaliteit die Surface je biedt. Zo hebben we bijvoorbeeld de TagVisualizer control. Je ziet dat deze controls niet de prefix Surface hebben; er is geen reden om een onderscheid te maken tussen deze controls en hun normale versie aangezien er geen normale versie van beschikbaar is.
De TagVisualizer is een control die detecteert wanneer een object met een tag op het scherm geplaatst wordt. Je kunt als dat gebeurt een event krijgen en je kunt aangeven welk UserControl er gerenderd moet worden op die plek. Dus als iemand een kopje koffie op het scherm plaatst en dat kopje is voorzien van de juiste tag, kun je een animatie om het kopje heen maken met mooie dampwolkjes. Voorzie die animatie van een timer zodat je na 5 minuten een signaal af laat gaan en de gebruiker weet dat hij zijn koffie niet moet vergeten te drinken voor deze te koud wordt.
Andere specifieke controls zijn ElementMenu (een soort rechtsklik popup menu maar aangezien je met een vinger niet rechts kan klikken is deze uitgevonden), de ScatterView (een listbox waarin de elementen kris-kras door elkaar staan en met een vinger bewogen kunnen worden), een LibraryBar (een uitgebreide ListBox waarin elementen, al dan niet gegroepeerd) naast elkaar staan en nog een aantal meer.
Windows 8
Nu is dit allemaal leuk en aardig maar laten we eerlijk zijn: niet iedereen heeft de beschikking over een Surface computer. En om nog eerlijker te zijn: niemand heeft de beschikking over een Surface V2 computer; deze zijn op het moment van schrijven nog niet leverbaar. Dus wellicht vraag je jezelf af: wat moet ik met deze informatie?
Er is een groot verschil tussen de SDK 1.0 en de SDK 2.0 welke ik nog niet duidelijk benoemd heb. Software gemaakt met de SDK 1.0 draait alleen op Surface 1.0. Geen uitzondering mogelijk. Software geschreven met de SDK 2.0 draait op Surface 2.0, maar ook op alle andere computers met Windows 7 en .net 4.0. Nu is dat niet zo interessant tot je je bedenkt dat er steeds meer en meer aanraak gevoelige hardware beschikbaar komt. Als deze hardware de juiste versie van Windows draait kun je er met de Surface SDK software voor schrijven. Je kunt dan eenvoudig software maken die met de vinger bedient kan worden, zonder dat je je zelf zorgen hoef te maken over het meerdere-vingers-op-een-knop probleem wat ik hier boven schetste. Het Surface team heeft deze problemen al voor je opgelost, zodat jij je kunt richten op je applicatie logica. Om te kijken welke mogelijkheden je systeem waar je applicatie op draait is meestal een paar regels al voldoende zodat het eenvoudig is om een applicatie te maken voor verschillende platformen.
/// <summary>
/// Default constructor.
/// </summary>
public SurfaceWindow1()
{
InitializeComponent();
if (InteractiveSurface.PrimarySurfaceDevice.IsTagRecognitionSupported)
{
// We kunnen Touches ondersteunen...
}
}
Ook voor de volgende versie van Windows, met de code naam Windows 8, is de Surface SDK een uitkomst. Zoals je wellicht weet kun je in de nieuwe Windows twee soorten applicaties maken: de nieuwe Metro applicaties maar ook oude applicaties worden ondersteund. Maar aangezien veel nieuwe hardware Touch zal gaan ondersteunen is het prettig als je het beste van beide werelden tot je beschikking hebt: het volledige .net framework (wat jij bij WinRT niet hebt) en simpele toegang tot Touch functionaliteit. Met de Surface SDK 2.0 heb je dat. Met andere woorden: applicaties die je vandaag de dag met .net 4.0 en Surface SDK 2.0 schrijft zullen in de toekomst fantastisch draaien op de nieuwe Windows versies.
Conclusie…
Met de nieuwste SDK is het bouwen van Touch applicaties eenvoudig geworden. Je hoeft je geen zorgen meer te maken over de specifieke uitdagingen die Touch applicaties bieden. En of je nu schrijft voor Surface of dat je je richt op Windows 7, of zelfs al Windows 8: met de Surface SDK ben je klaar voor de toekomst. Het enige wat nog rest is het krijgen van goede ideeën voor de volgende Touch-Enabled-Killer-App. Maar dat is iets waar wij ontwikkelaars goed in zijn, is het niet?