Projektdokumentation. Erweiterte Realität am Fallbeispiel eines Smartphones

Transkript

1 Projektdokumentation Hochschule Fulda Wintersemester 2010/2011

2 Inhaltsverzeichnis 1. Einleitung 2 2. Vorbereitung Augmented Reality Einarbeitung in die Entwicklungsumgebung von Android Das Betriebssystem Android und dessen Entwicklungsumgebung Android SDK, Eclipse und ADT Debuggen mittels ADB, DDMS Augmented Reality beispielhafte Umsetzung für Android Erste Schritte Zugriff auf die Kamera OpenGL ES Objekte erstellen und einbinden Sensorwerte auslesen und benutzen GPS-Daten auslesen und benutzen OpenGL ES Objekte innerhalb des Kamerabildes anzeigen lassen Mit Hilfe der Sensorwerte, OpenGL ES Objekte dynamisch im Raum bewegen lassen Persönliches Fazit Anhang Seite 1 / 27

3 1. Einleitung Anhand dieses Projektes möchte ich einen Einblick in die Augmented Reality (dt. Erweiterte Realität) geben und anhand einer Beispielanwendung für ein Smartphone zeigen, wie man solch eine Anwendung umsetzen könnte. Die Idee zu diesem Projekt kam mir einerseits durch meine Interesse an Googles neuem mobilen Betriebssystem Android und andererseits durch den immer größeren werden Hype rund um das Thema Augmented Reality. In den verschiedensten Medien setzt man sich mit diesem Thema auseinander. Erste Anwendungen für verschiedene Smartphones und Spielekonsolen sind bereits entworfen wurden. Einige Marketing-Abteilungen setzen bereits auf Augmented Reality, um Kunden ein interessanteres und umfangreiches Angebot präsentieren zu können. Alle Anwendungen haben eins gemeinsam: sie verwenden Endgeräte und binden mit Hilfe von Sensoren und Kameras virtuelle Objekte in das Display des Endgerätes ein. Was nun genau mit Augmented Reality gemeint ist, möchte ich im nächsten Kapitel kurz erläutern. Für ein auf Android basierendes Smartphone soll eine solche Anwendung beispielhaft umgesetzt werden. Aufgrund des engen Zeitrahmens habe ich mich nur auf die wesentlichen Grundstrukturen für die Entwicklung einer Augmented Reality Anwendung begrenzt. Diese sollen aber einen guten Einstieg in die Entwicklung vermitteln und Anreiz bieten, weit aus komplexere Anwendungen zu gestalten. Voraussetzungen hierfür sind neben Kenntnissen in der Programmiersprache JAVA auch Geduld und genügend Zeit, die die Einarbeitungszeit für sich beanspruchen wird. Zunächst soll ein Einblick in die Entwicklungsumgebung von Android gegeben werden, welche die ersten Schritte bis hin zur ersten eigenen Anwendung erklärt. Da auch das Debuggen und die Fehlersuche immer hilfreich sein können, werde ich auch hierzu ein paar Worte schreiben Seite 2 / 27

4 Im Anschluss daran werden die Grundstrukturen einer Augmented Reality Anwendung für Android vorgestellt und gezeigt, wie diese umgesetzt werden können. 2. Vorbereitung 2.1 Augmented Reality Am Anfang meines Projektes stand für mich zunächst die Informationsbeschaffung und die Auseinandersetzung mit der Frage Was ist Augmented Reality eigentlich? an. Des Weiteren war es wichtig für mich, mich in die Entwicklungsumgebung von Android einzuarbeiten und mich mit der Programmierung einer Anwendung für ein auf Android basierendes Smartphone vertraut zu werden. Zum Thema Augmented Reality verfolgte ich neben diversen Blogeinträgen insbesondere im Social Network Twitter Beiträge zu diesem Thema, da hier relativ viele Informationen innerhalb des gesamten Zeitrahmens gefunden werden konnten. Man muss beachten, dass dieses Thema zur Zeit einen richtigen Ansturm erlebt und es eine Fülle an Informationen gibt. Unter all diesen Informationen fanden sich bereits Anwendungen, die das Konzept der Augmented Reality gut umsetzten. Das Konzept der Augmented Reality besteht darin, durch eine Kombination von virtueller Realität mit der Realität dem Benutzer zusätzliche Informationen im Form von Textnachrichten oder grafischen Objekten in Echtzeit anzubieten, die kontextabhängig dargestellt werden. Die Einblendung dieser Informationen geschieht meist über das Sichtfeld des Benutzers, beispielsweise über ein Display eines Smartphones oder einer Datenbrille. So wird das reale Sichtfeld eines Seite 3 / 27

