Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m
Advertisement
  1. Code
  2. Android SDK
Code

Android SDK Erweiterte Realität: Kamera- und Sensoreinstellungen

Difficulty:AdvancedLength:LongLanguages:

German (Deutsch) translation by Katharina Nevolina (you can also view the original English article)

Augmented Reality (AR) (Erweiterte Realität) ist heute ein heißes Thema in mobilen Apps.  Smartphones und Tablets verfügen über die Leistung und die Hardware, die es Entwicklern ermöglichen, auf interessante Weise interessante neue Anwendungen zu schreiben, die Live-Kamera- und Video-Feeds, hyper-genaue Sensordaten und andere Echtzeit-Benutzerdaten enthalten.  Heute beginnen wir mit der Erforschung der Welt der Augmented Reality und der Möglichkeiten, die die Android-Plattform Entwicklern bietet, die AR-Anwendungen entwickeln und ihren Benutzern tiefe, reichhaltige Erfahrungen bieten möchten.


In dieser Serie sind auch erhältlich:

  1. Android SDK Erweiterte Realität: Kamera- und Sensoreinstellungen
  2. Android SDK Erweiterte Realität: Ort & Entfernung

Schritt 0: Voraussetzungen und Erste Schritte

Dieses Tutorial bewegt sich ziemlich schnell.  Daher erwarten wir von den Lesern, dass sie mit allen Grundlagen zum Erstellen und Ausführen von Android-Projekten vertraut sind.  Wir erwarten außerdem, dass die Leser ein Android-Gerät haben, das ausreichend leistungsstark ist, um AR-Apps (wie das Nexus S) auszuführen.  Die meisten Tests dieser Anwendung müssen auf einem tatsächlichen Android-Gerät durchgeführt werden, da die App stark von der Kamera, den Sensoren und den Standortdaten abhängt, die im Emulator nicht ohne weiteres verfügbar sind.

Wir haben eine Beispielanwendung in Verbindung mit dieser Anleitung zum Download bereitgestellt.  Dieses Projekt wird im Laufe dieser Premium-AR-Tutorialserie erweitert, also laden Sie das Android-Projekt herunter und folgen Sie ihm!


Teil 1: Welche Art von AR App entwickeln wir?


Zuerst müssen wir (in groben Zügen) definieren, was diese Anwendung tun wird.  Wir wollen bei den typischen Eigenschaften einer AR-Anwendung halten und diese im Laufe der Zeit verbessern.

Welche Art von Anwendung werden wir bauen?  Wir werden eine standortbasierte AR-App erstellen.  Diese AR-Apps zeigen im Allgemeinen an, wo sich die Dinge in der realen Welt befinden, indem sie angeben, wo die App denkt, dass sie sich in der Kameraansicht befinden, wenn der Benutzer das Telefon hält und bewegt.

Ein anderer Typ von AR-App ist der Typ, der das Objekt unter Verwendung von Computer-Vision-Algorithmen erkennt und entweder Informationen über die Kamera zeichnen kann, um zu zeigen, was das Objekt ist, wie es orientiert ist, oder andere Objekte in der Ansicht hinzufügen oder anzeigen kann.  Während wir diese Art von AR-App nicht erstellen werden, können viele der Techniken, die wir hier lehren, auf beide Arten von AR-App angewendet werden.

Die grundlegende Architektur einer standortbasierten Anwendung umfasst eine Kameraansicht, den Standort des Benutzers, die Ausrichtung des Telefons im Vergleich zur realen Welt und eine Liste von Orten für Objekte, die wir auf dem Display anzeigen möchten - die Daten, mit denen wir das Internet die Vision der Kamera von der Welt erweitern.



Dieser erste Teil unserer Serie wird über die Kamera und die Sensoren sprechen.  Im nächsten Teil werden wir über die Standortdaten und die Berechnungen beim Erstellen der App sprechen.


App-Anforderungen: Welche Gerätefunktionen benötigt unsere App?

Ihre typische AR-Anwendung benötigt Zugriff auf die folgenden Gerätefunktionen:

  • Zugriff auf die Kameraansicht
  • Zugriff auf den Standort des Benutzers
  • Zugriff auf andere Gerätesensoren, insbesondere einen Kompass (Beschleunigungsmesser und Gyroskop können ebenfalls nützlich sein)

