1.1.1  Voraussetzungen

Die wichtigste Voraussetzung für die Lektüre sind grundlegende Kenntnisse in einer objektorientierten Programmiersprache, im Idealfall in ‌Java. Aber auch ohne Java-Kenntnisse (zum Beispiel als C#-Entwickler) finden Sie sich sehr schnell zurecht, wenn objektorientierte Programmierung für Sie kein Fremdwort ist.

Weiterhin ist ein gutes Verständnis des Dateiformats »XML« notwendig, da Android die Layouts und einige andere Ressourcen in ‌XML beschreibt.

Die letzte Voraussetzung ist ein grundlegendes Verständnis von relationalen Datenbanken. Keine Angst, Sie müssen in diesem Buch keine »CREATE«-Anweisung aus dem Kopf schreiben.

1.5.1  XML-Dateien

• Dateiname: Kleinschreibung mit Worttrennung durch »_«.

  Beispiel: activity_main.xml

• Ressource-Namen (für IDs, Strings, Abstände usw.): »CamelCase«-Schreibweise.

  Beispiel: <string name="LabelName">Name:</string> oder <TextView android:id="@+id/FirstLabel" />

1.5.2  Java-Dateien

• Dateiname/Klassenname: »CamelCase«-Schreibweise.

  Beispiel: DbHepler

• Nicht private Konstanten: »UPPER Case«-Schreibweise Worttrennung durch »_«.

  Beispiel: public final static String ID_KEY = "TimeDataIdKey";

• Private Konstanten: »UPPER Case«-Schreibweise mit »_«-Zeichen als Präfix und Worttrennung durch »_«.

  Beispiel: private final static int _LOADER_ID = 150;

• Private Klassenvariablen: »pascalCase«-Schreibweise mit »_«-Zeichen als Präfix.

  Beispiel: private DateFormat _dateTimeFormatter = null;

• Methodennamen: »pascalCase«-Schreibweise.

  Beispiel: private void saveEndDateTime() { ... }

• Parameternamen und lokale Variablen: »pascalCase«-Schreibweise.

  Beispiel:

  private void setStartDate(Calendar startDate) {
    ...
    String startDateString = _dateTimeFormatter.format(startDate.getTime());
    ...
  }

2.1.1  Historie

Die Android Entwicklung begann mit der Entwicklungsumgebung Eclipse und dem Plugin »Android Developer Tools«.

‌‌Android Studio wurde auf der Google I/O 2013 zum ersten Mal präsentiert und als Alpha-Version veröffentlicht. Ein Jahr später, auf der Google I/O 2014, wurde es zum Beta-Status erhoben. Bereits im Dezember 2014 erschien dann die erste finale Version 1.0.

Seit Dezember 2014 ist Android Studio die offizielle Entwicklungsumgebung für die Android-Entwicklung. Es hat ‌‌Eclipse mit den ‌‌Android Developer Tools abgelöst. Neuere Funktionen erscheinen seitdem nur noch für Android Studio. Android Developer Tools werden zwar durch die Eclipse Foundation weiterentwickelt, aber nicht mehr von Google selbst.

Zusätzlich zu der Umstellung der Entwicklungsumgebung von Eclipse auf Android Studio wurde auch das Build-System von Ant bei Eclipse auf ‌‌Gradle unter Android Studio geändert.

Eine kurze Einführung in das Gradle-Build-System finden Sie weiter unten im Abschnitt 2.1.5.

2.1.2  Installation

‌Nun geht es ans Werk. Die aktuelle Version von Android Studio erhalten Sie von der offiziellen Android-Entwicklerseite (developer.android.com/studio/).

Im Normalfall erkennt der Browser das aktuelle Betriebssystem und schlägt die passende Datei für den Download vor. Wenn dies nicht der Fall ist oder Sie die Installationsdatei für einen anderen Rechner benötigen, finden Sie diese auf der oben genannten Seite unter »Download Options«.

Android Studio wird für die gängigen Betriebssysteme Windows, macOS und Linux angeboten.

Für Windows stehen mehrere Versionen für den Download zur Verfügung:

• Android Studio mit Installer (Standard 64 Bit)

• Android Studio ohne Installer als Zip-Archiv (64 Bit)

• Android Studio ohne Installer als Zip-Archiv (32 Bit)

Nutzen Sie den Installer. Andere Installationsmethoden sind nur in Spezialfällen erforderlich.

Das SDK (Software Development Kit) wird erst beim ersten Start von Android Studio nachgeladen.

Als ‌‌Hardware-Voraussetzungen sind ein moderner Rechner mit mindestens 4 GB RAM, 2 GB freiem Speicherplatz und 1280 x 800-Auflösung notwendig. Mit dieser Minimalanforderung wird die App-Entwicklung aber nicht wirklich Spaß machen. Für flüssige Android-Entwicklung empfehle ich einen modernen Rechner mit mindestens folgender Ausstattung:

• Core i5/i7 (ab 6. Generation) mit aktivierter Virtualisierungstechnik VT-x, EM64T und XD oder vergleichbarem AMD Prozessor

• 8 GB RAM (für Android Virtual Devices-AVDs)

• SSD statt Festplatte (rotierende Scheiben/HDD)

• 24“-Bildschirm mit Full-HD-Auflösung (1920 x 1080)

Die Virtualisierungstechnik ist notwendig, um schnellere Emulatoren installieren zu können (Intel ‌‌HAXM, Hyper-V, Genymotion und weitere). Die Standard-Emulatoren (ohne Virtualisierungstechnik) sind leider sehr langsam und machen bei der Entwicklung keinen Spaß. Genaueres können Sie in Anhang A.2 »Installation von HAXM« nachlesen.

2.1.3  Erster Start von Android Studio

‌Beim ersten Start erscheint die Meldung zur Übernahme der Einstellungen einer vorherigen Installation (falls vorhanden).

Nach dem Dialog zur Übernahme der Einstellungen erscheint der Assistent für die Ersteinrichtung (Abbildung 2.13). Dieser installiert das Android Software Development Kit (kurz Android SDK) und, falls ausgewählt, auch das erste Android Virtual Device (kurz AVD).

Wenn Sie im nächsten Schritt die Installationsmethode »Custom« auswählen (Abbildung 2.14), können Sie die Installation an einigen Stellen anpassen (unter anderem die RAM-Größe für HAXM, wohin SDK installiert wird usw.).

Im nächsten Schritt können Sie das Aussehen der Entwicklungsumgebung anpassen. Unter Windows und macOS stehen zwei Möglichkeiten zur Verfügung, »Default« und »Dracula« (Abbildung 2.15), unter Linux sind es drei, »IntelliJ«, »Dracula« und »GTK+« (Abbildung 2.16).

Der Assistent endet mit einer Seite als Zusammenfassung, die neben der Auflistung der Komponenten, die installiert werden, auch die Downloadgröße enthält. Diese liegt bei einem neuen System bei circa 1 bis 2 GB.

Nach dem Bestätigen mit Finish werden die notwendigen Komponenten heruntergeladen und installiert.

Wählen Sie die Installationsmethode »Custom«, können Sie die zu installierenden Komponenten auswählen (zum Beispiel gleich ein AVD mitinstallieren) (Abbildung 2.18). Wir werden später ein AVD komplett selbst einrichten. Aus diesem Grund ist die Installation an dieser Stelle nicht notwendig.

Falls Sie bei den Komponenten die Installation von HAXM ausgewählt haben (nur unter Windows und macOS), können Sie im nächsten Schritt den maximalen Arbeitsspeicher festlegen (Abbildung 2.19), der von HAXM benutzt werden darf. Belassen Sie es bei der Empfehlung (auf den meisten Systemen 2 GB).

Unter Linux muss zur Beschleunigung der AVDs KVM (Kernelbasierte Virtuelle Maschine) installiert sein. Dazu erscheint beim ersten Start unter Linux ein Hinweisdialog mit dem Link, wie es richtig eingerichtet wird (Abbildung 2.20).

Genauer beschreibe ich die Beschleuniger von AVDs im Anhang A.2 inkl. der Startzeiten der jeweiligen AVD-Typen.

Nach Abschluss der Installation erscheint der Startbildschirm von Android Studio und Sie können mit der Programmierung anfangen.

Falls es Aktualisierungen für Android Studio, SDK oder Android Studio Plugins gibt, werden diese auf dem Startbildschirm signalisiert und können von hier auch direkt installiert werden.

2.1.4  Struktur der Entwicklungsumgebung

Android Studio sieht wie die meisten modernen Entwicklungsumgebungen aus. Abhängig vom Betriebssystem befindet sich ganz oben die Menüleiste für den Zugriff auf die Funktionen der Entwicklungsumgebung (unter macOS ist die Menüleiste, wie üblich, nicht direkt im aktiven Fenster).

Gleich unterhalb des Menüs (auf der rechten Seite) finden Sie die Pfadnavigation zu dem aktuell aktiven Dokument. Dort sehen Sie sehr schnell, wo das Dokument physisch auf der Festplatte liegt. Weiterhin können Sie mit dieser Pfadnavigation auch schnell auf die Dateien/Ordner in derselben Ebene zugreifen, ohne die Projektansicht dazu bemühen zu müssen.

Links von der Pfadnavigation sehen Sie die Toolbar mit den sehr oft genutzten Funktionen, die jederzeit angepasst werden kann. Diese beinhaltet neben den üblichen Buttons zum Speichern, Ausführen und Debuggen der App auch spezielle, die nur die Android-Entwicklung betreffen.

Diese Toolbar erleichtert den Zugriff auf den Android SDK Manager und Android Virtual Device Manager.

Ganz unten befindet sich die Statusleiste mit den Informationen zum aktuellen Zustand des Projekts und der geöffneten Datei. Während des Build-Vorgangs wird hier auch der Fortschritt angezeigt.

Der größte Bereich wird vom Bearbeitungsfenster belegt. Links, rechts und unten finden Sie die Tool-Fenster, die spezielle Aufgaben/Darstellungen übernehmen. Durch einen Klick auf die Überschrift des Fensters wird dieses geöffnet und bleibt offen, bis Sie ein anderes Tool-Fenster auf derselben Seite anklicken oder noch einmal auf dieselbe Tool-Fenster-Überschrift klicken. In Abbildung 2.24 ist das Projekt-Tool-Fenster offen.

Die wichtigsten ‌Tool-Fenster für die Android-Entwicklung sind:

• Project

  Das Project-Tool-Fenster stellt die Dateien und Ordner des Projekts in einer Baumansicht dar. Dabei gibt es mehrere Ansichten für die Projektstruktur.

  Abb. 2.24: Project-Tool-Fenster

• Structure

  Das Structure-Tool-Fenster zeigt den Aufbau des aktuell aktiven Dokuments. Bei Java-Dateien haben Sie so sehr schnellen Zugriff auf die Methoden und Klassenvariablen. Bei XML-Dateien sehen Sie hier die Hierarchie der Elemente.

  Abb. 2.25: Structure-Tool-Fenster

• Gradle

  Das Gradle-Tool-Fenster zeigt die definierten Schritte für den Build der App. Die Erstellung der App erfordert sehr viele Schritte, diese können hier einzeln angesehen und ausgeführt (oder auch wiederholt) werden.

• Build

  Das Build-Tool-Fenster zeigt den letzten Stand und Fortschritt bei der Kompilierung. Hier können Sie auch die Fehler ansehen, falls die Kompilierung der App scheitert. Meistens sind die Fehlermeldungen aussagekräftig genug, um die Ursache auch direkt zu beseitigen.

  Abb. 2.26: Build-Tool-Fenster

• Profiler

  Das Profiler-Tool-Fenster zeigt die aktuelle Auslastung der laufenden App (CPU, Speicher, Netzwerk usw.). Das ist die erste Anlaufstelle, wenn Sie die Flaschenhälse der App untersuchen möchten.

  Abb. 2.27: Profiler-Tool-Fenster

• Logcat

  Das Logcat-Tool-Fenster zeigt die Log-Ausgaben des Betriebssystems und der App an. Wenn Sie in der App Log-Ausgaben integrieren, können Sie diese hier ablesen (und auch filtern).

  Abb. 2.28: Logcat-Tool-Fenster

• Terminal

  Das Terminal-Tool-Fenster erlaubt den Zugriff auf die Kommandozeile, ohne die Entwicklungsumgebung verlassen zu müssen. Es wird zum Beispiel gerne verwendet, um die git-Versionsverwaltung zu nutzen, Android Debug Bridge zu steuern oder einfach ein bestimmtes Skript auszuführen.

  Abb. 2.29: Terminal-Tool-Fenster

• Debug

  Das Debug-Tool-Fenster zeigt die Informationen während einer Debug-Ausführung der App. Hier werden auch die Daten der Variablen angezeigt, die bei einem aktiven »Breakpoint« gültig sind. Es leistet sehr gute Dienste bei der Fehleranalyse.

  Abb. 2.30: Debug-Tool-Fenster in Aktion

2.1.5  Build-System‌ Gradle

Die Erstellung von Android-Apps ist sehr kompliziert. Es sind viele Tools beteiligt, um aus allen App-Bestandteilen (Java-Klasse, XML-Dateien, Bilder usw.) eine fertige App zu erstellen. Hier ist ein sehr verkürzter Ablauf:

1. Herunterladen der externen Abhängigkeiten

2. Kompilieren der Java-Dateien in DEX

3. Kompilieren der Ressourcen

4. Optional: Obfuscation mit ProGuard

5. Verpacken als APK-Datei (DEX + Ressourcen)

6. Signieren der APK-Datei

7. Optimierung der fertigen Datei auf Speicherverbrauch

Damit Sie all diese Schritte nicht manuell durchführen müssen, verwendet Android Studio »Gradle« als Build-System.

‌Gradle ist ein Build-Management-System für Java. Es nutzt eine auf Groovy aufbauende »‌‌Domain Specific Language« (kurz ‌DSL‌), mit der die einzelnen Build-Schritte beschrieben werden.

Android liefert mit dem Android-Plugin für Gradle bereits alle Schritte, die für die normale Erstellung notwendig sind, mit. Sie können aber sehr einfach mit eigenen Schritten in den Build-Prozess eingreifen und ihn personalisieren. Das könnte zum Beispiel ein Import der Übersetzungen aus einem anderen Programm sein, der vor dem eigentlichen Build abläuft. Oder das Kopieren der fertigen App-Datei in einen vordefinierten Ordner am Ende.

Gradle übernimmt neben dem ‌‌Build selbst auch die Verwaltung der Abhängigkeiten zu externen Bibliotheken. Dazu wird das von der Java-Entwicklung bekannte ‌‌Maven-Repository eingebunden. Auch Android-Bibliotheken werden als Maven-Artifacts abgebildet.

Sie werden im Laufe des Buchs an einigen Stellen in das Build-Script unserer App eingreifen und dieses anpassen (neue Abhängigkeiten hinzufügen, Version anpassen usw.).

»Start a new Android Studio project«

Hierbei wird ein neues Projekt mithilfe eines Assistenten angelegt.

»Open an existing Android Studio project«

Ein bereits vorhandenes Projekt wird von der Festplatte geöffnet. Mit diesem Punkt können Sie den mitgelieferten ‌‌Quellcode laden (siehe dazu Anhang A.4 »Vorhandenen Quellcode in Android Studio öffnen« am Ende dieses Buches).

»Check out project from Version Control«

Öffnen eines Projekts aus einer Versionsverwaltung, wie Git, Mercurial oder Subversion. Dabei wird der Source-Code aus der Versionsverwaltung ausgelesen und wenn möglich auch gleich geöffnet.

»Import project (Gradle, Eclipse ADT, etc.)«

Import eines Nicht-Android-Studio-Projekts. Oft wird dieser Punkt für den Import der alten Android-Projekte verwendet, die noch mit Eclipse entwickelt wurden.

»Import an Android code sample«

Es wird ein Beispielprojekt aus dem Android SDK importiert. Sie finden hier einen sehr schönen Fundus an Beispielanwendungen zu den unterschiedlichsten Themen, mit denen man viel lernen kann.

3.1.1  Ein neues Projekt starten‌

Sie beginnen mit der Option Start a new Android Studio project. Daraufhin öffnet sich ein ‌‌Assistent für die Anlage neuer Android-Projekte. Auf dem ersten Bildschirm wird die App-Vorlage ausgewählt.

Die ‌Vorlagen erzeugen für oft gebrauchte Fälle ein Grundgerüst im Projekt. Viele der Vorlagen erfordern ein bestimmtes Vorwissen, um mit diesem Grundgerüst weiterarbeiten zu können. Da Sie gerade mit der Android-Entwicklung anfangen, verwenden Sie die einfachste Vorlage Empty Activity, die kaum Code erzeugt. Damit werden Sie die App praktisch von Grund auf neu aufbauen.

Nach dem Klick auf Next gelangen Sie zum nächsten Bildschirm des Assistenten, in dem die Basisdaten der App festgelegt werden.

Unter Name ist der ‌‌Name der App einzutragen. Dieser Name erscheint im ‌‌Android-Launcher (App-Übersicht). Der Wert wird als ‌Ressource verwaltet (zu den Ressourcen kommen wir später noch) und ist übersetzbar. Tragen Sie hier den Namen der App in der Hauptsprache ein. In unserem Fall ist es Zeiterfassung. Die Hauptsprache ist bei uns momentan Deutsch.

Unter Package name wird im Normalfall der eigene Internet-Domain-Name (in der umgekehrten Schreibweise) + Name der App eingetragen. In unserem Fall geben Sie für den ‌‌Package-Namen de.webducer.ab3.zeiterfassung ein.

Unter Save location können Sie den Speicherort des Projekts angeben, falls Sie es nicht im Standardverzeichnis speichern wollen.

Unter Language können Sie die Programmiersprache (Java oder Kotlin) auswählen, in der die Logik geschrieben wird. Diese Auswahl ist nicht endgültig und kann später angepasst werden. Für unser Projekt wählen Sie hier Java.

Die alternative Sprache »Kotlin« ist eine Java-kompatible Sprache, die seit 2017 offiziell von Google für Android-Entwicklung anerkannt wurde. Mittlerweile wird diese von vielen Android-Entwicklern, und auch Google selbst, präferiert. Kotlin kann auch parallel zu Java genutzt werden, wenn man eine App, zum Beispiel von Java, migriert.

Unter Minimum SDK wählen Sie die kleinste Android-Version, mit der die App noch kompatibel sein soll. Android Studio zeigt zur besseren Orientierung auch gleich die Statistik, auf wie viel Prozent der weltweit auf den Google Play Store zugreifenden Geräten die neue App funktionieren würde, wenn Sie die ausgewählte als minimale Version nutzen würden. API 23 (Android 6.0) ist jetzt eine sehr gute Wahl, da man mit dieser Version zum Zeitpunkt, als dieses Buch geschrieben wurde, ca. 85% der potenziellen Benutzer erreichen würde (wenn Sie dieses Buch lesen, wahrscheinlich mehr).

Nach einem Klick auf Finish wird das Projekt mit dem Grundgerüst erstellt und geöffnet. Dieser Prozess kann, abhängig von der Geschwindigkeit des Rechners (des Massenspeichers und der Internetverbindung), einige Zeit in Anspruch nehmen.

3.2.1  Neues‌ AVD anlegen

Bei der Installation von Android Studio wird ein AVD nur installiert, wenn Sie es in der »Customer«-Installation ausgewählt haben. Wir legen jetzt (noch) eins an, da Sie diesen Vorgang in der Praxis häufig durchführen müssen, um ein Gerät mit bestimmten Eigenschaften zu simulieren (wie spezielle Sprache, Auflösung, Android-Version usw.).

Für die Anlage eines neuen AVDs müssen Sie den ‌‌AVD Manager starten. Dazu haben Sie, wie unter Android Studio üblich, mehrere Möglichkeiten:

1. Über das Menü: Tools | AVD Manager

2. Über die Toolbar: Icon (AVD Manager)

Nun öffnet sich der AVD Manager, der alle bis jetzt eingerichteten Emulationen anzeigt und kurze Informationen zu diesen auflistet. Wenn noch kein AVD vorhanden ist, erscheint ein Dialog, der zur Anlage eines neuen AVDs einlädt.

Durch einen Klick auf Create Virtual Device ... gelangen Sie zu einem Assistenten, der die Anlage eines neuen Emulators erleichtert. Im ersten Bildschirm wählen Sie in der linken Spalte (Category , Abbildung 3.7), was für ein Gerät Sie emulieren möchten (wie Smartphone, Tablet, Android Wear oder TV). Für unseren ersten Test wählen Sie Phone. Als Modell eignet sich aktuell Pixel 2 XL sehr gut.

Einige der Vorlagen bieten auch einen integrierten Play Store. Damit können für Tests auch Apps installiert werden, mit denen die eigene App eventuell interagiert. Diese Integration erkauft man sich mit dem Nachteil, dass diese Vorlagen, im Gegensatz zu den übrigen, keinen »root«-Zugriff auf den Emulator erlauben. Solche Vorlagen sind an dem »Play Store«-Symbol in der Auflistung zu erkennen.

Ein »root«-Zugriff ist dann notwendig, wenn Sie später auf die Daten zugreifen möchten, die von Ihrer App erstellt wurden (zum Beispiel die Datenbank-Datei).

Nach dem Bestätigen mit Next können Sie auf dem nächsten Bildschirm die Android-Version auswählen, die auf dem emulierten Gerät laufen soll. Dabei gibt es Folgendes zu beachten:

1. CPU-Architektur: Aktuell werden Images für ARM, ARM x64, x86 und x86_x64 angeboten.

   • ARM-Images werden komplett emuliert. Das heißt, alle CPU-Befehle müssen durch Ihre reale CPU interpretiert werden. Deswegen sind die ARM-Images sehr langsam, auch auf den aktuell schnellsten Rechnern. Es dauert auch mehrere Minuten, bis der Emulator gestartet wird (siehe dazu auch die Vergleichstabelle zu den Startzeiten im Anhang). Google arbeitet aktuell an der Optimierung der ARM Emulatoren.

   • x86-Images werden durch den Intel-Treiber (‌HAXM – Hardware Accelerated eXecution Manager) direkt in der CPU Ihres Rechners ausgeführt, ohne Befehle zuerst interpretieren zu müssen (seit Android 3.2 werden auch AVDs auf AMD-Prozessoren beschleunigt, mit Hyper-V unter Windows). Auf den aktuellen Rechnern laufen deswegen die Apps in solchen Emulatoren deutlich schneller als auf den realen Geräten (ein Core i5 oder i7 ist immer noch deutlich schneller als jede mobile CPU). Der Zusatz x64 steht dafür, dass das Abbild (Image) ein 64Bit-Android enthält und somit nur auf einer 64-bitigen CPU laufen kann (sollte mittlerweile Standard sein). Auch das Entwickler-Betriebssystem muss 64-bitig sein. Relevant wird diese Unterscheidung erst dann, wenn Sie einen C/C++-Code ausführen möchten.

   Abb. 3.8: AVD-Assistent – Auswahl des Android SDKs

2. ‌‌‌Google API

   So gekennzeichnete Images sind ein wenig größer, da sie neben den reinen Android-Services auch die Services für Google-Dienste beinhalten, wie Maps, Play-Store-Service, Firebase usw. Diese Images benötigen Sie immer, wenn die App diese Services konsumieren soll.

3. API-Version

   Dies ist die eigentliche Version von Android. Abhängig von den Testkriterien sollten Sie eine für Sie passende auswählen.

Sollte im Recommended Tab nicht die gewünschte API Version vorhanden sein, wechseln Sie zum x86 Images-Tab. Hier können Sie die eventuell noch fehlende Images für eine Version direkt herunterladen. Wählen Sie hier Android Q (API 29) als x86 oder x86_64 für unseren Emulator.

Der nächste Bildschirm zeigt die Details des neuen virtuellen Geräts.

In der Standardansicht für die Details können folgende Daten angepasst werden:

• »AVD Name«: Name des AVDs

  Es ist empfehlenswert, an dieser Stelle eine Konvention zu nutzen, um anhand des Namens die Eigenschaften des AVDs schnell zu überblicken, wenn Sie viel mit AVDs arbeiten. Zum Beispiel A21_x86_de für Android AVD mit API 21, basierend auf dem x86-Abbild und in deutscher Sprache.

• Basis-Gerät, auf dem dieses AVD basiert, das wir auf dem ersten Bildschirm ausgewählt haben.

• SDK-Version für das AVD aus dem zweiten Bildschirm.

• »Startup Orientation«: Ausrichtung des AVDs

  Hoch- oder Querformat, die Umschaltung ist auch während der Laufzeit des AVDs möglich.

• »Emulated Performance Graphics«: Nutzung der Grafikkarte des Host-Rechners beschleunigt bei guter Grafikkarte die Animationen und Reaktionszeit des AVDs.

• »Device Frame«: Zeigt an, ob bei dem Emulator auch ein Geräterahmen angezeigt werden soll. Praktisch: Wenn Sie einen kleinen Bildschirm haben, können Sie den Rahmen weglassen und so mehr von der App sehen.

Weitere Einstellungen können vorgenommen werden, wenn Sie auf Show Advanced Settings klicken.

In der erweiterten Ansicht sind folgende ‌‌Einstellungen die wichtigsten:

• »Memory and Sorage«: Größe des Speichers

  Wichtig: Wenn Ihr Entwickler-Rechner wenig Arbeitsspeicher hat und Sie HAXM deshalb während der Installation nur wenig Speicher zugestanden haben, dann sollte der Arbeitsspeicher kleiner als der für HAXM zugebilligte sein, wenn Sie ein x86-Abbild nutzen.

• »SD-Card«: Speichergröße der SD-Karte

• »Keyboard«: Aktivierung der Hardware-Tastatur

  Das ist sehr nützlich, da sonst alle Eingaben über die Android-Tastatur im AVD mit der Maus gemacht werden müssen.

• »Camera«: Einstellen der beiden Kameras (emuliert – eine Animation – virtuelle 3D-Szene, keine oder Ihre Webcam)

• »Network«: Geschwindigkeit des Netzwerks (WLAN, LTE, GPRS usw.). Das kann auch später zur Laufzeit des Emulators geändert werden.

• »Device Frame«: Rahmen für das AVD, damit dieses wie ein »echtes« Gerät aussieht.

Nach der Bestätigung mit Finish wird das neue AVD generiert. Es kann auf langsameren Rechnern einige Zeit dauern, bis es erzeugt wurde. Danach schließen Sie den AVD Manager.

3.2.2  ‌‌Starten der App

Um eine App auf einem Emulator zu starten, müssen Sie zuerst in der Auswahlbox das Gerät selektieren, auf dem die App laufen soll. Im oberen Bereich werden kompatible, bereits laufende Geräte angezeigt. Im unteren Bereich lässt sich ein vorhandenes AVD aus der Liste auswählen.

Dann haben Sie, wie bei Android Studio üblich, mehrere Möglichkeiten, die App zu starten:

1. Über das Menü: Run | Run 'app'

2. Über die Toolbar mit dem -Icon

3. Über die Tastenkombination Control+R unter OS X und Umschalt+F10 unter Windows/Linux

Der Start des AVDs kann abhängig vom System sehr lange dauern (mitunter auch mehrere Minuten), insbesondere der erste Start (wie ein richtiger Neustart auf einem Android-Gerät nach dem Zurücksetzen auf die Werkseinstellungen).

Im neu gestarteten AVD erscheint nach dem Start von Android die Hello-World-App, die von dem Assistenten erzeugt wurde (wischen Sie, falls nötig, das Schloss-Symbol nach oben, um das AVD zu entsperren). Nun haben Sie eine lauffähige Basis, mit der Sie weiterarbeiten können.

Wenn Sie die App auf Ihrem Smartphone oder Tablet ausführen möchten, schließen Sie Ihr Gerät per USB-Kabel an. Es erscheint dann beim Start der App im Geräte-Auswahl-Dialog im oberen Bereich.

Wie Sie Ihr Smartphone oder Tablet für die Entwicklung freischalten und für den ersten Lauf einrichten, lesen Sie im Anhang A.3.