5 Touristen beispielsweise durch auf seinem Smartphone-Display eingeblendete Hinweise und Erklärungen zum aktuellen Standort erweitert. Die Anwendung Layar sei hierfür als Beispiel genannt. Abb. 1: Layar: The first mobile augmented reality browser, SHAWN HONNICK, ; Stand: Im Bereich der Spieleindustrie hat die Augmented Reality ebenfalls erste Fortschritte gemacht. Als Beispiel sei hier Kinect genannt. Ein System zur Bewegungssteuerung auf der Xbox360. Lediglich über drei verschiedene Kameras wird der gesamte Körper des Spielers analysiert und Bewegungen entsprechend umgesetzt. Die Anwendungszwecke einer Augmented Reality Anwendung reichen also von Spielen, über die ins Sichtfeld projektierte Navigation bis hin zu Informationen über die unmittelbare Umgebung Seite 4 / 27

6 2.3 Einarbeitung in die Entwicklungsumgebung von Android Die Einarbeitung in die Entwicklungsumgebung von Android nahm ich mir anhand verschiedener Tutorials vor. Dazu verwendete ich neben neu erschienener Literatur, die sich mit diesem Thema auseinandersetzte, auch diverse Artikel aus Fachzeitschriften, die in die Programmierung einführten, Details und Struktur von Android erklärten und anhand von kleineren Anwendungsfällen ebenfalls erste Schritte zur eigenen Anwendungen führten. Sämtlich verwendete Literatur kann dem Literaturverzeichnis entnommen werden. 3. Das Betriebssystem Android und dessen Entwicklungsumgebung Bei Android handelt es sich um eine Linux-Plattform, die von der Open Handset Alliance (OHA) ständig weiterentwickelt und als Open-Source-Software zur Verfügung gestellt wird. Die OHA umfasst mittlerweile 79 Mitglieder, darunter zahlreiche bekannte Firmen der mobilen Welt. Android ist inzwischen nicht nur auf Smartphones im Einsatz, sondern auch auf Tablets, in Googles TV-Plattform und im Automobilbereich. Die Anwendungen für Android werden üblicherweise in Java geschrieben, die dann unter einer virtuellen Maschine namens Dalvik laufen (DVM). Dalvik ähnelt der Java Virtual Machine (JVM), denn beide führen letztendlich Byte-Code aus. Allerdings unterscheidet sich die Prozessorarchitektur: im Gegensatz zu einer JVM, die auf Stapelmaschinen aufbaut, baut DVM auf einer Registermaschine auf. Übersetzte Anwendungen enden daher auch nicht auf *.class sondern auf *.dex. Folgende Abbildungen soll dies verdeutlichen: Seite 5 / 27

7 Android App.java APK Android Java APIs Dalvik VM Native Bibliotheken Linux Kernel Abb. 2: vgl. Schichtung des Android-Systems, Markus Junginer; ix Androiden auf dem Vormarsch S. 18ff.class.jar xml Dateien Abb. 3: vgl. Wie ein Android Package entsteht, Markus Junginer; ix Androiden auf dem Vormarsch S. 18ff.dex Binär-XML Dateien Ausgeführte Android-Anwendungen werden als eigener Prozess ausgeführt, was zu einer erhöhten Sicherheit und Stabilität führt. Des Weiteren können mehrere Anwendungs-Prozesse aktiv zur gleichen Zeit laufen. Im Hintergrund laufende Anwendungen werden vom System automatisch nach einer bestimmten Zeit beendet, oder wenn Ressourcen zurückgeholt werden müssen. Das Besondere an Android-Anwendungen ist die Zuordnung von Aktivitäten (Activities), die letztendlich die Schnittstelle zum Benutzer darstellen. Es kann immer nur eine Aktivität einer Anwendung aktiv sein, mit der der Nutzer interagieren kann. Für die Entwicklung von Android-Anwendungen ist es essentiell, den Lebenszyklus von Aktivitäten und deren Zusammenspiel mit dem Anwendungsprozess zu verstehen. Folgende Abbildung soll einen vereinfachten Lebenszyklus einer Aktivität darstellen, die durch Aufruf der Callback-Methoden interagiert: Seite 6 / 27