Die App erfordert möglicherweise auch andere Dienste und Berechtigungen, z. B. Netzwerkzugriff, aber diese sind nicht von zentraler Bedeutung für die AR-Aspekte der App.


Hinweis zu Zielgeräten: Der Nexus S


Nicht alle Android-Geräte (oder Mobilgeräte im Allgemeinen) verfügen über die Hardwarespezifikationen, um mit AR-App-Anforderungen umgehen zu können.  Für die Zwecke dieses Tutorials richten wir uns an das Nexus S mit Android 2.3.4, das unseren spezifischen Hardwareanforderungen gerecht wird.  Daher zielt unsere Anwendung auf eine sehr spezifische Version des Android SDK ab.  Das wird die App einfach halten.  Die SDK-Anforderungen können jedoch flexibler sein, sobald das Android-Manifest erforderliche Hardwarefunktionen korrekt identifiziert, oder Sie implementieren alternative Funktionen für weniger leistungsfähige Geräte.

Während das Nexus S in der Lage ist, vernünftige AR-Aufgaben zu bewältigen, sind auch viele andere Geräte, einschließlich einiger älterer Geräte, in der Lage.  Wenn Sie eine Produktionsanwendung erstellen, die die AR-Technologie verwendet, sollten Sie Ihre Zielgeräte sorgfältig auf Antwort, Benutzerfreundlichkeit und korrekte Funktionalität testen.


Teil 2: Projekteinrichtung


Jetzt sind wir bereit für die Entwicklung!  Lassen Sie uns zuerst ein AR-Projekt richtig einrichten.  Diese Anwendung ist wie jedes andere Anwendungsprojekt in Eclipse konfiguriert.


Schritt 1: Erstellen Sie ein neues Eclipse-Projekt


Beginnen Sie mit dem Erstellen eines neuen Android-Projekts in Eclipse.  Hier sind die Projektdetails, die wir für das Beispielprojekt verwendet haben (zum Download verfügbar):

  • Projektname: ARTUT
  • API Level Min/Ziel: 10
  • Aktivitätsklasse starten: ArtutActivity

Schritt 2: Konfigurieren Sie die Manifestdatei


Als Nächstes möchten Sie die Android-Manifestdatei konfigurieren.  Sie sollten die folgenden Einstellungen angeben:

Fügen Sie auf der Registerkarte Manifest Einstellungen für Folgendes hinzu:

  • android.hardware.camera (Required=true) 
  • android.hardware.camera.autofocus (Required=false) 
  • android.hardware.location.gps (Required=true) 
  • android.hardware.sensor.compass (Required=true) 
  • android.hardware.sensor.gyroscope (Required=true) 
  • android.hardware.sensor.accelerometer (Required=true) 

Auf der Registerkarte Anwendung (Application):

  • Debuggable sollte auf true festgelegt werden

Fügen Sie auf der Registerkarte Berechtigungen (Permissions)  Einstellungen für Folgendes hinzu:

  • android.permission.CAMERA
  • android.permission.FINE_LOCATION

Schritt 3: Schließen Sie das Zielgerät an


Wenn Sie das noch nicht getan haben, müssen Sie ein Android-Gerät zum Testen einrichten und es über USB an Ihren Entwicklungscomputer anschließen.  Wenn Sie das noch nicht getan haben, müssen Sie möglicherweise vor der Verwendung Treiber herunterladen und installieren.

Es macht wenig Sinn, ein Android Virtual Device (AVD) für dieses Projekt zu erstellen, da der Emulator nicht über ausreichende Funktionen zum Testen von Live-Kamera- oder sensorbasierten Anwendungen mit einem gewissen Grad an Effektivität verfügt.  Wir werden unsere gesamte Entwicklung und Tests gegen echte Hardware durchführen.  Neben der Bereitstellung einer besseren Testumgebung bei der Verwendung von Sensoren, der Kamera und anderer Hardware stellen wir auch fest, dass das Testen auf echter Hardware aufgrund der Leistungs- und Funktionsbeschränkungen des Emulators viel schneller ist.


Teil 2: Arbeiten mit der Kamera


Unser erster echter Schritt bei der Entwicklung einer AR-App besteht darin, dass der Inhalt der Kamera auf dem Bildschirm angezeigt wird.  Dazu implementieren wir ein benutzerdefiniertes SurfaceView, das im Layout der Aktivität angezeigt wird. 


