Android_Tutorial_Lektion08_fotolia_RA_Studio_46292813

Programmier Tutorial: Apps für Android entwickeln – Teil 8: Optional – App im Android Emulator ohne Intel HAXM ausführen

Hinweis: Diese Lektion ist optional und ausschließlich für Informationszwecke gedacht. Sie sollte übersprungen werden, falls Intel HAXM auf dem Entwicklungssystem genutzt werden kann. Falls Intel HAXM nicht verwendet werden kann, sollte die eigene Android App auf einem Tablet oder Smartphone erprobt werden.


Hinweis: Es ist absolut nicht empfehlenswert die eigene Android App ohne Hardware-Beschleunigung im Android Emulator zu erproben. Zum einen werden keine aktuellen System Images mehr von Google veröffentlicht und zum anderen läuft das AVD ohne Intel HAXM sehr instabil und extrem träge. Es ist dennoch interessant, etwas Erfahrung mit dieser Art der Android Emulation zu sammeln.

Wir werden in dieser Lektion ein ARM-basiertes Android Virtual Device (AVD) einrichten. Die Lektion soll zeigen, wie ein AVD ohne Hardware-Beschleunigung ausgeführt werden kann. Diese Art der Android Emulation besitzt aber einige große Nachteile gegenüber der Emulation mit Intel HAXM. Daher dient diese Lektion nur Informationszwecken.

Die Kursteilnehmer können die Arbeitsschritte dieser Lektion auf ihren Entwicklungssystemen ausführen und so Erfahrungen mit der nicht Hardware-beschleunigten Android Emulation sammeln. Es können aber beim Ausführen des ARM-basierten AVD schwer lösbare Probleme auftreten. Daher werden die beschriebenen Arbeitsschritte leider nicht bei allen Lesern durchführbar sein.

Sollte bei euch das ARM-basierten AVD absolut nicht im Android Emulator ausführbar sein, dann lest die Lektion bitte bis zum Ende und geht anschließend zur nächsten Lektion über. Da diese Lektion optional ist, kann sie problemlos übersprungen werden. In der nächsten Lektion zeigen wir, wie die im Kurs entwickelte Android App auf einem physikalischen Android Gerät, also einem Smartphone oder Tablet, installiert und getestet wird.

1. Was ist ein ARM-basiertes AVD?

Ein ARM-basiertes AVD wird benötigt, 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 VT, VT-x oder vmx verfügt.

Wenn Intel HAXM nicht auf dem Rechner verwendet werden kann, ist es nicht möglich x86-basierte AVDs im Android Emulator auszuführen. Stattdessen muss auf virtuelle Geräte auf Basis von ARM System Images, die nicht Hardware-beschleunigt (hardware accelerated) sind, zurückgegriffen werden.

Was ein Android Virtual Device (AVD) ist, haben wir bereits in der vorherigen Lektion kennengelernt. Auf einem AVD kann die eigene Android App zu Testzwecken installiert und ausgeführt werden. Das virtuelle Gerät selbst wird im Android Emulator ausgeführt, so dass eine Kapselung der folgenden Art besteht:

Android Emulator > Virtuelles Gerät > Android App

Welche Eigenschaften ein AVD besitzt, wird maßgeblich von dem verwendeten Hardware Profile und System Image bestimmt. Dabei ist das vom virtuellen Gerät verwendete System Image von zentraler 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 Image wird bestimmt, welche Android API Version von dem AVD nachgebildet werden soll (z.B. API Level 24 – Android 7.0 Nougat).

Das System Image legt außerdem fest, welche Binärschnittstelle (Application Binary Interface, ABI) verwendet werden soll. Ein ABI steht für eine bestimmte Kombination aus Prozessor (CPU) und Befehlssatz (Instruction Set). Auf diese Weise können verschiedene Android Geräte mit unterschiedlichen CPUs und Instruction Sets emuliert werden. Das ABI definiert, wie der Maschinencode einer Anwendung mit dem ausführenden System zur Laufzeit interagiert.

Für AVDs können System Images mit folgenden ABIs verwendet werden:

  • x86
  • x86_64
  • armeabi
  • armeabi_v7a
  • arm64_v8a
  • mips

Von einem ARM-basierten AVD spricht man, wenn für das virtuelle Gerät ein System Image verwendet wird, dessen ABI auf einer armeabi, armeabi_v7a oder arm64_v8a Befehlsarchitektur basiert. Hingegen spricht man von einem x86-basierten AVD, wenn das verwendete System Image auf einem x86 oder x86_64 ABI basiert.