8 Activity gestoppt, wird eventuell noch mal ausgeführt oncreate onresume Activity läuft Activity wird fortgesetzt onpause - mit Aufruf einer Aktivität, wird ein Activity-Objekt erstellt - Initialisierung folgt durch Aufruf von oncreate-methode - onresume-methode holt die Aktivität in den Vordergrund - wird die Aktivität verlassen, wird onpause-methode aufgerufen 1 (weitere weniger relevante Callback-Methoden sind der SDK-Dokumentation zu entnehmen) Für die Entwicklung von Android-Anwendungen in der Praxis empfiehlt sich der Einsatz von Eclipse mit installierten Android Development Tools (ADT). Alternativen wären Ant 2 oder IntelliJ IDEA Grundvoraussetzung ist die Installation des Android SDK und natürlich einer vorhandenen JVM. Im Folgenden möchte ich die Installation des Android SDK und die Einrichtung der Entwicklungsplattform Eclipse erläutern Seite 7 / 27

9 3.1 Android SDK, Eclipse und ADT Unter der Internetadresse finden sich Installationsanweisungen. Im Prinzip muss das entsprechende Paket heruntergeladen, ausgeführt und installiert werden. Anschließend wird in Eclipse über Help Install New Software Add Sites die Adresse hinzugefügt und ein entsprechender Name vergeben. Per Update Funktion kann nun in Eclipse der Android Device Manager installiert und konfiguriert werden. Zum Schluss muss Eclipse nur noch der Pfad zum installierten Android SDK mitgeteilt werden. Dazu unter Windows Preferences öffnen, Android auswählen und den entsprechenden Pfad angeben Seite 8 / 27

10 Der Android Device Manager sollte nun in der Lager sein, alle zur Verfügung stehenden Android Plattformen herunterzuladen und einzurichten Seite 9 / 27

11 Wurde alles ordnungsgemäß eingerichtet, kann nun über File New Other Android Android Project ein Android Projekt erstellt werden: Seite 10 / 27

12 3.2 Debuggen mittels ADB, DDMS Bei der Entwicklung von Softwareprodukten ist es essentiell, die erstellte Software auf Fehler zu überprüfen oder ausgegebene Fehlermeldungen zu analysieren und zu beheben. Allerdings sind Fehler auf echten Android Geräten zur Laufzeit schwerer zu entdecken. Hinzu kommt, dass sich der Android Emulator von den echten mobilen Geräten im Verhalten unterscheidet. Mit Unterstützung der bereitgestellten Tools, Hilfsmittel und Techniken soll die Fehlersuche schneller von Statten gehen. Eines der vom Android SDK zur Verfügung gestelltes Programm ist die Android Debug Brigde (ADB), die eine Verbindung zwischen ADT und dem Emulator. Des Weiteren ermöglicht die ADB es, auf laufendem Programmcode des Emulator oder eines angeschlossenes Android-Smartphones zuzugreifen. Dabei stellt ADB neben Befehlen für Kopieren, Installieren von Dateien bzw. Anwendungen, Auslesen von System-Log-Einträgen auch eine Remote Shell zur Verfügung. In Eclipse ist die ADB bereits durch das Plugin ADT integriert. Mittels des Dalvik Debug Monitor Service (DDMS) lassen sich Anwendungsprozesse auf einem Android-Smartphone oder im Emulator überwachen. Der DDMS ähnelt den bereits bekannten Debuggen eines Java- Programms. Viele Funktionen der ADB lassen sich von hier aus bequem steuern, da diese integriert ist. Des Weiteren ist es möglich Screenshots aufzunehmen, eine Port-Weiterleitung einzurichten, SMS, GPS-Daten und Anrufe zu simulieren sowie thread- und heap-eigenschaften auszulesen. Um das Debugging auf einem Android-Smartphone zu starten, muss neben der Seite 11 / 27