Schritt 1: Definieren des App-Bildschirmlayouts


Zuerst müssen wir die Layout-Ressource definieren, die für den Haupt-AR-Bildschirm verwendet wird.  Ein FrameLayout ist für unseren Bildschirm am besten geeignet, da es die Schichtung von Ansichten innerhalb des Anzeigebereichs ermöglicht.  Daher kann unsere Layout-Ressource /res/layout/main.xml ziemlich einfach sein:


Schritt 2: Definieren einer benutzerdefinierten SurfaceView zum Halten des Kamerainhalts


Als Nächstes müssen Sie ein benutzerdefiniertes Ansichtssteuerelement für die Verwendung in Ihrem FrameLayout definieren.  Die SurfaceView-Klasse kann für diesen Zweck verwendet werden.  Daher können Sie diese Klasse verwenden, um Ihre Kamerazeichnung zu kapseln.

Die ArDisplayView-Klasse beginnt mit einem Konstruktor.  Wir haben die Aktivität als Konfigurationsparameter hinzugefügt (mehr dazu in einem nächsten Schritt).  Der Konstruktor muss den zugrunde liegenden SurfaceHolder initialisieren, der die Zeichnung auf dem Bildschirm steuert.

(Eine Anmerkung hier ist, dass obwohl die setType() -Methode veraltet ist und die Android SDK-Dokumentation sagt, dass es nicht mehr notwendig ist, haben wir festgestellt, dass der Kamera-Code ohne sie nicht funktioniert, es startet einfach nicht, sogar auf dem neuesten Geräte.)

Wir haben die entsprechenden Mitgliedsvariablen für die Arbeit mit einer Kamera hinzugefügt, und wir halten auch die Aktivität in der Nähe, sodass wir auf Orientierungsänderungen und jeden anderen bequemen Zugriff auf den Kontext oder die Aktivität reagieren können, die wir benötigen.


Schritt 3: Implementieren der SurfaceHolder Callback


Als Nächstes müssen Sie die SurfaceHolder-Callbacks innerhalb der Klasse implementieren.  Aktualisieren Sie Ihre ArDisplayView-Klasse so, dass sie die SurfaceHolder.Callback-Schnittstelle wie folgt implementiert:

Das erfordert das Überschreiben und Implementieren von drei neuen Methoden: SurfaceCreated(), SurfaceChanged() und SurfaceDestroyed().

Wenn Sie mit der Kamera arbeiten, sind einige Schritte zum Starten und Herunterfahren erforderlich.  Diese Schritte sind in den Android SDK-Dokumenten für die Kamera-Klasse eindeutig dokumentiert.  Wir lassen diese Schritte im Grunde in die entsprechenden SurfaceHolder Callbacks fallen.


Schritt 4: Implementieren Callback von objectCreated()


Wir beginnen mit der Callback-Methode SurfaceCreated().  Hier fordern wir die Kamera an, richten die Ausrichtung der Kamera basierend auf der aktuellen Ausrichtung des Geräts ein (so dass die Kameravorschau immer mit der rechten Seite nach oben zeigt) und rufen die Kameravorschau über die Methode setPreviewDisplay() mit unserem SurfaceHolder auf.


Schritt 5: Implementieren Callback von SurfaceChanged()


Ein Großteil des interessanten Codes für die Vorschau der Kamera findet im Callback von surfaceChanged() statt.  Hier fordern wir die Kameraparameter an und prüfen, welche unterstützten Vorschaugrößen es sind.  Wir müssen eine Vorschaugröße finden, die von der Oberfläche aufgenommen werden kann. Daher suchen wir nach der nächsten Übereinstimmung und verwenden sie als Vorschaugröße.  Als Nächstes stellen wir das Kameravorschauformat ein, übergeben die Änderungen an den Kameraparametern und rufen schließlich die startPreview()-Methode auf, um die Vorschau der Kamera in unserer Oberfläche anzuzeigen.


Schritt 6: Implementieren des SurfaceDestroyed() Callbacks


Wir enden mit der Callback-Methode SurfaceDestroyed().  Hier beenden wir die Kameravorschau und geben die Kamera-Ressourcen frei.


Schritt 7: Die benutzerdefinierte Kameraansicht und die Hauptaktivität