Auf Entwicklungssystemen ohne Intel Virtualisierungstechnologien können nur AVDs ausgeführt werden, die ARM-basierte System Images verwenden. Warum dies so ist, klären wir im folgenden Abschnitt.

1.1 Wann muss ein ARM-basiertes AVD verwendet werden?

Wie bereits erwähnt, sind die Virtualisierungstechnologien von Intel für das Ausführen von AVDs im Android Emulator von entscheidender Bedeutung. Nur Entwicklungssysteme die über einen Intel Prozessor mit Virtualization Technology VT, VT-x oder vmx verfügen, können den Intel Hardware Accelerated Execution Manager (Intel HAXM) verwenden. Der Intel HAXM ist eine Hardware-unterstützte Virtuelle Umgebung, die die Android Emulation auf dem Entwicklungsrechner beschleunigt.

Verfügt das Entwicklungssystem über keinen Intel Prozessor mit Virtualization Technology, kann der Intel HAXM nicht verwendet werden. In einem solchen Fall ist es nicht möglich x86-basierte AVDs im Android Emulator auszuführen. Stattdessen muss für die Android Emulation auf ARM-basierte AVDs zurückgegriffen werden.

Daraus ergibt sich leider ein großer Nachteil. Es ist dann keine Hardware-Beschleunigung möglich. Da nur x86-basierte AVDs Hardware-beschleunigt werden können, ist die Android Emulation auf ARM-basierten AVDs deutlich langsamer. Auch reagieren ARM-basierte virtuelle Geräte träger auf Benutzereingaben.

Zwar eignen sich auch ARM-basierte AVDs für das Testen der eignen App im Android Emulator, sie sind aber aufgrund der sehr langsamen Ausführung nicht zu empfehlen. Leider sind sie auf Entwicklungssystemen ohne Intel Prozessor mit Virtualization Technology alternativlos. In solchen Fällen ist es aber besser, die Android App direkt auf einem physikalischen Android Gerät zu testen.

Als Nächstes werden wir ein ARM-basiertes virtuelles Gerät in Android Studio anlegen.

2. Einrichten eines ARM-basierten AVD

Wir werden nun ein ARM-basiertes AVD 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 Infobildschirm des Managers, wie in der vorherigen Lektion gezeigt. Da wir bereits ein AVD angelegt haben, wird uns aber der Your Virtual Devices-Dialog angezeigt, der alle vorhandenen AVDs übersichtlich auflistet:

your_virtual_devices_dialog

Der Your Virtual Devices Dialog des Android Device Managers

Wir haben an dieser Stelle die Möglichkeit des ARM-basiertes Android Virtual Device einzurichten. Mit einem Klick auf den Create Virtual Device… Button stoßen wir den Einrichtungsprozess an.

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

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.

Als Nächstes öffnet sich der Select a system image-Dialog, in dem wir ein System Image für das AVD auswählen müssen. Dies ist die entscheidende Stelle. Hier wird festgelegt, auf welcher Binärschnittstelle (x86 oder ARM) das virtuelle Gerät basiert.

Hinweis: Seit einiger Zeit werden keine aktuellen ARM-basierten System Images mehr von Google veröffentlicht. Daher müssen wir in dieser Lektion auf ein älteres System Image mit API Level 25 (Android Nougat) zurückgreifen.

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

  1. Dazu klicken wir zuerst auf den oberen Reiter Other Images über der Tabelle.
  2. Anschließend wählen wir das ARM-basierte System Image Nougat (API Level 25 und ABI armeabi-v7a) aus.
  3. Bevor das System Image genutzt werden kann, muss es heruntergeladen werden. Dies veranlassen wir mit einem Klick auf den Download Link hinter dem Release Name.
select_system_image_download

Herunterladen des ARM-basierten System Images für API Level 25

Mit einem Klick auf den Download Link veranlassen wir das Herunterladen des ARM-basierten System Image.

Es öffnet sich der License Agreement-Dialog, der uns über die Lizenzvereinbarungen des Android SDK Preview informiert:

arm_license_agreement

Die Lizenzvereinbarungen für die Installation des Google APIs ARM EABI v7a System Images

Wir lesen uns die Lizenzvereinbarungen des License Agreement-Dialogs in Ruhe durch und aktivieren den Accept Radio Button, falls wir mit den Vereinbarungen einverstanden sind. Danach bestätigen wir den Dialog mit einem Klick auf den Next Button.