13 korrekten USB-Treiberinstallation für das jeweilige Betriebssystem (wird normalerweise mit der Android SDK Installation vorgenommen, weitere Informationen findet man in der Dokumentation 4 ) auch der Debugger-Modus auf dem Android-Smartphone selbst eingestellt sein. Entsprechende Einstellung hierzu findet man unter Einstellungen Anwendungen Entwicklung Häkchen bei USB-Debugging. Der Punkt Falsche Standorte ermöglicht es, GPS-Daten zu simulieren. Abschließend muss noch ein Eintrag im Android-Manifest vorgenommen werden. Das <application>-tag muss um das Attribut android:debugable= true erweitert werden. Da sich das Betriebssystem Android seit seinem Erscheinen schnell weiterentwickelt hat, ist es für Entwickler erforderlich, sich stets über Aktualisierungen und Neuerungen zu informieren. Sind die grundlegenden Fakten, wie der Aktivitäten-Lebenszyklus verstanden, sollte die Entwicklung von Android-Anwendungen nicht schwer fallen. Dennoch bietet die API stets Neuigkeiten und Herausforderungen, allein die Gestaltung eines professionellen Userinterfaces erfordert viel Erfahrung. Die SDK Dokumentation bietet hier jedoch einen ersten Einstieg, auch wenn sie meines Erachtens noch recht mager ausfällt Seite 12 / 27