Jetzt müssen Sie Ihre benutzerdefinierten Ansichten zum FrameLayout-Steuerelement hinzufügen.  Aktualisieren Sie dazu die onCreate()- Methode der ArtutActivity-Klasse wie folgt:

Dadurch wird die View-Klasse der Kameravorschau namens ArDisplayView zur FrameLayout hinzugefügt.  Wenn Sie die Anwendung jetzt ausführen, wird die Aktivität gestartet und Sie sollten eine Kameravorschau auf dem Bildschirm sehen.

Ein Hinweis zu Zahlen: Die standardmäßige DDMS-Bildschirmaufnahme erfasst nicht die Kameravorschau.  Führen Sie die App selbst aus, um die wahre Funktionalität zu sehen.


Teil 3: Arbeiten mit den Gerätesensoren


Unser nächster Schritt bei der Entwicklung einer AR-App beinhaltet den Zugriff auf die Gerätesensordendaten.  Wir brauchen auch eine Möglichkeit, Inhalte auf der Kamera zu überlagern. Dazu implementieren wir eine benutzerdefinierte Ansicht, die über die ArDisplayView, die derzeit im FrameLayout-Steuerelement der Aktivität angezeigt wird, überlagert werden kann.


Schritt 1: Overlay-Inhalt anzeigen


Zuerst müssen Sie ein benutzerdefiniertes Ansichts-Steuerelement definieren, um Overlay-Inhalt zu zeichnen.  Erstellen Sie eine neue Klasse namens OverlayView, die von der View-Klasse abgeleitet ist.  Diese Klasse beginnt für diesen Teil des Tutorials einfach.  Wir wollen nur einige Sensordaten über der Kameraansicht überlagern (noch keine Phantasie Mathe).  Dazu erstellen wir Member-Variablen, um die letzten bekannten Sensordaten für jeden Sensor, an dem wir interessiert sind, zu speichern.  Wir implementieren dann die onDraw() -Methode unserer Ansicht und zeichnen etwas Text auf die Leinwand.

Die Methode onDraw() erledigt hier alle Arbeit.  Wir konfigurieren einen Paint mit den entsprechenden Textattributen und zeichnen dann mit der drawText() -Methode etwas Text auf der Zeichenfläche.

Warum verwenden wir eine benutzerdefinierte Ansicht anstelle von regulären Steuerelementen?  Wir werden später Genauigkeit benötigen, um AR-Objekte innerhalb der Kameraansicht zu platzieren, die repräsentativ für Orte von Orten in der realen Welt sind.  Eine Alternative zu dieser Methode besteht darin, das 3D-Rendering zu verwenden, um einen besseren Überblick über Tiefe und Entfernung zu erhalten.  In einer Location AR App ist das normalerweise weniger wichtig, da die Entfernungen oft ziemlich groß sind (Kilometer, nicht Meter).


Schritt 2: Implementieren der SurfaceHolder Callbacks


Als Nächstes müssen Sie die SensorEventListener-Schnittstelle innerhalb der Klasse implementieren.  Aktualisieren Sie Ihre OverlayView-Klasse so, dass sie die SensorEventListener-Schnittstelle wie folgt implementiert:

Das erfordert das Überschreiben und Implementieren von zwei neuen Methoden: onAccuracyChanged() und onSensorChanged().  Für die Zwecke dieses Tutorials interessiert uns nur die Methode onSensorChanged().


Schritt 3: Registrieren für Sensordatenaktualisierungen


Bevor wir die SensorEventListener-Callbacks implementieren, möchten wir uns für die entsprechenden Sensordatenaktualisierungen registrieren.  Aktualisieren Sie dazu die onCreate()-Methode der OverlayView-Klasse.

Beginnen Sie damit, dass Sie den SensorManager anfordern und die Sensoren abrufen, die die Ansicht anzeigen soll.  In diesem Fall sehen wir den Beschleunigungsmesser, den Kompass und das Gyroskop.  Als nächstes registrieren Sie sich, um nach Ereignissen auf jedem dieser Sensoren zu horchen.

Jetzt können Sie den Sensorrückruf onSensorChanged() implementieren, um auf diese Sensoraktualisierungen zu reagieren.


Schritt 4: Implementieren des OnSensorChanged() Callbacks


