Im mobilen Segment hat Android mittlerweile einen Marktanteil in Deutschland von über 73% (Quelle: Statista 2020). An dieser großen Verbreitung möchten Sie sicherlich teilhaben, ob als Hobby-Programmierer oder in einem Unternehmen. Mit diesem Buch finden Sie einen praktischen Einstieg in die Android-Programmierung.
1.6 Danksagung
Dieses Buch würde nicht da sein, wenn mich nicht einige Menschen unterstützen würden.
In erster Linie gilt mein größter Dank meiner Familie, die oft genug auf mich verzichten muss, damit ich an dem Buch arbeiten kann.
Weiterhin gilt mein Dank meiner Lektorin, Frau Bahlmann, die das Buch mit Ideen für eine bessere Strukturierung und einen optimalen Sprachgebrauch zugänglicher gemacht hat. Auch ein Dank an meine erste Lektorin, Frau Janatschek, die die Geduld hatte, zwei Jahre auf die erste Veröffentlichung zu warten, und meinen technischen Schreibstil in einen leserlichen verwandelte.
Ein weiterer Dank gilt der Münchner Volkshochschule, in der ich seit 2009 unterrichte und mein Können bei der Arbeit mit Lernwilligen verfeinern darf.
Ohne die Leser wäre dieses Buch sinnlos. An dieser Stelle möchte ich mich bei allen Lesern bedanken, die Feedback zu diesem Buch (über Amazon-Rezensionen oder direkt per E-Mail an android-buch@webducer.de) an mich geschrieben haben. Ich habe in dieser dritten Auflage das Feedback umgesetzt und freue mich auf weiteres.
In diesem Kapitel befassen wir uns mit den Grundlagen für die Android-Programmierung. Dazu werden Sie eine Entwicklungsumgebung aufsetzen und die Grundbausteine der Android-Programmierung kennenlernen.
2.1 Entwicklungsumgebung
Bei der Programmierung ist es wichtig, nicht nur die Programmiersprache zu kennen, sondern auch die Werkzeuge. In diesem Abschnitt werden wir daher die Entwicklungsumgebung installieren und einrichten.
Android Studio ist seit 2014 die offizielle Entwicklungsumgebung für Android und basiert auf der nicht nur unter Java-Entwicklern sehr beliebten IDE (englische Abkürzung für Integrated Development Environment) von JetBrains IntelliJ IDEA. Diese Entwicklungsumgebung für auf »Java Virtual Machine« (kurz JVM) basierende Sprachen unterstützt den Programmierer bei der Entwicklung.
Neben IntelliJ IDEA liefert die Firma JetBrains noch weitere Entwicklungsumgebungen für andere Sprachen wie WebStorm für die Web-Entwicklung, PHP-Storm für PHP-Entwicklung, RubyMine für Ruby on Rails, ReSharper für .Net-Entwickler und mehr.
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.
Android Studio ist ein Open-Source-Projekt. Der Quellcode kann unter wdurl.de/ab3-as-projekt heruntergeladen werden und Sie können eigene Android-Studio-Versionen damit bauen.
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.
Die aktuellen Hardware-Anforderungen finden Sie unter :
developer.android.com/studio/index.html#Requirements.
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.
Installation unter Windows
Nach dem Download, der fast 1 GB groß ist, kann die Installation starten. Die Installation liefert auch eine Java-Laufzeitumgebung, sodass keine JDK-Installation mehr notwendig ist.
Wenn Sie die Standardeinstellungen bei der Installation beibehalten, installiert das Setup neben Android Studio auch ein Android Virtual Device (kurz AVD). Sie werden noch weitere AVDs im Laufe des Buchs installieren und deren Funktionen kennenlernen.
Mit dem nächsten Schritt (Abbildung 2.3) können Sie den Pfad für die Installation anpassen, falls Sie einen anderen Speicherort auswählen möchten.
In dem vorletzten Schritt (Abbildung 2.4) können Sie einen Ordner für das Startmenü ändern.
Nun startet die Installation, die abhängig vom System einige Minuten in Anspruch nehmen wird (Abbildung 2.5).
Nach der erfolgreichen Installation (Abbildung 2.6) haben Sie die Möglichkeit, Android Studio direkt zu starten. Das sollten Sie auch tun, da die Installation noch nicht abgeschlossen ist. Neben Android Studio muss auch Android SDK (Software Development Kit) installiert werden. Abhängig von den ausgewählten Komponenten werden noch mal ein bis zwei GB an Daten auf Ihren Rechner heruntergeladen.
Abhängig von der Windows-Version und der Einstellung der Firewall kann es beim Start zu einer Anfrage kommen, ob Android Studio sich mit dem Internet verbinden darf (für eigene Updates und für Updates von Android SDK). Um auf dem aktuellen Stand zu bleiben, sollten Sie natürlich den Zugriff gewähren.
Den Rest der Ersteinrichtung beschreibe ich nach der macOS- und Linux-Installation in Abschnitt 2.1.3, da diese Schritte unter allen Systemen gleich aussehen.
Installation unter OS X
Wie üblich unter macOS, müssen Sie nur Android Studio aus dem geöffneten Package in den Programmordner verschieben (oder in einen Ordner Ihrer Wahl, Abbildung 2.7). Im Paket befindet sich nur Android Studio. Das Android SDK (Software Development Kit) muss beim ersten Start installiert werden. Zusätzlich zu Android Studio fallen noch einmal 1 bis 2 GB an zusätzlichen Daten an.
Nach Abschluss der Installation und beim Start erscheint als Erstes ein Sicherheitsdialog, da Android Studio nicht über Apple Store installiert wurde. Bitte bestätigen Sie diesen Dialog (es muss nur einmal gemacht werden).
Die Ersteinrichtung beschreibe ich nach der Linux-Installation im Abschnitt 2.1.3, da diese Schritte unter allen Systemen gleich aussehen.
Installation unter Linux (Ubuntu)
Unter Ubuntu haben Sie zwei Installationsmöglichkeiten:
Installation über den integrierten Store. Suchen Sie im Store einfach nach »Android Studio« und installieren Sie es (Abbildung 2.9). Es wird auch eine Verknüpfung im Startmenü automatisch angelegt.
Manuelle Installation, die hier beschrieben ist (funktioniert unter allen Linux-Distributionen).
Unter Linux muss die heruntergeladene komprimierte Datei in einen Ordner entpackt werden. Zum Starten führen Sie im Terminal die Datei studio.sh
aus dem bin
-Ordner aus.
Die genauen Anweisungen zum Starten von Android Studio sind auch in der Datei Install-Linux-tar.txt
beschrieben. Die Datei liegt in dem Installationsverzeichnis.
Der erste Start (und Einrichtung des SDK) ist unter allen Betriebssystemen fast identisch.
2.1.3 Erster Start von Android Studio
Beim ersten Start erscheint die Meldung zur Übernahme der Einstellungen einer vorherigen Installation (falls vorhanden).
Diese Meldung erscheint immer bei größeren Updates, da die Einstellungen in versionsabhängigen Ordnern gespeichert werden (so kann man parallel auch mehrere Versionen von Android Studio haben), zum Beispiel beim Wechsel von Version 3.6.2 auf Version 4.0.0.
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.
Das SDK wird unter Windows in den Ordner c:\Users\<Benutzer>\AppData\Local\Android\sdk\
, unter macOS in den Ordner /Users/<Benutzer>/Library/Android/sdk/,
unter Linux in den Ordner home/<Benutzer>/Android/sdk
installiert. Diesen Ordner zu kennen, ist wichtig, um zum Beispiel über die Kommandozeile mit Android Debug Bridge (kurz ADB) zu arbeiten, Intel Hardware Accelerated Execution Manager (kurz HAXM) manuell zu installieren oder mitgelieferte Ressourcen anzusehen.
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.
Wenn Sie ein vorhandenes Projekt öffnen und dessen Dateien unverständliche Zeichen enthalten, kann dies an einer falschen Codierung der Dateien liegen. In der heutigen Programmierung sollten die Dateien als »UTF-8« codiert vorliegen, womit auch deutsche Umlaute in den Kommentaren und Texten keine Probleme verursachen. Sie sehen die Codierung der aktuell aktiven Datei immer in der Statusleiste.
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.
Wenn Sie mehr Platz für das Bearbeitungsfenster haben möchten, weil Sie gerade mit dem Codieren beschäftigt sind, können Sie alle Tool-Fenster auf einmal zuklappen. Dazu klicken Sie doppelt auf den Tab des aktuell aktiven Dokuments. Ein zweiter Doppelklick auf den Tab stellt alle Tool-Fenster wieder her.
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.
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.
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.
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.
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).
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.
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.
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:
Herunterladen der externen Abhängigkeiten
Kompilieren der Java-Dateien in DEX
Kompilieren der Ressourcen
Optional: Obfuscation mit ProGuard
Verpacken als APK-Datei (DEX + Ressourcen)
Signieren der APK-Datei
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.).
Wenn Sie mehr über Gradle wissen möchten, schauen Sie auf die offizielle Homepage des Build-Tools unter gradle.org. Weitere Möglichkeiten, das eigene Android-Build anzupassen, finden Sie auf den Entwickler-Seiten für Android unter developer.android.com/studio/build/.
Im Laufe der nächsten Kapitel werden wir eine einfache App entwickeln, die mit der Zeit erweitert und optimiert wird. Im Zuge der Entwicklung werden auch alle neuen Techniken und Technologien am praktischen Einsatz erklärt.
Die neue App soll Ihnen dabei helfen, Ihre eigene Arbeitszeit im Blick zu behalten. Dazu werden in diesem Kapitel folgende Funktionen umgesetzt:
3.1 Projektanlage
Zur Projektanlage starten Sie zuerst die Entwicklungsumgebung »Android Studio«.
Die Entwicklungsumgebung bietet mehrere Möglichkeiten, mit der Arbeit zu beginnen:
»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).
Den Quellcode für die Aufgaben im Buch finden Sie bei dem Anbieter Bitbucket. Der Code ist in Kapitel unterteilt und führt Sie von einer Aufgabe zur nächsten – vom Ausgangscode zur Lösung der gestellten Aufgaben.
»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
Sollten neue Android-Studio-Versionen grundlegende Änderungen enthalten, so dass die Inhalte im Buch nicht mehr nachvollzogen werden können, werden korrigierte Kapitel auf der Projektseite veröffentlicht. Sollten Sie eine solche Änderung feststellen, schreiben Sie bitte an android-buch@webducer.de, damit ich die Korrekturen vornehmen und für alle verfügbar machen kann.
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.
Jede Android-App sollte einen weltweit eindeutigen Namen haben, damit es zu keinen Konflikten in den App Stores kommt. Es wird empfohlen, als Namen die umgekehrte Schreibweise der eigenen Homepage zu nutzen, plus den Namen der App.
Im Namen dürfen keine Leer- oder Sonderzeichen, außer ».«, vorkommen, und es sollen nur Kleinbuchstaben verwendet werden. Der Grund dafür liegt in den Java-Konventionen. Der Package-Name wird im Java-Code auch als Package-Root verwendet. Die Java-Konventionen schreiben Kleinschreibung ohne Sonderzeichen vor. Die Trennung der Ebenen erfolgt nur durch einen Punkt.
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).
Um ein besseres Gespür für die Verbreitung der Versionen zu entwickeln, klicken Sie auf den Link Help me choose, der die Verbreitung der einzelnen Versionen grafisch aufzeigt. Die Angaben sind nicht ganz aktuell, aber nicht weit von der Wahrheit entfernt. Unter dem Link finden Sie noch weitere Statistiken zu Android, wie Statistiken zu Bildschirmgrößen, OpenGL Versionen usw.
Ein Klick auf die einzelnen Versionen in dieser Übersicht zeigt auch gleichzeitig die Funktionen, die mit dieser Version eingeführt wurden. Zum Beispiel macht API 16 (Android 4.1) gar keinen Sinn, wenn Sie eine App schreiben wollen, die auf Bluetooth Smart (Bluetooth Low Energy) angewiesen ist. Diese Funktionalität wurde erst mit API 18 (Android 4.3) eingeführt.
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.
src/kap03-layouts/00-start
3.2 Ausführen der App im Emulator
Nachdem Android Studio Ihnen ein Grundgerüst für die App erstellt hat, wollen Sie bestimmt wissen, wie dieses Grundgerüst auf dem Smartphone oder im Emulator aussieht. Zuerst sehen wir uns die App auf einem »Android Virtual Device« (kurz AVD) an.
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:
Über das Menü: Tools | AVD Manager
Ü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:
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.
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.
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:
Über das Menü: Run | Run 'app'
Über die Toolbar mit dem -Icon
Ü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).
Schließen Sie das AVD nach dem Start nicht, da der Neustart immer eine gewisse Zeit dauert. Wenn Sie Ihren Code ändern und die App neu mit Run 'app' ausführen, wird die im Emulator laufende App durch die neue Version ersetzt. Der Emulator muss dabei nicht neu gestartet werden.
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.