Android_Tutorial_Lektion07_fotolia_RA_Studio_46292813

Programmier Tutorial: Apps für Android entwickeln – Teil 7: Ausführen der App auf einem AVD im Android Emulator

In dieser Lektion werden wir unsere Android App im Emulator ausführen lassen.

Die App kann dabei nicht direkt in dem Emulator laufen, sondern benötigt ein virtuelles Gerät auf dem sie ausgeführt wird. Das virtuelle Gerät wiederum wird im Android Emulator ausgeführt.


Es besteht also eine Kapselung der Art: Android Emulator > Virtuelles Gerät > Android App.

Virtuelle Geräte, auf denen Android Apps ausgeführt werden können, nennt man Android Virtual Devices oder kurz AVDs. Wir werden ein solches AVD in dieser Lektion einrichten und anschließend im Emulator ausführen. Bei der Einrichtung des AVDs werden wir den Android Virtual Device Manager von Android Studio nutzen.

Nachdem wir das AVD eingerichtet haben, werden wir es im Android Emulator starten und unsere eigene App darauf ausführen lassen. Dabei wird die App wie auf einem normalen Android Gerät, bspw. einem Smartphone, installiert und über den App Launcher gestartet.

Hinweis: Um das AVD im Emulator ausführen zu können, muss auf dem Entwicklungssystem der Intel® Hardware Accelerated Execution Manager (HAXM) installiert sein. Dies ist nur möglich, wenn der Entwicklungs-PC über einen Intel Prozessor mit Virtualization Technology VT, VT-x oder vmx verfügt. Falls kein solcher Prozessor verbaut ist, kann ein ARM-basiertes AVD verwendet werden. Jedoch ist dies aufgrund der sehr langsamen Ausführung nicht zu empfehlen. Wie das ARM-basierte virtuelle Gerät zu erstellen ist, erklären wir in der optionalen Lektion: Ausführen der App im Android Emulator ohne Intel HAXM. Sie dient aber ausschließlich Informationszwecken. Sollte Intel HAXM nicht auf dem Entwicklungssystem verfügbar sein, ist es besser die eigene App auf einem physikalischen Android Gerät, wie Tablet oder Smartphone, zu testen, anstelle eines ARM-basierten AVDs im Emulator zu verwenden.

1. Der Android Emulator

Mit Hilfe des Android Emulators können virtuelle Android Geräte auf dem Entwicklungs-PC ausgeführt werden. Dies ermöglicht die Nachbildung verschiedener Android Plattformen auf dem Computer. Auf diese Weise können Android Apps ausgiebig getestet werden, ohne dass dafür Hardware-Geräte benötigt werden.

Der Emulator kann Android Smartphones, Tablets, Wears- und TV-Geräte nachbilden. Wir werden den Emulator in diesem Kurs für das Nachbilden von Android Smartphones und Tablets verwenden, auf denen wir dann unsere App zum Testen ausführen werden. Die App wird dabei auf dem virtuellen Android Gerät installiert.

Die Installation kann auf zwei Wege erfolgen: über Android Studio oder indem eine APK-Datei in das Emulatorfenster gezogen wird. Nach dem Installieren verweilt die App auf dem virtuellen Gerät, bis sie wieder deinstalliert oder durch eine neuere Version ersetzt wird.

1.1 Funktionen des Android Emulators

Der Android Emulator ist ein sehr mächtiges Entwicklungswerkzeug und verfügt über eine Vielzahl an Funktionen. Bedient wird der Emulator wie ein normales Android Gerät. Jedoch nicht mittels Fingergesten, sondern über Maus- und Tastatureingaben.

Es ist möglich die Bildschirm-Orientierung zu rotieren, Screenshots zu schießen und die Fenstergröße dynamisch zu verändern. Auch in interessante Bildschirmbereiche kann hinein und wieder hinaus gezoomt werden.