Nun öffnet sich der Installing Requested Components-Dialog, durch den zuerst das gewählte System Image als Zip-Datei heruntergeladen und anschließend im Android SDK Verzeichnis installiert wird:

system_image_download_start

Das Installing Requested Components Fenster

system_image_download_end

Das ARM-basierte System Image wurde installiert

Das Herunterladen und anschließende Installieren des ausgewählten System Images dauert eine kleine Weile. Man kann den Fortschritt der Installation über das Installing Requested Components-Fenster verfolgen. Sobald das ARM-basierte System Image installiert worden ist, klicken wir auf den Finish Button.

Wir gelangen nun wieder zurück zu den Select a system image-Dialog:

select_system_image_arm

Das ARM-basierte System Image kann jetzt verwendet werden

Wenn wir jetzt auf den oberen Reiter Other Images über der Tabelle klicken, wird das umrahmte System Image ohne Download-Link angezeigt. Dies bedeutet, dass die Installation des ARM-basierten System Images erfolgreich war.

Wir wählen nun das eben heruntergeladene ARM-basierte System Image Nougat (API Level 25 und ABI armeabi-v7a) aus und klicken anschließend auf den Next Button.

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

device_name_arm_avd

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

Als AVD Name tragen wir Nexus 9 ARM ein. Die übrigen Einstellungen übernehmen wir unverändert. Anschließend klicken wir auf den Finish Button und lassen das ARM-basierte AVD erstellen.

Nun wird unser ARM-basiertes viertuelles Gerät vom AVD Manager erstellt. Dieser Vorgang kann einige Momente dauern. Anschließend gelangen wir wieder zurück zu dem Your Virtual Devices-Dialog, in dem jetzt das neu erstellte ARM-basierte AVD aufgeführt ist:

your_virtual_devices_dialog_arm

Im Your Virtual Devices Dialog ist jetzt das ARM-basierte AVD aufgelistet

Wir starten nun das ARM-basierte AVD durch Klicken auf das grüne Play-Symbol (Markierung A) rechts in der Actions-Spalte.

Das erstellte AVD wird nun im Emulator gestartet. Der Startvorgang dauert sehr, sehr lange, da die Android Emulation nicht Hardware-beschleunigt wird. Es ist also viel Geduld gefragt. Nach 30 Minuten sollte der Vorgang aber abgeschlossen sein. Die Startzeit ist von vielen Komponenten, besonders vom verfügbaren Arbeitsspeicher, 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 ARM-basierten AVDs:

arm_basiertes_avd

Das erstellte ARM-basierte virtuelle Gerät wurde im Android Emulator gestartet

Hinweis: Wenn eine Fehlermeldung mit dem Titel Process System isn’t responding im Emulator-Fenster angezeigt wird, muss die Option Close app ausgewählt werden.

In der oberen Abbildung ist das ARM-basierte Android Virtual Device nach dem ersten Start dargestellt. Wir haben jetzt ein ARM-basiertes Android Virtual Device eingerichtet und im Android Emulator ausgeführt. Der Intel HAXM wird dafür nicht benötigt, jedoch erfolgt die Android Emulation ohne Hardware-Beschleunigung auch deutlich langsamer.

3. Ausführen der App auf dem ARM-basierten AVD

Jetzt ist es an der Zeit unsere App auf dem ARM-basierten AVD auszuführen. Wichtig ist, dass der Android 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 ARM-basierte AVD als Deployment Target über die Drop-Down Box (Markierung A) ausgewählt wurde:

run_app_arm

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 ein Zwischenschritt, bei dem das Deployment Target explizit ausgewählt werden musste.

Es erscheint nun der Instant Run-Dialog, da auf dem virtuellen Android Gerät die Android 7.1.1 Version (Android API 25) ausgeführt wird und wir diese Android Platform nicht auf unserem Entwicklungsrechner installiert haben.

Wir benötigen die Instant Run-Funktion für das Testen unserer App auf dem virtuellen Android Gerät nicht und klicken daher auf den Proceed without Instant Run Button.

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

Hinweis: Auch dieser Vorgang nimmt sehr viel Zeit in Anspruch, da das Android Virtual Device nicht Hardware-beschleunigt ausgeführt wird. Es kann bis zu 30 Minuten dauern, bis die App auf das AVD übertragen und darauf gestartet worden ist.

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 ARM-basierten virtuellen Gerät aussieht, ist in der unteren Abbildung dargestellt:

