Elke nieuwe technologie brengt vragen en uitdagingen met zich mee. Wat zijn de functionaliteiten? Kunnen bestaande technologieën gekoppeld worden aan de nieuwe technologie? Wat zijn de beperkingen en implementatiemogelijkheden? Met de komst van Google Glass raken bedrijven steeds meer geïnteresseerd in de antwoorden op deze vragen. Google Glass bevindt zich echter nog in een experimentele fase. Er is dus nog een groot onontgonnen terrein. In dit whitepaper lees je over een app die wij ontwikkelden voor Google Glass. We combineerden bestaande met nieuwe technologie om verschillende functies mogelijk te maken. Wat die zijn lees je hieronder. Over onze aanpak en de toepassingen van elke functie gaat de rest van dit paper.
Masc onderzocht in 2014 hoe Google Glass ingezet kan worden als middel om bedrijfsprocessen te verbeteren of onderzoeken. We gingen uit van een applicatie die de volgende dingen moest kunnen:
Video-opnames maken met Glass zonder dat de drager van de bril er iets van merkt. Bewegingen van de Glass, en daarmee dus ook het hoofd van de drager, registeren (met sensoren). Berichten ontvangen, zonder de app te hoeven afsluiten (in-app-notificaties). Een voorgedefinieerde locatie herkennen.
Waarom is het belangrijk dat een Glass video-opnames kan maken, in-app-berichten kan ontvangen of een locatie herkent? Dat hangt maar net af van wat je met je app wilt. De functies die we noemen kun je op allerlei manieren inzetten. Denk aan een onervaren monteur die een cv-ketel moet ontmantelen. Door te filmen met een Google Glass heeft hij zijn handen vrij en kan op afstand een ervaren collega meekijken. Die kan via de in-app-notificaties instructies doorsturen die in het beeldscherm van de Glass verschijnen. Het herkennen van locaties? Heel handig als je toeristen met Google Glass de omgeving wilt laten zien, zoals onze opdrachtgever Liefde voor Limburg. Met de app Glass Guide die we voor hen maakten, herkent de bril een toeristische locatie en reageert daarop door een filmpje of foto’s van vroeger te tonen, of een audiofragment met uitleg af te spelen. Handsfree informatie krijgen!
Dit whitepaper is geschikt voor developers die (willen) werken met Google Glass. Maar ook voor leken die geïnteresseerd zijn in de ontwikkeling van Google Glass-applicaties of simpelweg in de technische mogelijkheden van de bril. We hebben technisch taalgebruik zo veel mogelijk vermeden.
Applicatie voor Google Glass ......................................................................................................... 4 Wat is Google Glass?.............................................................................................................. 4 Gewenste functionaliteit ........................................................................................................ 5 Android: het besturingssysteem van de Glass ..................................................................... 5 Glass’ grafische gebruikersomgeving ................................................................................... 5 Ontwikkelmethodes Glassware ............................................................................................. 6 Ontwikkelomgeving ................................................................................................................ 8 Samengevat: Een Glass-applicatie ontwikkel je zo .............................................................. 9 Sensors: beweging van Glass registeren .................................................................................... 10 Welke sensors zijn beschikbaar voor Google Glass? ......................................................... 10 Wat zijn de functies van de sensors? ................................................................................. 10 Hoe kunnen de sensors worden uitgelezen? ..................................................................... 12 Protocol voor gegevensopslag ............................................................................................. 12 Samenvatting........................................................................................................................ 13 In-app-notificaties ......................................................................................................................... 14 Wat zijn in-app-notificaties?................................................................................................. 14 Welke communicatieprotocollen komen in aanmerking? ................................................. 14 Communicatieprotocollen vergeleken ................................................................................ 14 Communicationprotocol voor de huidige applicatie ........................................................... 15 Geofencing .................................................................................................................................... 17 Wat is geofencing? ............................................................................................................... 17 Hoe kan de huidige locatie worden bepaald? .................................................................... 17 Hoe kan geofencing geïmplementeerd worden? ............................................................... 18 Samenvatting........................................................................................................................ 19 Over Masc ............................................................................................................................................. 22
Google Glass is een draagbare computer in de vorm van een bril, die door Google Inc. ontwikkeld wordt in het kader van het onderzoek- en ontwikkelingsproject ‘Project Glass’. Google Glass moet het mogelijk maken informatie te benaderen met een head-mounted display. Dit houdt in dat de gebruiker informatie kan zien die voor zijn of haar ogen geprojecteerd wordt. Google Glass geeft informatie weer zoals op een smartphone, maar dan handsfree.
Hardwarefuncties van de Glass
Aan de voorkant van de bril zit een prisma, het bevindt zich voor het rechteroog van de gebruiker. Hierdoor kan de Glass voor het oog beelden projecteren. De bediening van de Glass gaat via spraakcommando’s of door tik- of veeg bewegingen op het touchpad, aan de rechter zijkant van de bril. De Glass bevat ongeveer dezelfde hardware als hedendaagse smartphones en kan daarom zowel als los apparaat als in aanvulling op smartphones worden gebruikt. Zo is het mogelijk om met de Glass te zoeken op het internet, te videobellen of om foto’s en video’s te maken. In combinatie met een smartphone kan de Glass ook gebruikt worden om te bellen, sms’en en te navigeren.
Schematisch tekening van werking visuele overlay
De applicatie moet voldoen aan een aantal functionaliteiten. Glass moet de volgende acties simultaan uit kunnen voeren.
Video-opnamen maken met de geïntegreerde camera, terwijl er niets op het display van de Glass wordt weergegeven. Uitlezen en opslaan van de sensorgegevens van het apparaat. Ontvangen van in-app-notificaties verstuurd vanaf een externe Windows-applicatie. Ontvangen van in-app-notificaties wanneer de Google Glass zich binnen de radius van één van de opgeslagen geografische locaties bevindt.
Aansluitend is het nodig om een Windows-applicatie te ontwikkelen die als ondersteunende beheerapplicatie van de Google Glass-applicatie dient. Deze beheerapplicatie bevat de volgende functies:
Uitlezen van video-opnamen en sensorgegevens die staan opgeslagen op de Google Glass. Gelijktijdig afspelen van video-opnamen en weergeven van sensorinformatie. Beheren van in-app-notificaties en geografische locaties.
Google Glass draait op het besturingssysteem Android. Android is speciaal voor mobiele apparaten, zoals hedendaagse smartphones, tablets, mediaspelers, smartwatches en uiteraard de Glass. Android is net als Glass ontwikkeld door Google Inc. in samenwerking met Open Handset Alliance (OHA). OHA is een samenwerkingsverband van circa 87 bedrijven die zich richt op het ontwikkelen van standaarden voor mobiele apparaten. Op het moment van schrijven draait de Glass op Android versie KitKat 4.4.2. Omdat de Glass op Android draait, kunnen ook bestaande Android-applicaties die specifiek voor de smartphone zijn gemaakt in theorie op de Glass draaien. In de praktijk werkt dit echter niet optimaal omdat het Glass-scherm afwijkende afmetingen heeft ten opzichte van de gemiddelde smartphone. Daarnaast bevat de Glass geen touchscreen maar een touchpad waardoor interactie met een smartphone-applicatie in veel gevallen onmogelijk is. Om deze reden heeft Google specifieke ontwerprichtlijnen opgesteld voor de ontwikkeling van Glass-applicaties. Hierbij moet rekening gehouden worden met de grafische gebruikersinterface en de gebruikersinvoer.
De grafische gebruikersomgeving, ook wel graphical user interface (GUI) genoemd, is een van de belangrijkste aspecten van de Glass. Dit komt omdat een GUI voor een bril een nieuw concept is, waardoor Google de Android GUI voor de Glass speciaal opnieuw heeft ontworpen. Google heeft ontwerpprincipes opgesteld met als doel de GUI zo intuïtief mogelijk te maken en de ontwerpen abstracter te maken zodat er meer focus gelegd wordt op de inhoud die het belangrijkst is.
Dit heeft Google gedaan door gebruik te maken van zogenaamde ‘cards’. Een card is een schermvullend GUI-element dat tekst en een (achtergrond)afbeelding kan bevatten. Een card is onderdeel van een ‘timeline’, een tijdlijn waar door het met de vinger vegen over het touchpad gescrold kan worden door de set met cards. Optioneel kan een card ook een menu hebben. Het is ook mogelijk om een aangepaste card te maken die meer content bevat. In de paragraaf ‘Glass Development Kit’ gaan we daar verder op in.
Een timeline met meerdere cards
Het menu dat geopend wordt wanneer er op een card wordt getapt.
Voor de Glass bestaan er twee verschillende API’s waarmee applicaties ontwikkeld kunnen worden. De eerste mogelijkheid is de ‘Mirror API’. Dit is een RESTful API om op een makkelijke manier Glassware te ontwikkelen. Een andere manier om applicaties te ontwikkelen is met de Glass Development Kit. Het substantiële verschil met de Mirror API is dat de GDK software laat draaien op het apparaat terwijl een applicatie gemaakt met de Mirror API draait op het internet. In de volgende twee paragrafen leggen we de verschillen tussen de twee API’s verder uit.
Om te begrijpen wat de Mirror API inhoudt, moet het concept cloudgebaseerde Glassware eerst duidelijk zijn. Cloudgebaseerde Glassware houdt in dat de applicatie niet op het apparaat draait maar online op het internet. De Mirror API is een webservice van Google waar de Google Glass
mee kan communiceren. Een Mirror API-applicatie wordt als service op de Google webservice geplaatst. De service geeft aan de Mirror API door welke rechten de applicatie nodig heeft wanneer de Glass zich abonneert op de service. De Glass communiceert met de Mirror API en kan zich met de Mirror API abonneren op een service (de Glassware). Zodra een Glass zich heeft geabonneerd op een service kan de service content sturen naar de Glass. Dit kan bijvoorbeeld door ‘tijdlijnkaarten’ in de ‘tijdlijn’ van de Glass te plaatsen. Andersom kan de Glass-applicatie ook content sturen naar de service. Voorbeelden hiervan zijn tekst en foto’s. Op deze manier kan er interactief informatie-uitwisseling plaatsvinden. De Mirror API communiceert door het versturen van een REST-aanvraag met JSON-inhoud.
Schematisch weergave werking Mirror API Glassware op de Glass
Voor de ontwikkeling van een native Android-applicatie wordt de Android Software Development Kit (SDK) gebruikt. De SDK bevat een bundel van ontwikkelingstools die bijdragen aan de ontwikkeling van Android-applicaties. Vanwege de specifieke ontwerpprincipes die Google heeft opgesteld voor Glass-applicaties heeft Google een Glass Development Kit (GDK) uitgebracht. De GDK dient als extensie van de Android SDK en bevat specifieke uitbreidingen om de ontwikkeling van Glass-applicaties makkelijker te maken. De GDK zorgt onder andere voor de afhandeling van touch gestures en kan Glass cards aanmaken en weergeven. Ook bevat hij functies om de tijdlijn aan te passen. De afhandeling van spraakcommando’s is een belangrijk onderdeel van de GDK. Met GDK kan er in tegenstelling tot met de Mirror API een applicatie ontwikkeld worden die ook zonder internetverbinding werkt. Daarnaast kan de GDK hardware aansturen zoals de camera en sensors, en toegang verkrijgen tot het bestandssysteem. Het belangrijkste aspect van de GDK is de mogelijkheid om een ‘immersion’ te maken. Een immersion is een afgebakend onderdeel van de Glass. Op het moment dat een immersion wordt gestart heeft het de focus op de Glass. Dit is anders dan een timeline card die onderdeel is van de timeline waar doorheen gescrold kan worden. Wanneer een immersion ontwikkeld wordt is het
mogelijk om af te wijken van de standaard cards die gebruikt kunnen worden. De GDK biedt de vrijheid om compleet zelfgemaakte GUI-elementen te ontwerpen en ontwikkelen. Een aangepaste GUI in combinatie met volledige toegang tot de Android- en GDK-API maken het mogelijk om met de GDK complexe Glass-applicaties te ontwikkelen.
In de vorige paragraaf is het duidelijk geworden wat de verschillen zijn tussen de twee API’s. Maar welke methode gebruik je wanneer? Samenvattend stellen we dat de Mirror API vooral nuttig is bij het tonen van statische content waarbij een verbinding met het internet een vereiste is. De GDK kan het best gebruikt worden bij applicaties waarvan het belangrijk is dat de applicatie de focus heeft of wanneer hardware aangesproken moet kunnen worden. Uit een vooronderzoek bleek dat een native Glass-applicatie voor ons project de beste oplossing zou zijn, gezien de gewenste functionaliteit en toepassing. De beslissing voor een native app is genomen op basis van de volgende overwegingen:
Het is essentieel dat de Glass-applicatie toegang heeft tot de hardware van het apparaat zoals de camera, sensors en het bestandssysteem. De Glass-applicatie moet ook offline kunnen werken en niet afhankelijk zijn van de servers van Google. Wanneer de applicatie wordt gestart, moet de applicatie de focus krijgen op de bril door een immersion. Dit is alleen mogelijk met de GDK.
Met de ontwikkelomgeving wordt de computersoftware bedoeld die een softwareontwikkelaar ondersteunt bij het ontwikkelen van software. Het wordt ook wel integrated development environment of kortweg IDE genoemd. Ook voor de ontwikkeling van Glassware is het noodzakelijk om een ontwikkelomgeving te gebruiken. De keuze voor de ontwikkelomgeving is afhankelijk van de gebruikte API. Omdat het Mirror API-platform onafhankelijk is, is de keuze voor een ontwikkelomgeving afhankelijk van de ontwikkeltaal die gebruikt wordt. Hierdoor is het aanbod vrijwel onbeperkt en in grote mate afhankelijk van persoonlijke voorkeur. Als er gebruik wordt gemaakt van de GDK ligt een Java-omgeving voor de hand, de SDK is namelijk gebaseerd op Java. Omdat er binnen dit project gebruik wordt gemaakt van de GDK is er alleen onderzocht welke IDE ontwikkelomgeving het meest geschikt is voor het ontwikkelen van native Glassapplicaties. De twee meest gebruikte ontwikkelmethodes voor native Android ontwikkeling zijn Eclipse en Android Studio. In de volgende paragrafen verduidelijken en vergelijken we de eigenschappen van Eclipse en Android Studio.
Eclipse is een open source framework voor software-ontwikkelomgevingen. De bekendste toepassing is het gebruik als IDE voor de programmeertaal Java. Om deze reden raadt Google aan om Android-applicaties in Eclipse te ontwikkelen. Dit doet Google onder andere door de Android SDK aan te bieden in de vorm van ‘Android Developer Tools Bundle’. Deze bundel bevat de Eclipse IDE met de Android Developer Tools (ADT) plugin voor Eclipse. De ADT plugin voor Eclipse bevat alle benodigde tools om de ontwikkeling voor het Android-platform beschikbaar te maken. Eclipse maakt gebruik van het bouwsysteem Apache Ant. Dit is een computerprogramma voor het automatiseren van het bouwproces van de applicatie. De bouwbestanden die worden gebruikt zijn geschreven in XML. Door de ondersteuning van Google is Eclipse uitstekend geschikt om Android-applicaties te maken. Omdat een Glass-applicatie ook een Android-applicatie is, is deze ontwikkelomgeving uitstekend voor de ontwikkeling van Glassware.
Android Studio is een IDE specifiek gemaakt voor de ontwikkeling van Android applicaties. De IDE is ontwikkeld door Google, ontwikkelaar van het Android-platform. De Android Developer Tools zitten ingebakken in de ontwikkelomgeving en hoeven dus niet apart geïnstalleerd te worden. Het grootste verschil tussen Android Studio en Eclipse is dat Android Studio zich nog in het bètastadium bevindt en daarom nog bepaalde functionaliteit mist en dan met name de uitgebreide debuggertools die Eclipse wel bevat. Het doel van een debuggertool is het opsporen van fouten in de applicatie. Daarnaast werkt Android Studio in tegenstelling tot Eclipse standaard met het bouwsysteem Gradle. Gradle is qua functionaliteit een combinatie van Apache Ant en Apache Maven en biedt daarom de mogelijkheid om complexe bouwbestanden te maken met relatief weinig code. Gradle maakt gebruik van een syntax die gebaseerd is op Groovy; een objectgeoriënteerde programmeertaal.
Welke stappen zijn, samengevat, nodig om een Glass-applicatie te ontwikkelen? Om te beginnen zal bepaald moeten worden welke API je gebruikt. Dit is afhankelijk van het type applicatie dat er gemaakt moet worden. Daarop volgt de keuze voor een ontwikkelomgeving. Bij een native Glass-applicatie is Android Studio minder betrouwbaar voor de ontwikkeling omdat de ontwikkelomgeving nog in een bètastadium verkeert. Eclipse geniet om deze reden de voorkeur. Ongeacht of er is gekozen voor Eclipse of Android Studio moet de Glass Development Kit Preview geïnstalleerd worden. Hierdoor kan gebruikt worden gemaakt van de GDK API waarmee specifieke functionaliteiten van de Glass benut kunnen worden.
Sensors komen van pas als je bewegingen van de Glass (ofwel hoofdbewegingen van de drager van de bril) wilt registeren. Dit kan nuttig zijn bij gedragsonderzoek. Stel je voor dat IKEA wil weten hoe winkelend publiek zich door de winkel beweegt. Met sensors is te zien of bezoekers veel of weinig om zich heen kijken. Combineer je dit met video-opnames, dan weet je ook precies wáár de aandacht van bezoekers naartoe gaat. In dit hoofdstuk zetten we de verschillende sensors op een rij en bespreken we onze eigen afwegingen en keuzes.
In dit whitepaper behandelen we de verschillende sensors die gebruikt kunnen worden voor Google Glass. De sensors zijn beschikbaar via de API van Android. Ze zijn te onderscheiden in fysieke en virtuele sensoren. De fysieke sensoren halen rechtstreeks informatie uit de corresponderende hardwaresensor die in het apparaat verwerkt zit. Een virtuele sensor is een softwarematige sensor die gebruik maakt van meerdere fysieke sensors en gegevens combineert en berekent. Hieronder volgt een overzicht van de beschikbare bewegings- en omgevingssensors. De locatiesensors voor het bepalen van een locatie worden in dit hoofdstuk niet besproken. In het hoofdstuk over geofencing gaan we in op locatiebepaling.
Gyroscope Accelerometer Light sensor Magnetometer (magnet field sensor)
Gravity (accelerometer) Linear acceleration Rotation vector (combinatie van accelerometer, magnetometer, gyroscope) Orientation sensor
Om meer zicht te krijgen op de functies van de verschillende type sensors, nemen we ze hier kort door. Dit maakt het mogelijk ze te vergelijken en een betere keuze te maken voor de huidige app.
De gyroscoop meet bewegingen van het hoofd ten opzichte van de huidige positie. Ofwel: het geeft een indicatie hoeveel de Glass wordt bewogen. De metingen zijn relatief ten opzichte van de vorige meting waardoor dezelfde metingen kunnen worden waargenomen in verschillende posities.
Sensorcoördinatensysteem
De accelerometer is een versnellingsmeter. Met de versnellingsmeter is het mogelijk om versnelling te registreren en meten.
De gravity sensor is een virtuele sensor die gebruik maakt van de accelerometer. Het verschil met de accelorometer is dat de gravity sensor de zwaartekracht erbij rekent. Wanneer het apparaat stilstaat zal de output hetzelfde zijn als bij de accelerometer.
De rotatie vector staat voor de oriëntatie van de Glass als een combinatie van een hoek en een as, waarbij de Glass rond een as (x, y of z) is geroteerd over een hoek van 0 graden.
De orientationsensor kan meten in welke richting de Glass kijkt ten opzichte van het noorden. Het functioneert hierdoor net als een kompas en genereert een output van 0 tot 359. Graden 0 90 180 270
Richting noord oost zuid west
Het uitlezen van sensors is in de meeste gevallen een rekenintensieve taak voor het apparaat. Dit komt omdat de sensors vele metingen tegelijk kunnen doen. Daarnaast is het soms wenselijk om meerdere sensors tegelijk uit te lezen. Om de sensors uit te lezen wordt gebruik gemaakt van de SensorManager-module in de Android API. De SensorManager bevat de nodige functionaliteiten voor het uitlezen van de gegevens. Zo is het mogelijk om één of meerdere specifieke sensors te activeren en kun je de updatefrequentie instellen. De volgende updatefrequenties zijn beschikbaar:
Fastest: Dit is de snelste updatefrequentie en probeert de sensordata zo snel mogelijk te verkrijgen. Game: Deze updatefrequentie is geoptimaliseerd voor in het gebruik van spelletjes. Normal: Dit is de standaard updatefrequentie. Userinterface: Deze updatefrequentie wordt aangeraden wanneer de GUI ververst moet worden tijdens elke meting. Dit is de langzaamste methode.
De sensorgegevens moeten in de applicatie die we ontwikkelen worden opgeslagen zodat deze later weer uit te lezen zijn. Als de sensorgegevens worden uitgelezen in de Windows-applicatie is het noodzaak dat de opgeslagen gegevens worden geïnterpreteerd zoals ze zijn opgeslagen. Om dit probleem op te lossen is er voor gekozen om zelf een opslagprotocol te ontwerpen welke door zowel de Glass-applicatie als de Windows-applicatie gebruikt wordt. Voordat er een opslagprotocol ontworpen kon worden moest er eerst nagedacht worden over de data die opgeslagen moet worden. Door het gemaakte opslagprotocol weet de Glass-applicatie hoe de gegevens opgeslagen moeten worden en weet de Windows-applicatie weet hoe de gegevens uitgelezen moeten worden. Wat het opslagformaat betreft, een belangrijke eis was dat het een makkelijk leesbaar formaat is en dat het formaat toegankelijk is. Hieruit zijn de twee formaten XML en JSON naar voren gekomen die beide goed leesbaar zijn en veel gebruikt worden voor data-uitwisseling. Uiteindelijk is ervoor gekozen de data op te slaan in JSON-formaat. De volgende drie kenmerken gaven de doorslag voor het gebruik van JSON:
JSON is lichtgewicht en zorgt daardoor, in tegenstelling tot XML voor weinig overhead. JSON is makkelijk leesbaar voor het menselijk oog. Onze organisatie is al bekend met JSON. Hierdoor is er meer consistentie binnen de organisatie en is het project makkelijker overdraagbaar binnen de organisatie.
JSON is een open standaard formaat dat tekstuele data kan opslaan in de vorm van naamwaarde paar. Hieronder volgt een voorbeeld van een JSON-object van een persoon:
{ "firstName": "John", "lastName": "Smith", "age": 25, "address": { "streetAddress": "21 2nd Street", "city": "New York", "state": "NY", "postalCode": "10021" }, "phoneNumber": [ { "type": "home", "number": "212 555-1239" }, { "type": "fax", "number": "646 555-4567" } ], "gender": { "type":"male" } }
De specificatie en beschrijving van het opslagprotocol is gespecificeerd in Bijlage A.
Samengevat zijn er acht sensors die op de Glass uitgelezen kunnen worden. Vier fysieke sensors en vier virtuele sensors. De sensor kunnen worden uitgelezen met de SensorManager-module in de Android API. Binnen dit project was het nodig om de sensorgegevens op te slaan. Omdat de Windowsapplicatie moet begrijpen is een opslagprotocol bedacht. De applicatie slaat de sensorgegevens op via het bestandssysteem.
Een in-app-notificatie maakt het mogelijk om op afstand berichten naar Google Glass te sturen. De drager van de bril kan de berichten (tekst, maar ook video, foto’s en audio) vervolgens bekijken, zónder de app af te sluiten. Handig als een ervaren monteur instructies wil sturen naar zijn jongere collega die op locatie een lastige klus uitvoert. In dat geval is het wel nodig dat de jongere collega filmt met de Glass, zodat zijn collega kan meekijken. Er zijn genoeg vergelijkbare toepassingen voor andere (beroeps)groepen te bedenken.
Een notificatie is bedoeld om aan de gebruiker van Google Glass aan te geven dat er een gebeurtenis heeft plaatsgevonden. Een notificatie doet dit door een bericht van verzender naar ontvanger te sturen. Een bericht kan:
Automatisch verzonden worden op een ingesteld tijdstip Automatisch verzonden worden op het moment dat iemand een bepaalde locatie bereikt (zie het volgende hoofdstuk over geofencing) Handmatig verzonden worden door iemand die in een applicatie op ‘send’ drukt
Er zijn verschillende methodes om draadloos te communiceren tussen apparaten. Voor communicatie tussen twee apparaten, in dit geval een Glass-applicatie en een Windowsapplicatie is het van belang dat hetzelfde communicatieprotocol gebruikt kan worden. Omdat de Glass is beperkt in de ondersteunde hardware en software is er bekeken welke communicatieprotocollen in aanmerkingen komen voor de gewenste situatie. De belangrijkste eisen zijn de stabiliteit van de verbinding, de snelheid van de verbinding en voldoende communicatie mogelijkheden. Zo moet de Glass-applicatie kunnen communiceren met de Windows-applicatie. Daarnaast moet het andersom ook mogelijk zijn dat de Windows-applicatie kan communiceren met de Glass-applicatie zodra de Glass-applicatie er verbinding mee heeft gemaakt.
Uiteindelijk is de keuze gemaakt uit de volgende twee netwerkprotocollen:
Hypertext Transfer Protocol (HTTP) WebSockets
Het HTTP-protocol is het meest gebruikte protocol op het internet. Het wordt vooral gebruikt voor de communicatie tussen een webclient en een webserver. Het protocol wordt veel gebruikt voor het externe netwerk (internet) maar kan ook gebruikt worden voor lokale netwerken (intranet). HTTP is een vraag-antwoordprotocol. Een http-client initieert een aanvraag naar de http-server met een TCP/IP-verbinding. De server kan niet rechtstreeks een aanvraag doen naar de client. Een manier om dit probleem te omzeilen is door regelmatig pull-aanvragen vanuit de client te sturen. Dit houdt in dat de client regelmatig aan de server vraagt of de server een nieuwe aanvraag heeft voor de client.
Het WebSocket protocol is een geavanceerde techniek die het mogelijk maakt om een interactieve verbinding te openen tussen een client en een WebSocket-server. Een belangrijke eigenschap van WebSocket is dat het een full-duplex-verbinding tot stand brengt. Dit houdt in dat gegevens zowel verzonden als ontvangen kunnen worden aan beide kanten zonder dat daarom gevraagd hoeft te worden. De server kan data naar de client sturen, zonder dat de client daarom hoeft te vragen. Voordat de verbinding wordt gelegd, moet deze eerst door de server geaccepteerd worden. Dit proces heet de WebSocket Handshake. De WebSocket Handshake wordt via het http protocol gelegd. Nadat de server de WebSocket Handshake heeft geaccepteerd wordt de verbinding geüpgraded naar een WebSocket-verbinding en vanaf dat moment is er een full-duplex-verbinding beschikbaar.
Client (Glass applicatie)
Server (windows applicatie) Aanvraag voor websocket verbinding
Data request
full-duplex
Tijd
Acceptatie aanvraag, verbinding open
handshake (HTTP upgrade)
Client of server verbreekt verbinding Werking WebSocket-protocol
Er is gekozen om het WebSocket-protocol te gebruiken voor deze applicatie. De doorslaggevende factor was het feit dat het HTTP-protocol geen ondersteuning biedt voor pushnotificaties omdat er geen full-duplex-verbinding tot stand kan komen. Het WebSocket-protocol is te implementeren in
zowel de client als server en biedt daardoor meer mogelijkheden voor het versturen van data. Bovendien is het WebSocket-protocol makkelijk toepasbaar over het internet, omdat het van dezelfde poorten verbinding kan maken als bij het HTTP-protocol, en hierdoor zonder verdere beperkingen gebruikt kan worden.
Met geofencing kun je bepalen of iemand zich in een specifiek geografisch gebied bevindt. De Glass herkent een locatie en kan als reactie bepaalde beelden tonen of een geluids- of videofragment afspelen. In een applicatie die we voor Liefde voor Limburg ontwikkelden, de Glass Guide, is deze technologie gebruikt. Fietstoeristen dragen een Google Glass en krijgen, wanneer ze langs een bijzonder kasteel of natuurgebied komen, extra informatie via de bril. Tourguide 2.0.
Geofencing is het virtueel afbakenen van een gebied met geografische coördinaten. Dit houdt in dat er een bepaald gebied als ‘geofence’ kan worden bestempeld zodra het is gedefinieerd met behulp van geografische coördinaten. Door de locatie van een gebruiker naast de gedefinieerde geofences te leggen is het mogelijk om te berekenen of de gebruiker zich op dat moment binnen een van de geofences bevindt. Wanneer de geografische coördinaten van de gebruiker zich binnen de grenzen van de geografische coördinaten van een geofence bevinden, betekent het dat de gebruiker zich binnen de geofence bevindt. Vallen de coördinaten van de gebruiker buiten het geografische gebied dan bevindt de gebruiker zich buiten de geofence. Een manier om een geofence te definiëren is door de lengte- en breedtegraad van een locatie te bepalen en daar vervolgens een radius aan toe te voegen.
Visuele weergave van geofence op kaart
Er kan bepaald worden of men zich in een geofence bevindt door de coördinaten van een geografisch gebied (geofence) te vergelijken met de huidige locatie. Hiervoor moet eerst de huidige locatie bepaald worden. Dit wordt gedaan met het Global Positioning System (GPS). Met GPS is het mogelijk om een locatie te bepalen met behulp van satellieten. Google Glass bevat echter geen GPS-module. Wel is het mogelijk om de GPS-module van een smartphone te gebruiken voor Glass, via bluetooth. Bluetooth is een open standaard voor draadloze verbindingen tussen apparaten op korte afstand. Om de GPS-module van de smartphone te
gebruiken op de Glass moet er eerst een bluetooth-verbinding tussen de twee apparaten worden opgezet. Het koppelen is alleen mogelijk met een Glass-beheerapplicatie op de smartphone. De naam van deze applicatie is MyGlass en bevat allerlei mogelijkheden om de Glass met de smartphone te beheren. Als de verbinding met Glass is opgezet heeft de Glass toegang tot de GPS-locatie van de smartphone.
Om geofencing te implementeren moet bepaald worden welke technieken er nodig zijn. Een essentieel onderdeel van geofencing is het opvragen van de geografische locatie. Er moet een keuze gemaakt worden tussen beschikbare mogelijkheden. Geofencing voor Android kan op twee verschillende manieren geïmplementeerd worden:
Door het gebruik van Google Play Services waarmee geofence monitoring gebruikt kan worden. Door gebruik te maken van de Android locatievoorzieningen waarbij je de locatie gebruikt om de geofence te berekenen.
Geofencing wordt standaard ondersteund door Google Play Services. Google Play Services is een SDK en API waar Android-applicaties mee kunnen communiceren. Door te communiceren met Google Play Services is het mogelijk om de services van Google te integreren in de applicatie. Voorbeelden van Google Services zijn Google+, Google Maps, Google Play Games etc. Door gebruik te maken van de Location API’s van Google is het mogelijk om geofences te registreren. Google Play Services wordt in de Android-documentatie aangeraden als best practice. Op dit moment wordt Google Play Services echter nog niet ondersteund door Google Glass. Hierdoor is het niet mogelijk om geofencing op deze manier te implementeren. Het alternatief is het schrijven van een eigen geofencing library. Bij het ontwikkelen van de library moet er rekening gehouden worden met de frequentie van het ophalen van de locatie. Hoe verder de dichtstbijzijnde geofence zich bevindt van de huidige locatie des te minder frequent de huidige locatie opgehaald hoeft te worden. En hoe dichterbij de dichtstbijzijnde locatie hoe vaker de huidige locatie opgehaald moet worden. Er is daarom gekozen om de functionaliteit te implementeren waarmee het mogelijk is om variabele updatefrequenties te definiëren op basis van de afstand tot de dichtstbijzijnde geofence. Hieronder volgt een voorbeeld van een aantal te definiëren updatefrequenties: Afstand tot dichtstbijzijnde geofence < 15 meter < 50 meter < 150 meter < 500 meter < 5000 meter 5000+ meter
Updatefrequentie 3 seconden 6 seconden 10 seconden 25 seconden 60 seconden 300 seconden
In Bijlage B staat het ontwerp van de geofencing library.
Om te bepalen of men zich in een geografisch gebied bevindt, moet het geografische gebied worden gedefinieerd als een geofence. Voor de ontwikkeling van een native Glass-applicatie is er op dit moment slechts één manier op geofencing te implementeren. Namelijk door zelf geofencing te berekenen aan de hand van de huidige locatie en de geofences. Om dit doel te bereiken is er een geofencing library geschreven. Hiermee kunnen geofences worden gedefinieerd en toegevoegd aan een verzameling geofences. Door het instellen van een updatefrequentie zal de applicatie met behulp van remote GPS om de x-aantal seconden berekenen of men zich binnen één of meerdere geofences bevindt.
Onderstaand JSON object toont het ontwerp dat is gebruikt als opslagprotocol voor het uitwisselen van gegevens tussen de Glass-applicatie en de Windows-applicatie. { "sessionname": "", "startDateTime": "", "events": [ { "eventType": "sensor", "time": 1000, "value": { "sensortype": "gravity", "values": [] } }, { "eventType": "notificationMessage", "time": 1003, "values": { "message": "" } }, { "eventType": "sensor", "time": 1010, "value": { "sensortype": "gyroscope", "values": [] } }, { "eventType": "sensor", "time": 1015, "value": { "sensortype": "rotation-vector", "values": [] } }, { "eventType": "enterGeofence", "time": 1015, "value": { "long": 0, "lat": 0 } }, { "eventType": "pictureTaken", "time": 1030, "value": { "pictureBase64" : "oVAsuzhOzy0RTv8DI07wAA" } } ], … }
Het volgende ontwerpdiagram toont het ontwerpdiagram welke is ontworpen als voorbereiding voor de ontwikkeling van de geofencing library. De geofencing library is gebruikt in de Glassapplicatie.
requestLocationUpdates 20 sec
requestLocationUpdates 5 sec
requestLocationUpdates 60 sec
onLocationChanged
close far
very far no
distanceTo ClosestGeofence
current latitude longitude
isActiveGeofence
leaveGeofence locationInGeofence addGeofence
remove
enterGeofence yes
Check distance to all geofences
Geofences
geofence
Start geofencing
add
Active Geofences
Masc is een bedrijf in Nijmegen dat in de loop der jaren is opgedeeld in drie divisies en een subdivisie:
Masc Software o Research and Development Masc ICT Masc Webmarketing
Masc Software houdt zich voornamelijk bezig met het ontwikkelen van software en apps. We ontwikkelen onder meer informatiesystemen, databasesystemen en applicaties voor mobiele apparaten. Ook de gebruikte techniek en programmeertalen zijn ongelimiteerd. Masc zoekt samen met opdrachtgevers naar de beste oplossing voor een probleem en onderzoekt nieuwe mogelijkheden en technieken. Masc ICT houdt zich bezig met ICT-oplossingen voor bedrijven. Enkele voorbeelden hiervan zijn netwerkoplossingen, virtualisatie, cloudservices en systeembeheer. Masc Webmarketing richt zich op online presence. We ontwikkelen websites, webshops en online marketingcampagnes.
Ben je benieuwd naar Masc en wil je met ons praten over de mogelijkheden van Glassware voor jouw organisatie? Neem dan contact met ons op. Oranjesingel 73 6511 NR Nijmegen www.masc.nl www.mascglassware.nl
T: (024) 388 85 00 E:
[email protected]