Wird die eigene App auf dem Emulator ausgeführt, kann sie:

  • die Services der Android Plattform nutzen, um andere Apps aufzurufen
  • auf die Netzwerkverbindung zugreifen
  • Video und Audio Medien abspielen
  • Audio Input aufzeichnen
  • Daten empfangen und speichern
  • den Nutzer benachrichtigen
  • graphische Übergänge wiedergeben

Über diverse Steuerelemente des Emulators können eingehende Telefonanrufe und Textnachrichten an das virtuelle Gerät gesendet werden. Auch die GPS-Position des Geräts kann nach Belieben vorgegeben werden. Weiterhin können Fingerabdruck-Scans, sowie verschiedene Netzwerk- und Batteriezustände simuliert werden.

Als Speicher kann sowohl eine SD Karte als auch ein interner Speicher nachgebildet werden. Wird eine Datei per Drag & Drop in das Emulatorfenster gezogen, speichert der Emulator sie auf dem gerade ausgeführten virtuellen Gerät ab.

1.2 Die virtuellen Android Geräte – Android Virtual Devices (AVDs)

Wie bereits erwähnt, werden die Android Apps nicht direkt im Emulator ausgeführt, sondern auf einem virtuellen Gerät. Und zwar auf einem Android Virtual Device, kurz AVD. Ein AVD besteht aus einem Hardware Profile, System Image, Skin und Speicherbereich.

Hinweis: Das verwendete System Image ist von großer Bedeutung. Es enthält Code für den Android Linux Kernel, die nativen Bibliotheken, die Virtuelle Maschine und diverse Android Packages, wie das Android Framework und vorinstallierte Apps. Über das System Images wird festgelegt, welche Android API Version von dem AVD nachgebildet werden soll (z.B. API Level 29 – Android 10.0 Q).

Jedes AVD funktioniert wir ein eigenständiges Android Gerät. Mit seinem eigenen privatem Speicher für Benutzerdaten, installierte Apps und Einstellungen. Außerdem wird eine SD Karte emuliert. All diese Daten werden in dem AVD-Verzeichnis auf dem Entwicklungs-PC gespeichert.

Mit Hilfe von AVD Konfigurationen lassen sich die virtuellen Geräte anpassen. Sie definieren, was für ein Android Gerät im Emulator nachgebildet werden soll (Phone, Tablet, Wear oder TV) und über welche Funktionen es dabei verfügen wird. Auf diese Weise können sehr viele unterschiedliche virtuelle Geräte konfiguriert werden, die reale Android Geräte nachbilden. Die programmierte App kann dadurch auf den verschiedenen Android Plattformen und Hardware Varianten im Emulator getestet werden, ohne das dazu die entsprechenden realen Android Geräte benötigt werden.

Somit sind AVDs für die Entwicklung von Android Apps von enormer Bedeutung. Auch wir werden unsere eigene App zuerst auf einem virtuellen Gerät im Emulator testen. Da momentan noch keine AVD in Android Studio angelegt worden ist, werden wir dies im nächsten Abschnitt nachholen und unser erstes Android Virtual Device einrichten.

2. Ein Android Virtual Device einrichten

Wir werden nun ein Android Virtual Device einrichten und es anschließend im Android Emulator ausführen. Von Android Studio wird uns dafür der Android Virtual Device Manager, kurz AVD Manager, zur Verfügung gestellt. Über den AVD Manager können alle erstellten virtuellen Geräte komfortabel verwaltet werden.

Wir können den AVD Manager auf zwei Arten öffnen. Mit einem Klick auf das AVD Manager-Symbol in der Toolbar-Leiste oder direkt über die obere Menüleiste, indem wir auf Tools > AVD Manager klicken.

Wir starten ihn über den zweiten Weg, siehe folgende Abbildung:

avd_starten

Den Android Virtual Device Manager über die obere Menüleiste starten

Wird der AVD Manager zum ersten Mal gestartet und ist noch kein AVD angelegt worden, öffnet sich der Your Virtual Devices-Dialog des Managers. Wir haben an dieser Stelle die Möglichkeit unser erstes Android Virtual Device einzurichten.