14 4. Augmented Reality beispielhafte Umsetzung für Android Es gibt unterschiedliche Ansätze für Augmented Reality auf mobilen Endgeräten. Neben Bilderkennung von QR-Codes (zweidimensionaler Strichcode), Abfrage von GPS-Daten und/oder Sensorwerten, ist auch eine komplette Überlagerung der Realität mit erweiterten virtuellen Objekten möglich. Ich möchte im Folgenden die Ansätze zur Realisierung einer Augmented Reality Anwendungen erläutern. Für die Realisierung verwende ich ein Android-Smartphone von Samsung, das Galaxy S i9000, mit der zur Zeit aktuellen Android Version 2.2 (Froyo). Leider ist es mir aufgrund eines Fehlverhaltens meines Smartphones nicht möglich, die sensorbasierende Bewegung von OpenGL ES Objekten zu realisieren. Ich werde die Grundzüge aber vorstellen. Alle Codeschnipsel sind in der Verzeichnisstruktur aufgeführt und befinden sich vollständig im Dateiverzeichnis dieser Ausarbeitung. 4.1 Erste Schritte Zunächst muss die Aktivität für die Anwendung angelegt werden. Diese wird für die späteren Abläufe benötigt. Mit Erstellung eines neuen Android-Projektes wird dies vorgenommen. Folgender Code-Ausschnitt sollte dies darstellen: public class ersteaktivitaet extends Activity { /** Called when the activity is first created. public void oncreate(bundle savedinstancestate) { super.oncreate (savedinstancestate); setcontentview(r.layout.main); Wie bereits erwähnt, wird für den Anwendungs-Prozesse eine Aktivität mittels der oncreate-methode erstellt. Der Aufruf von der setcontentview-methode kümmert sich um das Layout, welches aus den Ressourcen geladen werden kann. Das Seite 13 / 27

15 Layout kann auch im Android-Manifest festgelegt werden. Nähere Informationen sind der Dokumentation 5 zu entnehmen. Je nach Hardware-Zugriff muss im Android-Manifest eine entsprechende Regelung festgelegt werden sonst bleibt der Zugriff verwehrt. Entsprechende Einträge kann man ebenfalls der Dokumentation 6 entnehmen. 4.2 Zugriff auf die Kamera Um nun auf die Kamera zuzugreifen, muss die setcontentview-methode so angepasst werden, dass das Vorschaubild der Kamera direkt eingebunden wird. public class Kamerabenutzung extends Activity { /** Called when the activity is first created. public void oncreate(bundle savedinstancestate) { super.oncreate public void onresume () { super.onresume(); setcontentview(new PreviewCamera (this)); Mit Ausführung der Aktivität wird ein sogenannter SurfaceView der Klasse PreviewCamera als Layout definiert. Die Klasse PreviewCamera ist hierbei für das Kamerabild verantwortlich, welches sie entsprechend darstellt. Die Klasse PreviewCamera muss hier die Klassen SurfaceHolder und SurfaceView implementieren. Die entsprechenden zu überschreibenden Methoden würden wie folgt aussehen: Seite 14 / 27

16 Camera camera; public PreviewCamera (Context context)extends SurfaceView implements SurfaceHolder.Callback { super (context); // TODO Auto-generated constructor stub getholder ().addcallback (this); getholder ().settype (SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS); Die Variable camera dient zum Ansprechen der Hardwarekamera. Um Änderungen (Bild, Frame) der Kamera abzufragen, muss ein SurfaceHolder implementiert werden, der über einen entsprechenden SurfaceListener abgefragt public void surfacecreated (SurfaceHolder holder) { // TODO Auto-generated method stub camera = Camera.open (); try { camera.setpreviewdisplay (this.getholder ()); catch (IOException e) { Log.e("Camera", "camera.setpreviewdisplay(holder);"); public void surfacedestroyed (SurfaceHolder holder) { // TODO Auto-generated method stub try { camera.stoppreview (); camera.release (); catch (Exception e) { Log.e("Camera", e.getmessage()); Seite 15 / 27

17 Nur so ist es möglich, stets das aktuelle Bild der Kamera auf dem Display auszugeben. 4.3 OpenGL ES Objekte erstellen und einbinden Möchte man lediglich ein graphisches Objekt auf dem Display anzeigen lassen, so muss ebenfalls ein SurfaceView festgelegt werden, der vom Typ als SURFACE_TYPE_GPU festgelegt wird. Um entsprechende Methoden für OpenGL ES Objekte verwenden zu können müssen einige Klassen importiert werden. Android bietet hierzu neben der Klasse android.opengl.glu auch OpenGL ES über entsprechende Klassenbibliotheken an. Für die Beispielanwendung habe ich das Listing zu OpenGL ES aus dem Buch Android Anwendungen für das Handybetriebssystem erfolgreich programmieren von Heiko Mosemann und Matthias Kose verwendet. Es ist ebenfalls im Dateiverzeichnis vorhanden (Listing 16.3, Listing 16.4, Listing 16.5, Listing 16.6). Die Darstellung eines OpenGL ES Objektes entspricht im größten Teil der bisher bekannten Art und Weise wie übliche OpenGL Objeke dargestellt werden. In der init-methode werden alle relevanten Dinge für OpenGL ES initialisiert, über die getegl-methode wird eine Instanz festgelegt, die über die eglgetdisplay- Methode eine Verbindung zur Render-Ausgabe herstellt. Mittels der eglinitialize- Methode wird der EGL-Kontext geschaffen Seite 16 / 27

18 Seite 17 / 27

19 4.4Sensorwerte auslesen und benutzen Android-Smartphones bieten in der Regel zahlreiche Sensoren an, die ausgelesen werden können. Neben Bewegungs-, Beschleunigungssensoren, gibt es unter anderem auch magnetische Sensoren und Lagesensoren. Die Implementierung gestaltet sich relativ einfach: public class Sensoren extends Activity implements SensorEventListener { SensorManager sensor = null; final String tag = "Sensor"; /** Called when the activity is first created. public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); sensor = (SensorManager) getsystemservice(sensor_service); public void onaccuracychanged(sensor sensor, int accuracy) { // TODO Auto-generated method public void onsensorchanged(sensorevent event) { // TODO Auto-generated method stub public void onaccuracychanged(int sensor, int accuracy) { // TODO Auto-generated method stub Log.d(tag,"onAccuracyChanged: " + sensor + ", accuracy: " + accuracy); public void onsensorchanged(int sensor, float[] values) { // TODO Auto-generated method stub Log.d(tag, "onsensorchanged: " + sensor + ", x: " + values[0] + ", y: " + values[1] + ", z: " + values[2]); Zunächst muss die Klasse Sensoren einen SensorEventListener implementieren, Seite 18 / 27

20 der auf Ereignisse reagiert. Die Variable sensor vom Typ Sensormanager wird ein Sensortyp zugewiesen. Wenn nicht bekannt ist, welche Sensoren zur Verfügung stehen oder alle Sensoren abgefragt werden sollen, kann dies über SENSOR_SERVICE getätigt werden. Spätere Abfragen, um welchen Sensore es sich handelt sind möglich. Bei Änderungen sollen jeweils Log-Einträge verfasst werden. 4.5GPS-Daten auslesen und benutzen Ähnlich wie die Sensoren lassen sich auch die GPS Daten relativ einfach auslesen. Aus Platzgründen werde ich nur die relevanten Methoden hier vorstellen. Der kompletten Quelltext kann im Dateiverzeichnis betrachtet werden. public class GPS extends Activity implements LocationListener { LocationManager standort; final String tag = "GPS"; /** Called when the activity is first created. public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); standort = (LocationManager) getsystemservice(location_service); Die Klasse GPS muss, um GPS-Daten abfragen zu können, die Klasse LocationListener implementieren. Dadurch ist es möglich, Standortänderungen wahrzunehmen, Abfragen zum GPS-Status zu stellen und ggf. die Aktualisierung vorübergehend zu deaktivieren um Batterie zu sparen, zum Beispiel wenn der Anwendungs-Prozesse in den Hintergrund gerät Seite 19 / 27

21 @Override protected void onresume() { standort.requestlocationupdates(locationmanager.gps_provider, 5000, 10f, this); protected void onpause() { standort.removeupdates(this); super.onresume(); Sobald die Anwendung ausgeführt wird, soll der aktuelle GPS-Standort erfragt werden. Hierzu wird die onresume-methode überschrieben und der Variablen standort ein LocationListener hinzugefügt, der alle 5 Sekunden oder 10 Meter aktualisiert werden soll. Bei Unterbrechungen (Hintergrundprozess) soll die Aktualisierung deaktiviert werden. Hierzu wird die onpause-methode entsprechend überschrieben. 4.6OpenGL ES Objekte innerhalb des Kamerabildes anzeigen lassen Wie im vorherigen Teil angesprochen, muss ein SurfaceView angelegt werden, um auf dem Display eine entsprechende Ausgabe von der Kamera oder einem OpenGL ES Objekt zu erhalten. Wenn man nun beide Aspekte miteinander verbinden will, bedeutet dies, dass man im Prinzip zwei SurfaceView miteinander verbinden muss. Um es besser zu verstehen, kann man dies sich als zwei Ebenen vorstellen, die übereinander gelegt werden. Hier muss man allerdings beachten, dass eine der Ebenen, vorzugsweise die, die für die OpenGL ES Objekte verantwortlich ist, nur einen Teilbereich des anderen SurfaceViews ausfüllt und transparent dargestellt wird. Ansonsten sieht man im wahrsten Sinne des Wortes nur schwarz Seite 20 / 27

22 @Override public void onresume () { super.onresume(); glview = new GLLayer(this); previewcam = new PreviewCamera(this, glview); setcontentview (glview); addcontentview(previewcam, new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)); Es werden hier zwei SurfaceViews angelegt, wovon das erste (glview) für die Darstellung des OpenGL ES Objektes zuständig ist und previewcam sich um die Darstellung des Kamerabildes kümmert. Die Variable previecam ist wie im Beispiel für die Kamera implementiert wurden, also vom Typ PrevieCam. Die Klasse PreviewCam wurde genauso implementiert wie im Beispiel für die Kamera angegeben. Lediglich eine zusätzliche Implementierung der Klasse PreviewCallback führt zu einer zusäzlichen public void onpreviewframe(byte[] arg0, Camera arg1) { if (callback!=null) callback.onpreviewframe(arg0, arg1); und um eine Zeile mehr in der surfacecreated-methode: Seite 21 / 27

23 @Override public void surfacecreated (SurfaceHolder holder) { // TODO Auto-generated method stub synchronized(this) { camera = Camera.open (); Parameters param = camera.getparameters (); param.setpreviewsize(240, 120); camera.setparameters(param); try { camera.setpreviewdisplay (this.getholder ()); catch (IOException e) { Log.e("Camera", "camera.setpreviewdisplay(holder);"); camera.startpreview(); camera.setpreviewcallback(this); setpreviewcallback ist hierbei hinzugekommen. Diese Methode wird aufgerufen, sobald eine neues Frame dargestellt wurde. Für die Darstellung des OpenGL ES Objektes kann ein beliebiges OpenGL ES Objekt nun verwendet werden. Da bereits in einem früheren Abschnitt OpenGL ES erklärt wurde, verzichte ich hier darauf. Es sei lediglich darauf hingewiesen, dass für die Darstellung des OpenGL ES Objektes folgende Vereinbarung im jeweiligen Konstruktur getroffen werden muss: public GLView (Context context) { super (context); // We want an 8888 pixel format because that's required for // a translucent window. // And we want a depth buffer. this.seteglconfigchooser(8, 8, 8, 8, 16, 0); this.setrenderer(this); this.getholder().setformat(pixelformat.translucent); Die Angabe von PixelFormat.TRANSLUCENT ist erforderlich, da sonst keine Seite 22 / 27

24 Überblendung mit dem Kamerabild stattfinden würde. 4.7Mit Hilfe der Sensorwerte, OpenGL ES Objekte dynamisch im Raum bewegen lassen Für diesen Abschnitt hatte ich mir eigentlich vorgenommen, die zuvor vorgestellten Konzepte miteinander zu kombinieren und so eine kleine Beispielanwendung für Augmented Reality zu entwerfen. Allerdings musste ich zu der Erkenntnis kommen, dass ich entweder einen Fehler in meiner Anwendung habe, oder die Herangehensweise völlig falsch war. Denn so recht funktionieren wollte es nicht. Die Überlagerung zweier SurfaceViews klappt soweit, sobald aber Sensorwerte mit abgefragt werden sollen, wird mir auf meinem Smartphone lediglich ein schwarzes Display angezeigt und die Anwendung stürzt ab. Auf der Suche nach der Fehlerquelle hatte ich Log-Einträge ausgelesen und im Debugger-Modus die Anwendung analysiert. Ich konnte keine Fehlerquelle ausfindig machen. 7 Auf der Suche nach Rat bin ich im Internet auf eine Beispielanwendung gestoßen, die mehrere Würfel im Display abhängig vom Beschleunigungssensoren und Orientierungssensor darstellen soll. Es gibt sogar eine Demo 8, die man sich auf seinen Smartphone installieren kann. Diese Demo hatte ich bei mir installiert und das Ergebnis war keine Freude: auch hier begrüßte die Anwendung mich mit einem schwarzen Display und stürzte kurz darauf ab. Ein Kommentar auf der Website weist darauf hin, dass die Anwendung nicht auf einem Samsung Galaxy S laufen würde. Ich hatte probiert, es über andere Möglichkeiten zu realisieren, bin jedoch in der restlichen Zeit zu keinem brauchbaren Ergebnis gekommen Seite 23 / 27

25 5. Persönliches Fazit Lehrveranstaltung Graphisch Interaktive Systeme WS 2010/2011 Trotz der aufgetretenen Probleme hat mir die Arbeit an diesem Projekt sehr viel Spaß gemacht. Die Zeit, in der ich Debug-Meldungen betrachte, auswertete und versuchte mögliche Fehlerquellen zu eliminieren werde ich wohl nicht so schnell vergessen. Ich werde mich dennoch weiterhin mit der Programmierung von Android Anwendungen auseinandersetzen. Allein nur um den Einblick, den ich durch diese praxisnahe Erfahrung gewonnen habe, weiter zu vertiefen. Die Vorlesung Graphisch Interaktive Systeme bietet meines Erachtens genau den richtigen Rahmen, um sich mit hoch interessanten und aktuellen Themen auseinandersetzen und so seine ersten persönlichen Erfahrungen mit einer neuen Technik sammeln zu können Seite 24 / 27

26 6. Anhang Softwareressourcen: Java(TM) SE Runtime Environment (build 1.6.0_22-b04), 32-bit und 64-bit Eclipse IDE for Java EE Developers (Eclipse Helios 3.6, 32-bit und 64-bit) ADT Plugin für Eclipse Android SDK (Linux i386) SDK Tools, r8 Hardwareressourcen: Typ Name Spezifikation Android OS, v2.2 (Froyo) ARM Cortex A8 1GHz Prozessor Smartphone Samsung i GB/16GB Datenspeicher, 512 MB Galaxy S RAM, 2GB ROM Desktop-PC Desktop-PC Eigenbau Medion Titanium 8080 weitere techn. Details 9 Windows 7 Professional x64 Ubuntu (maverick) x64 i860 Quad 2.80 GHz 4GB RAM 2x 500 GB Datenspeicher Windows XP Professional SP3 x86 Pentium GHz 2 GB RAM 160 GB Datenspeicher /GT-I9000HKDDBT/detail.aspx?atab=specifications Seite 25 / 27

27 Quellen: Becker, Arno (Hrsg.); PANT, Markus: Android 2 Grundlager der Programmierung. 2., aktualisierte und erw. Aufl. Heidelberg : dpunkt-verl., 2010 MOSEMANN, Heiko (Hrsg.); KOSE, Matthias: Android Anwendungen für das Handybetriebssystem erfolgreich programmieren. Akt Auflage. München : Hanser, 2009 Eisele, Markus: Entwicklen für Googles Android Jenseits von Hallo Welt In: ix 6/2009, S. 126 Lau, Oliver: Beep Beep Einführung in die Pogrammierung des Google- Handys In: c't 12/2011, S. 172 Becker, Arno: Die Systemarchitektur von Android Ein Blick ins Innere In: mobile developer android 4/2010, S. 28 Linke, Andreas: Apperitif Einführung in die Entwicklung von Android- Apps, Teil 1 In: c't 22/2010, S. 188 Linke, Andreas: A la carte Einführung in die Entwicklung von Android- Apps, Teil 2 In: c't 24/2010, S. 194 Linke, Andreas: Gut geschüttelt Einführung in die Entwicklung von Android-Apps, Teil 3 In: c't 1/2010, S. 172 Beier et ai., Andreas: Die eigene App Entwicklen für Android, iphone, WebOS, Symbian, Blackberry und Windows Mobile In: c't 16/2010, S. 90 Becker, Arno: Die ersten Schritte zur eigenen App Bitte Einsteigen In: mobile developer android 1/2011, S Seite 26 / 27

28 Becker, Arno: Debugging von Android Programmen Falsches flott finden In: mobile developer android 1/2011, S. 38 Junginger, Markus: Zeitgemäße App-Entwicklung für Googles mobiles Betriebssystem Androiden auf dem Vormarsch In: ix developer 1/2011, S. 11 Ableson, Frank: Das Android-OS als Brücke zwischen realer und digitaler Welt Sensoren, Sensoren In: mobile OS 1/2011, S. 70 diverse Android SDK Documentation, Website, Camera image as an OpenGL texture on top of the native camera viewfinder, Website, Simple AR example, Website, Android Anwendungen für das Handybetriebssystem erfolgreich programmieren.; MOSEMANN, Heiko (Hrsg.); KOSE, Matthias; Listing 16.3, Listing 16.4, Listing 16.5, Listing Seite 27 / 27