zitate_app_arm_avd

Unsere App wird auf dem ARM-basierten virtuellen Gerät im Android Emulator ausgeführt

Da die App jetzt auf dem Android Virtual Device ohne Intel HAXM, also ohne Hardware-Beschleunigung, ausgeführt wird, reagiert sie nur sehr träge auf Benutzereingaben. Für die Bedienung der App wird also etwas Geduld benötigt. Mit Intel HAXM würde die Android Emulation bis zu 10 mal schneller erfolgen.

Da unsere Android App auf dem AVD installiert wurde, können wir sie auch selbst auf dem Emulator starten. Dazu einfach auf den Alle Apps-Button klicken und anschließend auf das Symbol unserer Android Anwendung.

Die App bleibt auf dem ARM-basierten 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.

zitate_app_installed

Unsere App ist jetzt auf dem ARM-basierten Android Virtual Device fest installiert

Mit einem Klick auf das Zitate-Symbol können wir unsere eigene App vom ARM-basierten AVD aus starten.

Zusammenfassung

In dieser optionalen Lektion haben wir erfahren, wie man ein Android Virtual Device auch ohne Intel HAXM im Android Emulator ausführen kann. Mit Hilfe eines ARM-basierten AVDs ist das Testen von Android Apps auch auf Entwicklungssystemen möglich, auf denen Intel HAXM nicht installiert werden kann. Dies ist aber nicht zu empfehlen und sollte nur in Ausnahmefällen angewandt werden.

Zu Beginn der Lektion haben wir geklärt, was ein ARM-basiertes AVD ist. Danach haben wir ein ARM-basiertes virtuelles Gerät in Android Studio eingerichtet und abschließend unsere App darauf im Android Emulator ausgeführt.

Da das virtuelle Gerät ohne Intel HAXM nicht Hardware-beschleunigt ausgeführt werden kann, reagieren die Apps im Emulator nur sehr träge auf Benutzereingaben. Auch das Starten des AVDs und das Installieren der eigenen App nimmt sehr viel Zeit in Anspruch. Es ist daher nicht empfehlenswert diese Art der Android Emulation für das Entwickeln der eigenen Android App zu verwenden.

In der nächsten Lektion werden wir unsere Android App auf einem physikalischen Android Gerät, also einem Smartphone oder Tablet, ausführen lassen. Dies ist eine hervorragende Alternative, falls Intel HAXM auf dem Entwicklungssystem nicht verfügbar sein sollte. Zudem ist das Ausführen der eignen App auf einem physikalischen Android Gerät sehr wichtig, denn nur die Installation der App auf ein angeschlossenes Android Gerät ermöglicht das Testen unter realen Bedingungen.

Weiterführende Literatur