In der unteren Abbildung ist der Your Virtual Devices-Dialog des AVD Managers dargestellt:

avd_manager_startbildschirm

Der Infobildschirm des AVD Managers wenn noch keine virtuellen Geräte vorhanden sind

Wir stoßen wir den Einrichtungsprozess unseres virtuellen Android Geräts an, indem wir in dem Your Virtual Devices-Dialog auf den Create Virtual Device… Button klicken.

Es öffnet sich nun der Choose a device definition-Dialog, der uns bei der Auswahl des Hardware-Profils des AVD unterstützt. In diesem Dialog kann man aus einer Vielzahl an vorkonfigurierten Profilen auswählen. Es ist sogar möglich eigene Hardware-Profile zu erstellen und somit ganz spezielle Android Geräte nachbilden.

Wir wählen als Device Definition des AVDs, die eines Nexus 9 Tablets aus:

  1. Dazu wählen wir in der Category-Spalte den Eintrag Tablet aus.
  2. Anschließend wählen wir in der Tabelle direkt daneben den Eintag Nexus 9 aus.
avd_choose_device_definition

Eine Hardware-Definition für das AVD auswählen

Nachdem wir die oben aufgeführten Einstellungen vorgenommen habe, bestätigen wir den Choose a device definition-Dialog mit einem Klick auf den Next Button.

Jetzt öffnet sich der Select a system image-Dialog, in dem wir ein System Image für das AVD auswählen müssen. Zu jeder Android API Version existiert mindestens ein System Image. Viele davon sind mittlerweile veraltet, da man sie zum Testen der eigenen App nicht mehr benötigt.

Bei der Entwicklung einer App wird empfohlen sie auf allen API-Versionen zu testen, auf denen sie lauffähig ist. Das bedeutet, begonnen mit der API-Version der minSdkVersion bis hin zu der aktuellsten API-Version. Für jede API-Version muss dafür ein eigenes AVD erstellt werden. Möchte man bspw. die API-Versionen 17 bis 28 unterstützen, müssen dafür 12 AVDs eingerichtet werden.

In diesem Kurs werden wir mit nur einem AVD arbeiten. Da es sich um eine Beispiel-App handelt, ist dieses Vorgehen zu vertreten. Bei einer kommerziellen App sollte deutlich mehr Testaufwand betrieben werden.

Wir wählen nun für unser AVD als System Image Q (API Level 29) aus:

  1. Dazu klicken wir zuerst auf den oberen Reiter Recommended über der Tabelle.
  2. Anschließend wählen wir das System Image Q (API Level 29 und ABI x86) aus.
  3. Mit einem Klick auf den Next Button wechseln wir zum nächsten Dialog.
avd_select_system_image

Ein System Image für das AVD auswählen

Das ausgewählte System Image sorgt dafür, dass unser AVD im Android Emulator ein Android 10.0 Gerät nachbilden wird. Dieses System Image verfügt zudem über die Google APIs, wie die Android Google Maps API, wodurch viele Google Dienste bereits auf dem virtuellen Gerät vorinstalliert sind und von unserer App genutzt werden können. Die anderen System Images aus der Liste können heruntergeladen werden, so dass je nach Bedarf ein weiteres AVD mit einer anderen API-Version eingerichtet werden kann. Wir begnügen uns aber an dieser Stelle mit einem AVD.

Hinweis: Das von uns ausgewählte System Image Android Q (API Level 29 und ABI x86) muss nicht heruntergeladen werden, da wir es in dieser vorherigen Lektion bereits mit Hilfe des SDK Managers auf unserem Entwicklungssystem installiert hatten.

Nach dem Select a system image-Dialog öffnet sich der Verify Configuration-Dialog. In ihm nehmen wir nur eine einzige Änderungen vor:

avd_device_name

Vorgeben des Gerätenamens und Abschließen der AVD Konfiguration

Als AVD Name tragen wir Nexus 9 ein. Die übrigen Einstellungen übernehmen wir unverändert. Anschließend klicken wir auf den Finish Button und lassen unser AVD mit dem Namen Nexus 9 erstellen.