Ein Großteil des interessanten Codes für die Sensoraktualisierungen findet im onSensorChanged() -Callback statt.  Hier müssen wir die Ansicht auf Sensoränderungen reagieren lassen.  Wir haben uns für verschiedene Arten von Änderungen registriert, daher kann diese Methode für jeden Sensorwechsel aufgerufen werden.  Im Moment möchten wir lediglich die geänderten Sensordaten speichern und dann die Ansicht zwingen, ihren Inhalt zu aktualisieren.  Wir können das tun, indem wir einfach die Ansicht ungültig machen und sie neu zeichnen.


Schritt 5: Ihr benutzerdefiniertes Overlay und die Hauptaktivität


Jetzt müssen Sie Ihre benutzerdefinierte Ansicht dem FrameLayout-Steuerelement hinzufügen.  Aktualisieren Sie dazu die onCreate() -Methode der ArtutActivity-Klasse.  Fügen Sie den folgenden Code direkt unter dem addView()-Aufruf hinzu, der die ArDisplayView hinzufügt:

Dadurch werden die zwei Ansichten gestapelt: zuerst die Ansichtsklasse der Kameravorschau namens ArDisplayView und dann das OverlayView, das die Sensordaten darüber anzeigt.  Wenn Sie die Anwendung jetzt starten, wird die Aktivität gestartet und Sie sollten eine Kameravorschau auf dem Bildschirm sehen, auf der die Sensordaten angezeigt werden (Sie können keine Screenshots der Kameraansicht aufnehmen, daher zeigt die folgende Abbildung nur den Overlay-Inhalt) .



Wenn Sie die App zu diesem Zeitpunkt ausführen, haben Sie wahrscheinlich bemerkt, dass die Sensordaten sehr schnell aktualisiert werden, obwohl nach einer Geschwindigkeit gefragt wurde, die langsam genug ist, um mit Orientierungsänderungen zu arbeiten.  Diese Gerätesensoren haben eine sehr hohe Empfindlichkeit.  Letztlich wird das zu einer Verwacklung in der Benutzeroberfläche führen.  Wir werden eventuell einige Glättungsalgorithmen implementieren müssen, um das Zittern zu vermeiden, wenn wir beginnen, die Sensordaten in unserer Anwendung zu verwenden.

Sie könnten sich auch fragen, ob wir alle diese Sensoren verwenden und welche Einheiten sie haben.  Wir werden nicht unbedingt alle Sensoren verwenden, aber wir dachten, wir würden Ihnen zeigen, wie sie aussehen und wie Sie darauf zugreifen können, falls Ihre speziellen AR-Interessen bei verschiedenen Sensoren liegen.

  • Die Beschleunigungsmesserzahlen sind in SI-Einheiten (m/s^2, d. h. Meter pro Quadratsekunde, wobei die Erdschwere 9,81 m/s^2 ist).
  • Die magnetischen Sensoreinheiten sind in Mikro-Teslas.  Wenn sie in x-, y- und z-Form kommen, können wir den Vektor messen und mit der Schwerkraft vergleichen, um zu bestimmen, wo (magnetischer) Norden in Bezug auf das Gerät ist.
  • Das Gyroskop misst die Rotation um jede Achse im Bogenmaß pro Sekunde.  Das kann auch zur Berechnung der relativen Geräteausrichtung verwendet werden.

Schlussfolgerung

Das schließt den ersten Teil unseres AR-Tutorials ab.  Augmented Reality ist ein spannendes Genre für Anwendungen auf der Android-Plattform.  Das Android SDK bietet alles, was zur Entwicklung von schlanken und interessanten AR-Apps erforderlich ist, aber nicht alle Geräte können die Hardwareanforderungen erfüllen, die diese Apps verlangen. Glücklicherweise ist die neueste Generation von Android-Geräten die bisher leistungsfähigste und viele der Android-Geräte sind perfekt in der Lage, erweiterte AR-Anwendungen auszuführen.

Im nächsten Teil dieser Tutorial-Serie werden wir fortfahren, Standortdaten zu sammeln und AR-Objekte an einem bestimmten Ort auf dem Bildschirm zu platzieren.  Das beinhaltet verschiedene mathematische Algorithmen, aber das Endergebnis wird ... Augmentation sein!

Advertisement
Advertisement
Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.