Comments 14

  1. Wenn ich auf den Play Button drücke erscheint nur eine Meldung in der Leiste unten bei 4: Run, welche da lautet:

    Error running app:
    Default activity not found

    jetzt hab ich mich schon bis hier hin durchgeschlagen, aber dabei komme ich echt nicht weiter…

    1. Post
      Author

      Hallo Michael,

      beim Starten der App wird die Start-Activity (auch Launcher Activity genannt) nicht gefunden. Die Start-Activity wird in der AndroidManifest.xml Datei festgelegt. Vergleiche am besten noch einmal genau deinen Code der AndroidManifest.xml Datei mit dem im Tutorial angegebenen Quellcode.

      Viele Grüße, Chris

  2. Leider absolute mit Probleme mit dem Emulator. Lasse ihn zur Zeit mit einem Nexus5 Version 23 laufen. Warte das Resultat noch ab, aber von Anfang an Fehlermeldungen, auch beim Einrichten.
    Da es über einen AMD Rechner läuft konnte intelhaxm nicht installiert werden.
    Bei einrichten über „arm“ trudelte die Meldung ein: „Your CPU does not support required features (VT-x or SVM)“
    Consider using an x86 system image on a x86 host for better emulation perfomance.

    Fürchte also, dass es gar nicht funktionieren wird auf einem 64bit System.

    Welche Alternative könnte sich da anbieten, vor allem da immer auf fehlendes VT-x oder SVM hingewisen wird?

    1. Post
      Author

      Hallo Sondrine,

      wenn Du ein Android Gerät hast, kannst du die Android App darauf ausführen. Ein Emulator wird nur benötigt, wenn kein reales physisches Android Gerät vorhanden ist. Wie Du Deine App auf ein Android Gerät installierst, wird in Teil 3 des Android Tutorials beschrieben.

      Ich hoffe das hilft Dir weiter!

      Viele Grüße, Chris

  3. Hallo zusammen,
    diese Anleitung scheint mir genau das zu sein wonach ich gesucht habe. Sehr ausführlich – echt klasse gemacht, da kann man euch nur loben.
    Intel HAXM kann ich auf meinem Rechner nicht nutzen, also habe ich jetzt versucht,
    Allerdings sieht mein SDK Manager schon mal ganz anders aus, und dort kann ich auch kein Google APIs ARM EABI v7a System Image auswählen.
    Kann jemand weiterhelfen?

    Grüße
    Mathias

  4. Sehr gute Seite, die Ihr da erstellt habt. Sehr ausführlich und gut verständlich.

    Vielen Dank.

    Vielleicht wäre noch eine kleine Ergänzung um „mögliche Fehler“ sinnvoll. Ich ärgere mich seit längerem mit dem Problem „Cannot set up guest memory ‚android_arm‘: Invalid argument“ und finde keine Lösung im Internet. Alle beschriebenen Lösungen mit der Verringerung der RAM helfen bei mir nicht.

    Grüße

    1. Post
      Author

      Hallo Romuald,

      danke für das Lob!

      Eine Liste mit möglichen Fehlern und deren Lösung ist sehr hilfreich. Leser können gerne in den Kommentaren die bei ihnen aufgetretenen Fehler beschreiben. Vielleicht haben andere Leser bereits ähnliche Fehler gehabt und können dann eine mögliche Lösung vorschlagen.

      Viele Grüße, Chris

  5. Noch eine Frage:
    Bei mir wird bei Schritt 3.1 statt des grünen Start-Symbols nur ein Link angezeigt: „Repair Device“. Wenn ich darauf klicke, öffnet sich das Fenster zur Bearbeitung der Einstellungen für das AVD (Auswahl des system image).
    Da gibt es rechts diesen Hinweis: „Consider using a x86 system image for better emulation eerformance“.
    Ich nutze einen 32 Bit Intel i7er, dieser hat jedoch nicht alle erforderlichen Eigenschaften, um HAXM nutzen zu können.

  6. Hallo nochmal,
    Auch von mir ein ganz grosses Lob!
    Jetzt zu meiner Frage: Ich bin wie oben beschrieben vorgegangen und es ist folgendes Problem aufgetreten: Der Emulator erscheint beim Starten außerhalb des Screens und es gibt auch keinen Rahmen, an dem ich das Fenster verschieben könnte. Außerdem bekomme ich auf dem Screen des Emulators nur „Android“ gezeigt…
    Ist das normal? Kann man da Abhilfe schaffen?

    VG Moritz

    1. Post
      Author

      Hallo Moritz,

      ich hatte das Problem mit dem Fenster auch schon einmal. Ich habe dann folgende Anleitung genutzt und das Fenster mit den Pfeiltasten zurück auf den Bildschirm verschoben:

      http://www.tippscout.de/windows-tastatur-fenster-verschieben_tipp_2236.html

      Der Emulator ohne HAXM benötigt sehr viel Zeit, um sich zu starten. Gerade der erste Start kann schon mal 20 Minuten dauern. Wenn er fertig gestartet ist, dann sollte der Sperr-Bildschirm angezeigt werden, der sich mit Verschieben des Schlossen entsperren lässt.

      Das Wort „ANDROID“ wird während des Startvorgangs des Emulators angezeigt. Wenn der Emulator auch nach einer halben Stunde nicht mit dem Startprozess fertig ist, dann kann es sein, dass du das erstellte AVD konfigurieren musst. Es kann sein, dass der eingestellte Wert für den RAM unter Advanced Settings reduziert werden muss. Wenn das auch nicht hilft, kannst du versuchen verschiedene AVDs mit unterschiedlichen Device Definitions anzulegen und probieren, ob eine bestimmte davon bei dir läuft.

      Viele Grüße, Chris

  7. coole seite, kompliment, der aufbau in kombination mit den screenshots – sehr gut; ich habe früher skripte geschrieben und weiss, dass das schon viel arbeit ist – danke in jedem fall – wir arbeiten an unserer app, ufffff.

    1. Post
      Author
  8. Pingback: Android SQLite Tutorial - Teil 1: SQLite Projekt anlegen

  9. Pingback: Android Tutorial: Android Studio 1 installieren und einrichten

Schreibe einen Kommentar

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