Nun wird unser Android Virtual Device von dem AVD Manager erstellt. Dieser Vorgang kann einige Momente dauern.

3. Das Android Virtual Device im Emulator starten

Nachdem das AVD nach unseren Vorstellungen erstellt wurde, möchten wir es nun in dem Android Emulator ausführen. Dazu öffnen wir den AVD Manager über die Menüleiste mit Tools > AVD Manager. Der AVD Manager sollte jetzt auch das eben eingerichtete Android Virtual Device als Eintrag in der Your Virtual Devices-Liste anzeigen.

Zum Starten des eingerichteten AVDs müssen wir nur noch auf das Play-Symbol (Markierung A) in der Actions-Spalte klicken:

avd_im_avd_manager_starten

Mit Hilfe des AVD Managers das eben erstellte AVD starten

Das erstellte AVD wird nun im Emulator gestartet. Der Startvorgang kann manchmal sehr lange dauern. Es ist also etwas Geduld gefragt. Nach 10 Minuten sollte der Vorgang aber abgeschlossen sein. Die Startzeit ist von vielen Faktoren abhängig, daher ist eine genaue Zeitangabe nicht möglich. Außerdem nimmt das erste Starten zusätzliche Zeit in Anspruch. Dies alles solltet ihr berücksichtigen, um nicht vorzeitig den Startprozess abzubrechen.

Hinweis: Manchmal kommt es zu einem Absturz des Android Emulators, bevor das AVD komplett eingerichtet wurde. In einem solchen Fall ist es hilfreich das erstellte AVD noch einmal manuell „kalt“ zu starten (cold boot). Dazu muss im Your Virtual Devices-Dialog des AVD Managers in der hinteren Actions-Spalte auf das Dreieck nach unten geklickt und anschließend die Aktion Cold Boot Now ausgeführt werden. Danach wird das Android Virtual Device komplett neu gestartet und erneut eingerichtet. Auch die Aktion Wipe Data kann zu einer Lösung des Problems führen.

Nachdem das AVD im Emulator gestartet wurde, sehen wir in dem neu erschienenen Emulator-Fenster den Startbildschirm unseres AVDs. Da das virtuelle Gerät zum ersten Mal gestartet wurde, muss noch eine Infomeldungen bestätigt werden. Danach kann das AVD im Emulator ausgiebig erprobt werden.

avd_im_emulator_gestartet

Das erstellte Android Virtual Device wurde im Emulator gestartet

In der oberen Abbildung ist das Android Virtual Device nach dem ersten Start dargestellt. Wie zu erkennen ist, wird die grafische Benutzeroberfläche noch im Portrait Modus angezeigt.

Diese Fehldarstellung tritt auf, weil das virtuelle Android Gerät nicht in den Landscape Modus wechselt. Dieses Verhalten wurde mit Android 9.0 (Pie) eingeführt und ist der neuen Funktion Rotation Lock geschuldet. Wie der Name schon verrät, handelt es sich bei diesem neuen Feature um eine Sperrfunktion, die gegen ungewollte Bildschirmrotationen schützen soll.

In unserem Fall ist diese Funkion aber unvorteilhaft, denn die Bildschirminhalte des eingerichteten Android Virtual Devices sollen in den Landscape Modus dargestellte werden. Daher müssen wir die neue Funktion deaktivieren, um so eine Neuausrichtung der grafischen Benutzeroberfläche entsprechend der Bildschirmausrichtung zu erzwingen.

Hinweis: Nach dem ersten Starten des Virtuellen Android Geräts im Emulator sollte dieses für 5 Minuten ohne Benutzereingaben laufen gelassen werden. Dadurch können wichtige Hintergrundprozesse, die beim ersten Start auftreten, abgearbeitet werden. Danach reagiert das AVD auch deutlich direkter auf Eingabe.

In dem unteren Video ist zu sehen, wie die Funktion Rotation Lock deaktiviert wird:

Zuerst muss der Notification Tray mit einer Swipe-Down Geste eingeblendet werden. Dazu klicken wir auf die Status Bar am oberen Bildschirmrand und halten die Maustaste gedrückt. Anschließend ziehen wir mit gehaltener Maustaste den Mauszeiger nach unten bis ungefähr zur Bildschirmmitte.

Nun erscheint das Quick Settings Panel mit dessen Hilfe wir die automatische Bildschirmrotation aktivieren können. Um dies zu tun, klicken wir auf das ausgegraute Auto Rotation-Symbol (zwei gebogene Pfeile, die zusammen ein Rechteck formen und sich dazu an ihren Enden berühren). Nach einem kurzen Moment richtet das Android System die Bildschirminhalte im Landscape Modus neu aus.

Hinweis: Bei dem System Image Android Q (API Level 29) liegt in manchen Fällen ein Problem zwischen dem verwendeten Skin und der Auto Rotation Funktion vor. Aufgrund von diesem Bug richtet das Android System die Bildschirminhalte nicht neu aus. Das Problem kann manchmal behoben werden, wenn bei der Einrichtung des AVDs im Verify Configuration-Dialog die Option Enable Device Frame deaktiviert wird.

Hinweis: Führt auch dies nicht zum Erfolg, muss das AVD im Portrait-Modus betrieben werden. Dazu ist eine Rotation des virtuellen Geräts durchzuführen. Die Rotation wird mit Hilfe der Rotation Buttons ausgeführt. Diese befinden sich an vierter und fünfter Position in der schmalen Bedienleiste neben dem Emulator-Fenster. Durch Klick auf den Rotate Right Button wird das virtuelle Gerät um 90° nach rechts gedreht und somit im Portrait-Modus betrieben.

4. Ausführen der App auf dem AVD im Emulator

Jetzt ist es an der Zeit unsere App im Android Emulator auszuführen. Wichtig ist, dass der Emulator bereits gestartet ist und in einem eigenen Fenster ausgeführt wird (siehe vorheriger Abschnitt).

Die eigene App kann auf zwei Arten gestartet werden. Mit einem Klick auf das Run 'app' Symbol in der oberen Toolbar oder über die Menüleiste, indem wir auf Run > Run 'app' klicken.

Wir starten unsere App über den zweiten Weg, siehe folgende Abbildung. Dabei ist darauf zu achten, dass das eben erstellte AVD als Deployment Target über die Drop-Down Box (Markierung A) ausgewählt wurde:

run_app

Die Android App über die obere Menüleiste mit Run > Run ‚app‘ starten

Ab Android Studio 3.5 wird nun unsere App direkt gestartet. Bei älteren Android Studio Versionen erfolgte noch folgender Zwischenschritt, der in der unteren Akkordion-Box beschrieben wird.

Nun wird unser Android Projekt im Hintergrund neu erstellt und anschließend die Android App auf unserem erstellten AVD installiert. Diesen Vorgang können wir im Run Tool Window von Android Studio überwachen.

Nachdem die App auf unserem AVD installiert worden ist, wird sie mittels Konsolenbefehl automatisch von Android Studio gestartet. Wenn alles funktioniert hat, ist unsere App jetzt im Emulator-Fenster gestartet worden und wir erhalten als Text folgenden String angezeigt: Hello CodeYourApp World!

Wie unsere App auf dem virtuellen Gerät im Emulator aussieht, ist in der unteren Abbildung dargestellt:

app_auf_avd_im_emulator_gestartet

Unsere App wird auf dem erstellten Android Virtual Device im Emulator ausgeführt

Da unsere Android App auf dem AVD installiert wurde, können wir sie auch selbst auf dem Emulator starten. Dazu einfach das Alle Apps-Menü auf dem virtuellen Android Gerät öffnen und anschließend auf das Symbol unserer Android Anwendung.

Die App bleibt auf dem AVD installiert. Wir können also, wenn wir beim nächsten Mal das virtuelle Gerät auf dem Emulator ausführen, unsere Anwendung wie eine normal installierte Android App starten. Das Starten erfolgt intuitiv über das Alle Apps-Menü unseres Android Virtual Devices.

unsere_app_auf_avd_installiert

Unsere App ist jetzt auf dem Android Virtual Device installiert

Zusammenfassung

In dieser Lektion konnten wir unsere App zum erste Mal testen. Dazu haben wir die App im Android Emulator ausführen lassen. Und zwar auf einem virtuellen Gerät, einem sog. Android Virtual Device, welches wir vorher noch einrichten mussten.

Zu Beginn dieser Lektion haben wir auch die Beziehung zwischen einem AVD und dem Android Emulator näher kennengelernt. Der Emulator bildet mit Hilfe eines AVDs ein ganz bestimmtes, exakt definiertes Hardware-Gerät nach. Das AVD gibt dabei die Eigenschaften des Android Geräts genau vor. Die eigene App wird dann auf dem exakt definieren virtuellen Gerät im Emulator ausgeführt.

Diese Kapselung ist für den Entwicklungsprozess sehr vorteilhaft. Und zwar können dadurch beliebig viele verschiedene AVDs, die alle ganz bestimmte physikalische Android Geräte nachbilden, zum Testen eingesetzt werden. Die realen Hardware-Geräte werden dafür nicht benötigt, wodurch sich die Testkosten enorm reduzieren lassen.

Das erstellte AVD werden wir in den zukünftigen Lektionen als unser virtuelles Testgerät einsetzen. So können wir unseren Quellcode bereits zu einem sehr frühen Zeitpunkt in diesem Android Kurs gründlich testen. Dadurch lassen sich Programmierfehler schneller finden und beheben.

Die nächste Lektion ist optional und dient ausschließlich Informationszwecken. Wir werden in ihr ein ARM-basiertes Android Virtual Device einrichten. Dies ermöglicht die Android Emulation, wenn auf dem Entwicklungssystem der Intel® Hardware Accelerated Execution Manager (HAXM) nicht ausgeführt werden kann. Dies ist der Fall, wenn der Entwicklungs-PC über keinen Intel Prozessor mit Virtualization Technology verfügt.

Weiterführende Literatur




Comments 2

  1. Hallo,

    vielen Dank für das hilfreiche Tutorial. Bin als Anfänger auch gut mitgekommen. Leider läuft die erste App „Hello World“ nicht. Bin auch noch nicht dahinter gestiegen warum nicht. Nach dem Run-Befehl erscheint der folgdende Fehler:

    Default Activity not found.

    Was habe ich falsch gemacht? Was kann ich tun, damit ich die App zum laufen bekomme.

    Vielen Dank für deine/eure Mühe.

    Viele Grüße Paul

    1. Post
      Author

      Hallo Paul,

      es scheint die Default Activity, als die Start Activity, nicht gefunden zu werden.

      Welche Activity zum Starten der App verwendet werden soll, wird in der AndroidManifest.xml Datei vorgegeben. Wir haben dies in der 6ten Lektion in Abschnitt 2: Bekanntgabe der erstellten Activity im App Manifest mit folgendem Quellcode vorgegeben.

      AndroidManifest.xml

      <manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="de.codeyourapp.zitate">
       
          <application
              android:allowBackup="true"
              android:icon="@mipmap/ic_launcher"
              android:label="@string/app_name"
              android:roundIcon="@mipmap/ic_launcher_round"
              android:supportsRtl="true"
              android:theme="@style/AppTheme">
       
              <activity
                  android:name=".MainActivity"
                  android:launchMode="singleTop">
                  <intent-filter>
                      <action android:name="android.intent.action.MAIN" />
                      <category android:name="android.intent.category.LAUNCHER" />
                  </intent-filter>
              </activity>
       
          </application>
       
      </manifest>
      

      Prüfe bitte genau, ob auch bei dir exakt der gleiche Code in der Manifest-Datei angegeben ist.

      Viele Grüße, Chris

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.