Android mit Kotlin – kurz & gut - Jörg Staudemeyer - E-Book

Android mit Kotlin – kurz & gut E-Book

Jörg Staudemeyer

0,0

Beschreibung

Diese Befehlsreferenz ist ein nützlicher und zuverlässiger Begleiter für alle Systemadministratoren, die Aufgaben nicht ausschließlich über die Menüstruktur der GUI, sondern schnell und effektiv in der Eingabeaufforderung ausführen möchten. Befehle der Eingabeaufforderung Das Buch beschreibt die meisten Befehle der Eingabeaufforderung für die gängigen Windows-Betriebssysteme einschließlich Windows Server 2016 und Windows 10 mit ihren jeweiligen Optionen in komprimierter Form. Die Befehle sind thematisch gruppiert, ein ausführlicher Index hilft beim schnellen Auffinden. PowerShell-Alternativen Da Microsoft der Windows PowerShell eine immer größere Bedeutung beimisst, sind bei den Befehlen der Eingabeaufforderung häufig auch alternative Lösungsansätze mit PowerShell aufgeführt. Das Buch bietet Ihnen damit Hilfestellungen und Anregungen für den Übergang von der klassischen Eingabeaufforderung zur Systemadministration mit Windows PowerShell. Kompakt, nützlich und auf den Punkt gebracht: Diese Taschenreferenz ist auch in der 6. Auflage ein unverzichtbares Nachschlagewerk für alle Windows-Administratoren.

Sie lesen das E-Book in den Legimi-Apps auf:

Android
iOS
von Legimi
zertifizierten E-Readern

Seitenzahl: 244

Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:

Android
iOS
Bewertungen
0,0
0
0
0
0
0

Beliebtheit




Zu diesem Buch – sowie zu vielen weiteren O’Reilly-Büchern – können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei oreilly.plus+:

www.oreilly.plus

Android mit Kotlin

kurz & gut

Jörg Staudemeyer

Jörg Staudemeyer

Lektorat: Alexandra Follenius

Korrektorat: Sibylle Feldmann, www.richtiger-text.de

Herstellung: Susanne Bröckelmann

Umschlaggestaltung: Michael Oréal, www.oreal.de

Satz: III-satz, www.drei-satz.de

Druck und Bindung: M.P. Media-Print Informationstechnologie GmbH, 33100 Paderborn

Bibliografische Information Der Deutschen Nationalbibliothek

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen

Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über

http://dnb.d-nb.de abrufbar.

ISBN:

Print  978-3-96009-038-0

PDF   978-3-96010-204-5

ePub  978-3-96010-205-2

mobi  978-3-96010-206-9

Dieses Buch erscheint in Kooperation mit O’Reilly Media, Inc. unter dem Imprint »O’REILLY«. O’REILLY ist ein Markenzeichen und eine eingetragene Marke von O’Reilly Media, Inc. und wird mit Einwilligung des Eigentümers verwendet.

1. Auflage

Copyright © 2018 dpunkt.verlag GmbH

Wieblinger Weg 17

69123 Heidelberg

Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.

Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.

Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen.

5 4 3 2 1 0

Inhalt

Vorwort

Teil I: Grundlagen

1 Das Android-System

Versionsgeschichte

Architektur

Android-Apps

2 Entwicklungsumgebung und Entwicklungsprozess

Installation

Die Entwicklungsumgebung im Überblick

Das SDK konfigurieren

Ein neues Projekt anlegen

Programmieren

Der Build-Prozess

Starten und debuggen

Testen

Veröffentlichen

3 Kotlin für Android

Kotlin im Android-Projekt

Elementare Unterschiede

Das Typensystem

Null-sichere Operatoren

Ablaufsteuerung

Funktionen

Variablen, Felder und Properties

Klassen und Interfaces

Singleton-Objekte

Kollektionen, Maps und Wertebereiche

Teil II: Apps implementieren

4 Apps programmieren

App-Komponenten

Der Kontext

Intents und Parcels

Berechtigungen deklarieren und prüfen

Multithreading

Logging

5 Mit Ressourcen arbeiten

Struktur und Form

Auf Ressourcen zugreifen

Einfache Ressourcentypen

Roh-Ressourcen

6 Activity und Layout

Funktionsweise der Activity

Anmeldung im Manifest

Implementierung

Start und Ende

Vorgefertigte Activities

Layoutdefinition

View-Ereignisse

Elementare Views

View-Gruppen

Fragmente

7 Weitere Komponententypen

Komponententyp Service

Komponententyp Broadcast-Receiver

Komponententyp Content-Provider

Teil III: Systemfunktionen

8 Navigation und Dialoge

Menüs

Dialoge

Mitteilungen

9 Persistente Daten

Präferenzdaten

Zugriff auf Dateien

SQLite-Datenbanken

10 Systemdienste und Sensoren

Systemdienste verwenden

Auf Sensoren zugreifen

Referenzteil

Android-Versionen

API-Übersichten

Ressourcenkennzeichen

Systemdienste

Sensortypen

Standardaktionen

Manifest

Kotlin-Standardfunktionen

Index

Vorwort

Android mit Kotlin – kurz & gut wendet sich an Programmiererinnen und Programmierer, die sich das für die Entwicklung von Android-Apps erforderliche Grundlagenwissen rasch aneignen möchten und nicht erst dicke Lehrbücher und unübersichtliche Webanleitungen durcharbeiten wollen. Das Büchlein führt Sie kurz und knapp in die technischen Zusammenhänge und Vorgehensweisen ein und bietet eine Kurzreferenz für die wichtigsten zur Android-Entwicklungsumgebung gehörenden Begriffe, Werkzeuge, APIs usw.

Android-Programmierung ist ein sehr umfangreiches Thema, das sich in diesem Kurz-&-gut-Bändchen nicht annähernd in der Breite und Tiefe darstellen lässt, wie Sie es zur Programmierung ernsthafter Anwendungen benötigen. Daher werden Sie auch weiterhin auf die ausführliche Android-Dokumentation und andere Informationsquellen (siehe unten) zurückgreifen müssen, wenn es um weitere Funktionen oder kompliziertere Details geht. Schwerpunktmäßig beschränken wir uns hier auf die Programmierung von Apps für Smartphones und Tablets; was die grundsätzlichen Mechanismen angeht, sind die Unterschiede zur Programmentwicklung für Fernseher, Uhren, Automobilkonsolen usw. jedoch nicht allzu groß.

Ungeachtet seines abweichenden Titels ist dieses Buch eine überarbeitete und umstrukturierte dritte Auflage von Android-Programmierung kurz & gut. Ein wesentlicher Unterschied zu den vorangegangenen Auflagen besteht darin, dass die Codebeispiele nicht mehr in Java, sondern in der neuen Programmiersprache Kotlin formuliert sind. Kotlin bietet – gerade in der Android-Program-mierung – viele Vorteile und ist für Java-Programmierer relativ leicht zu lernen. Um den Übergang zu erleichtern, haben wir das Kapitel 3, Kotlin für Android, hinzugefügt, das die wichtigsten Unterschiede zwischen Kotlin und Java in kompakter Form erläutert.

Vorkenntnisse

Um dieses Buch erfolgreich nutzen zu können, sollten Sie über gewisse Vorkenntnisse verfügen. In erster Linie gehört dazu ein solides Grundwissen über die Java-Programmierung (Java SE) im Speziellen und die moderne Rechner-, Netzwerk- und Datenbanktechnik im Allgemeinen. Daneben sollten Sie sich aber auch schon etwas mit dem Gebrauch von Android-Geräten auskennen und möglichst ein halbwegs aktuelles Android-Telefon oder -Tablet zum Ausprobieren besitzen. Einige Erfahrungen mit der Java-Entwicklungsumgebung IntelliJ IDEA können nicht schaden, sind aber keine Voraussetzung.

Android-Versionen

Die Codebeispiele und Erläuterungen sind so gewählt, dass sie noch auf Geräten mit der Android-Version 4.0 (Ice Cream Sandwich) und höher laufen, das schließt aber nicht die Verwendung neuerer Features (zurzeit bis Android 8.1) aus, sofern sie durch ergänzende Android-Bibliotheken unterstützt werden. Die Darstellung der Entwicklungsumgebung beruht auf Android Studio Version 3.0 und Android SDK Version 27.

Aufbau dieses Buchs

Das Buch besteht aus drei Teilen:

Teil I – Grundlagen beschäftigt sich mit Dingen, die man (eigentlich) wissen sollte, bevor man zu programmieren anfängt. Er bietet einen groben Überblick über die Funktionsweise des Android-Systems insgesamt und die darin laufenden Apps, eine Beschreibung der umfangreichen Entwicklungsumgebung und wie man mit ihr umgeht sowie eine Einführung in die Programmierung mit Kotlin, soweit es für das Verständnis der Beispiele in diesem Buch erforderlich ist.

Teil II – Apps implementieren handelt davon, wie man Apps schreibt, aus welchen Komponenten sie bestehen, welche Mechanismen und Schnittstellen Sie beachten müssen und welche Hilfsmittel Android Ihnen dafür zur Verfügung stellt.

Teil III – Systemfunktionen hat die Fülle der technischen Möglichkeiten zum Inhalt, die Ihnen ein Android-Gerät zur Verfügung stellt, und zeigt, wie man die wichtigsten von ihnen konkret nutzt.

Der Referenzteil bringt schließlich verschiedene Übersichten in Listen- und Tabellenform, die den Inhalt der drei Teile ergänzen und zum späteren Nachschlagen kompakt zusammengestellt sind.

Weitere Informationsquellen

Wenn Sie sich tiefer gehend informieren möchten (und das werden Sie müssen, wenn Sie Apps programmieren), finden Sie unendlich viele Tipps, Tutorials, Foren usw., in denen fast jede erdenkliche Frage beantwortet wird. Einige Informationsquellen sind aber besonders zu empfehlen:

Die Android-eigenen Webseiten für Programmierer bieten umfassende Dokumentationen, die nur selten Lücken aufweisen, sich aber – schon wegen ihres Umfangs – nicht immer ganz leicht erschließen:

https://developer.android.com/index.html

.

Wenn Sie über die neuesten Entwicklungen bei Android auf dem Laufenden bleiben möchten, sollten Sie gelegentlich in das Android-Entwicklerblog von Google hineinschauen:

https://android-developers.googleblog.com

.

Dort kann man auch einen Newsletter für Entwickler bestellen:

https://developer.android.com/newsletter/index.html

.

Die kompakteste und gleichzeitig umfassendste Beschreibung der Programmiersprache Kotlin findet man wohl auf den Seiten des Kotlin-Projekts:

https://kotlinlang.org/docs/reference/

.

Wer bewegte Bilder mag, findet im »Android Developer«-Kanal Stoff zum Zuschauen:

https://www.youtube.com/user/android-developers

. Dort gibt es auch Beiträge zum Thema Android-Programmierung mit Kotlin.

Was gedruckte Literatur angeht, gibt es ebenfalls ein breites Angebot, hier daraus auch noch zwei Tipps.

Soeben frisch herausgekommen:

Android Studio 3.0 Development Essentials

von Neil Smyth (Payload Media) beleuchtet wohl alle Winkel der Android-Programmierung – und kommt dabei trotz relativ kompakter Darstellung auf 82 Kapitel und über 800 Seiten! Das Buch gibt es in einer Java- und einer Kotlin-Version.

Weniger massiv und eher auf die Besonderheiten von Kotlin im Zusammenhang mit Android bezogen ist

Kotlin for Android Developers

von Antonio Leiva (Leanpub).

TEIL I

Grundlagen

KAPITEL 1

Das Android-System

Android ist eine Kombination aus Betriebssystem und Anwendungsframework, ausgerichtet auf die besonderen Anforderungen und Möglichkeiten von mobilen Geräten. In diesem Kapitel zeigen wir, wie diese Plattform aufgebaut ist und wie auf ihrer Basis Anwendungen betrieben werden.

Versionsgeschichte

Android hat in seiner kurzen Geschichte bereits eine lange Reihe von Release-Ständen erreicht, die mit jeweils neuen oder veränderten Funktionalitäten verbunden sind. Da viele Geräte keine Aktualisierung der auf ihnen installierten Android-Version erlauben, muss man beim Konzipieren einer App immer berücksichtigen, dass auch die alten Android-Versionen noch vielfältig genutzt werden. Die Android-Entwicklungsumgebung unterstützt Sie dabei, Apps zu schreiben, die auch auf älteren Geräten noch laufen. Allerdings sind dann natürlich nicht alle Features von neueren Geräten verfügbar.

Die Fragmentierung in den Griff bekommen

Um Ihnen die Einschätzung darüber zu erleichtern, auf welche früheren Android-Plattformen Sie noch Rücksicht nehmen sollten, finden Sie unter https://developer.android.com/about/dashboards/ eine Übersicht der aktuellen Marktanteile, die regelmäßig anhand der Zugriffe auf Google Play ermittelt werden. Gegenwärtig (November 2017) zeigt sie, dass Anwendungen, die mit Android 4.0.3 und höher kompatibel sind, über 99 Prozent des gesamten Gerätebestands abdecken.

Unter https://developer.android.com/guide/topics/manifest/uses-sdkelement.html#ApiLevels können Sie die Release-Notes der wichtigeren aktuellen und früheren Plattformversionen abrufen, um zu erfahren, in welchen Versionen welche neuen Funktionen eingeführt worden sind. Eine aktuelle Zusammenfassung der Versionsgeschichte finden Sie auch in der Wikipedia unter https://de.wikipedia.org/wiki/Liste_von_Android-Versionen.

Prinzipiell können Sie davon ausgehen, dass eine für eine Plattformversion (z.B. 4.0) erstellte App auch auf höheren Android-Versionen (z.B. 7.0 oder 8.0) funktioniert, da die APIs prinzipiell aufwärtskompatibel weiterentwickelt werden. Allerdings kann es Änderungen im Verhalten des Betriebssystems geben, die möglicherweise zu Problemen in späteren Versionen führen. Ein Beispiel dafür ist die Einführung dynamischer Berechtigungen in Android 6.0 (siehe den Abschnitt »Android-Apps«, auf Seite 20), die dazu führen kann, dass ältere Apps abstürzen, die die verfügbaren Berechtigungen nicht auf die richtige Weise abfragen, weil das in früheren Plattformversionen nicht nötig war.

Testen Sie Ihre Apps immer gegen neuere Android-Versionen, bevor diese auf dem Gerätemarkt verfügbar werden, um den Anwendern mit den neuesten Mobiltelefonen und Tablets böse Überraschungen zu ersparen.

Versionsnummer und API-Level

Jede Android-Plattformversion wird, wie traditionell bei Softwareprodukten üblich, durch eine zwei- oder dreiteilige Versionsnummer (beispielsweise »4.0.3« oder »7.0«) und einen Codenamen wie »Ice Cream Sandwich« oder »Nougat« (seit Version 1.5 immer Bezeichnungen von in den USA populären Süßwaren) gekennzeichnet.

Versionswechsel der Plattform gehen meistens, aber nicht immer, mit Erweiterungen der Android-APIs einher. Daher gibt es eine gesonderte, durchgängig ganzzahlige Nummerierung der API-Levels, also der Versionsstände der Bibliotheken, auf die sich die Dokumentationen häufig beziehen.

Wenn wir uns im Text auf eine bestimmte Android-Version beziehen, geben wir in der Regel die Versionsnummer und das API-Level an, z.B. Android 4.0.3 (API-Level 15) für »Ice Cream Sandwich MR1« oder Android 8.0 (API-Level 26) für »Oreo«.

Im Anhang auf Seite 239 finden Sie eine Übersicht aller bisherigen Android-Versionen.

Architektur

Die auf einem Android-Gerät laufende Software stellt ein komplexes, mehrschichtiges Gebilde dar. Bei der normalen Anwendungsprogrammierung bekommen Sie davon nicht allzu viel direkt zu sehen, sollten aber Bescheid wissen, um das Geschehen im System richtig verstehen zu können. Eine schematische Übersicht sehen Sie in Abbildung 1-1.

Abbildung 1-1: Android-Architektur

Der »harte Kern«

Die Systemkomponenten in den unteren Schichten des Betriebssystems bestehen aus kompiliertem C- oder C++-Code und sind für normale Android-Apps unsichtbar.

Die Basis des Betriebssystems bildet ein angepasster Linux-Kern. Er stellt elementare Systemfunktionen wie die Prozessverwaltung, die Benutzer- und Rechteverwaltung, den Dateizugriff usw. zur Verfügung.

Ebenfalls auf der untersten Ebene befindet sich ein

Hardware Abstraction Layer

(HAL) mit gerätespezifischen Treibern, die einen einheitlichen Zugriff auf divergierende Hardwareplattformen ermöglichen. Das HAL und die Linux-Kernels müssen von Geräteherstellern an die Besonderheiten der in ihren Geräten verbauten Hardware angepasst werden.

Weiterhin gibt es eine Reihe von C- bzw. C++-Bibliotheken, die geräteunabhängige Basisfunktionen zur Verfügung stellen. Dazu gehören unter anderem

SQLite

als relationales Datenbanksystem und

Chromium

(bzw. früher

LibWebCore

) als schnelle HTML-Rendering-Engine.

Die

virtuelle Maschine

(VM) dient dazu, die in einer speziellen Bytecode-Variante codierten Java-Programme der Android-Apps und des Anwendungsframeworks auszuführen. Seit Android 6.0 wird eine leistungsfähige VM namens

ART

(

Android Runtime Environment

) eingesetzt. In älteren Geräten übernimmt diese Aufgabe eine virtuelle Maschine namens

Dalvik

. Beide verarbeiten nur eine spezielle Form von Maschinenprogrammen, die sich von normalem Java-Bytecode grundsätzlich unterscheidet, da sie für einen anderen, Speicherplatz sparenden Prozessortyp optimiert ist: das

Dalvik Executable Format

(DEX).

Mit der Android-Version 8.0 wurde durch das Projekt »Treble« eine klare Abtrennung der geräteabhängigen, angepassten Teile im HAL und im Kernel vom Rest des Betriebssystems eingeführt. Dadurch wird es möglich, neue Android-Versionen einzuspielen, ohne dass die Hersteller erst einmal aufwendige Anpassungen vornehmen müssen. Damit dürfte das Ende der Zersplitterung in der Android-Landschaft eingeläutet sein. Wenn man aber bedenkt, dass auch heute noch Geräte mit dem inzwischen vier Jahre alten KitKat verkauft werden, kann man sich vorstellen, wie lange uns das Nebeneinander alter und neuer Android-Versionen noch erhalten bleiben wird.

Die sichtbaren Teile

Die folgenden Systemkomponenten liegen denn auch im DEX-Format vor, werden also (typischerweise) in Java programmiert und laufen auf der virtuellen Maschine (ART oder Dalvik). Bei der Entwicklung Ihrer App haben Sie ausschließlich hiermit zu tun.

Die Java-Standardbibliotheken stellen Ihnen alle für die Java-Programmierung prinzipiell benötigten anwendungsneutralen Basisfunktionen zur Verfügung. Sie entsprechen weitgehend den vom Standard-JDK bekannten Bibliotheken, sind aber auf die Erfordernisse der Android-Programmierung angepasst. Insbesondere fehlen APIs, die im Zusammenhang mit der Android-Programmierung keinen Sinn ergeben, wie etwa AWT und Swing.

Das Android-Anwendungsframework umfasst eine Fülle von APIs für Grundfunktionen, mit deren Hilfe Anwendungen die Features ihrer Geräte nutzen sowie eine einheitliche Darstellung und ein Höchstmaß an Effizienz und Wiederverwendung erreichen können. Es ist komplett in Java programmiert, auch wenn die eigentliche Funktionalität zu einem großen Teil durch den Linux-Kernel oder die nativen Bibliotheken zur Verfügung gestellt wird.

Die mitgelieferten Systemanwendungen repräsentieren schließlich die gesamte für Anwender in Form von Icons im Home-Screen sichtbare Funktionalität der Android-Plattform. Mit wenigen Ausnahmen (z.B. der

Einstellungen

-App) kann die Funktionalität der Systemanwendungen vollständig durch vom Benutzer selbst installierte Apps ersetzt werden, und sie können gleichberechtigt miteinander und mit dem Betriebssystem kommunizieren. Das heißt auch, dass den System-Apps im Prinzip dieselben APIs zur Verfügung stehen wie Ihrer selbst programmierten App.

Es besteht auch die Möglichkeit, in C bzw. C++ (oder einer anderen Sprache) programmierten Binärcode einzubetten, um besonders zeitkritische Aufgaben zu erledigen oder interne Features direkt aufzurufen; diese Möglichkeit wird jedoch nur in speziellen Fällen benötigt und wird daher hier nicht behandelt.

Die Realisierung von in Java geschriebenen Benutzeranwendungen bildet das Thema dieses Buchs. In den weiteren Kapiteln werden wir uns damit beschäftigen, wie sie im Einzelnen funktionieren, wie man sie programmiert und welche Unterstützung das Framework bietet.

Android-Apps

Android definiert eine Reihe von Regeln und Konventionen, die eingehalten werden müssen, damit sich ein Programm überhaupt auf einem Gerät installieren und starten lässt. So ist auch genau festgelegt, aus welchen Bestandteilen eine Android-Anwendung bestehen kann und wie diese Bestandteile untereinander und mit dem Anwendungsframework kommunizieren.

Die APK-Datei

Eine Android-App besteht immer aus einer einzigen Datei, deren Dateiname mit .apk (Android-Package) endet. Die Datei enthält nichts weiter als ein gewöhnliches JAR-Archiv mit folgendem Inhalt (Sie können ihn selbst ansehen, indem Sie die Datei mit einem Unzip-Programm öffnen):

META-INF

– ein Verzeichnis mit dem JAR-Manifest (Inhaltsverzeichnis des Archivs) sowie den zur App gehörenden Zertifikaten.

res

– ein Verzeichnis mit den zur App gehörenden Ressourcen im Quellformat. Dies sind diverse Arten unveränderlicher Daten wie Bildschirmlayouts, Texte, Bilder und Medien, die von einer Anwendung benötigt werden, aber selbst kein Programmcode sind.

resources.arsc

– eine Datei mit den Ressourcen in vorkompilierter, zur Laufzeit schnell auswertbarer Form.

classes.dex

– eine Datei mit dem gesamten ausführbaren Programmcode im sogenannten Dalvik-Executable-Format, das von der Android-eigenen virtuellen Maschine Dalvik bzw. ART verstanden wird.

AndroidManifest.xml

– eine Datei mit den Metadaten der App, die sowohl vom App-Shop als auch vom Android-Framework auf dem Gerät bei der Installation und beim Betrieb ausgewertet wird.

App-Betrieb in der Sandbox

Android-Anwendungen laufen typischerweise auf mobilen Geräten, die spezielle Anforderungen an die auf ihnen betriebenen Programme stellen. Dazu gehören begrenzte physische Ressourcen, eine Vielzahl von eng miteinander verwobenen Anwendungen aus unterschiedlichen Quellen, aber auch die Fähigkeit, auf bestimmte Ereignisse (vor allem eingehende Telefonanrufe) unvermittelt reagieren zu können. Um unter diesen Bedingungen einen sicheren Betrieb zu gewährleisten, müssen die Anwendungen in einer bestimmten Art und Weise betrieben werden.

Jede Android-Anwendung wird in einer eigenen sogenannten Sandbox (einer weitgehend isolierten Umgebung) betrieben, in der sie nur die Rechte für den Zugriff auf diejenigen Daten und Gerätefunktionen hat, die sie für ihre spezifischen Aufgaben benötigt.

Dies wird dadurch erreicht, dass jede Anwendung in der Regel unter einem eigenen Linux-Benutzerkonto läuft, von dem allerdings weder Anwender noch Anwendungsprogrammierer etwas wahrnehmen. Die Zugriffsberechtigungen aller zu einer Anwendung gehörenden Dateien im Systemspeicher werden standardmäßig so eingestellt, dass nur das eigene Benutzerkonto darauf zugreifen kann.

Sofern sich eine Anwendung nicht gerade in der Entwicklung befindet und über die Entwicklungsumgebung gestartet wird, lässt sie sich nur installieren, wenn sie mit einem Zertifikat des Herstellers signiert ist. Das Zertifikat muss nicht von einer offiziellen Zertifizierungsstelle ausgestellt worden sein (und ist es in der Regel auch nicht), denn es dient nur dazu, Anwendungen verschiedener Herkunft sicher voneinander zu trennen.

Man kann auch mehrere Anwendungen so einrichten, dass sie gemeinsam unter demselben Linux-Konto laufen und gegenseitig auf ihre Dateien zugreifen können. Das erfordert aber, dass sie mit demselben Zertifikat signiert sind – also praktisch aus derselben Quelle stammen.

In der Regel läuft jede Anwendung vollkommen getrennt von allen anderen Apps in ihrem eigenen Prozess und damit in ihrer eigenen virtuellen Maschine. Der Prozess wird vom Betriebssystem gestartet, sobald eine ihrer Anwendungskomponenten aufgerufen wird. Er wird spätestens dann wieder beendet, wenn die Anwendung nicht mehr aktiv ist und der von ihr beanspruchte Arbeitsspeicher für andere Zwecke benötigt wird.

Trotz der strikten Trennung der Anwendungen ist es möglich, dass verschiedene Anwendungen auf einem System untereinander Funktionen aufrufen und Informationen austauschen können. Das funktioniert aber nur, indem alle ausgetauschten Informationen von der absendenden App serialisiert (d.h. von einer internen Objektstruktur in eine sequenzielle Form codiert) und von der empfangenden App deserialisiert (d.h. wieder zu einer internen Objektstruktur decodiert) werden. Das Anwendungsframework bietet dafür unterstützende Funktionen, allerdings müssen festgelegte Regeln eingehalten werden. Außerdem setzt die Kommunikation mit anderen Apps häufig bestimmte Rechte voraus.

Berechtigungen

Wenn eine App auf Informationen zugreifen will, die außerhalb des eigenen Zuständigkeitsbereichs liegen, oder Aktionen ausführen will, die sich außerhalb auswirken, benötigt sie dafür entsprechende Rechte. Damit ein solches Recht in Anspruch genommen werden kann, muss es im Manifest deklariert werden. Wenn das Recht nicht deklariert ist, kann die App die betreffenden Aktionen nicht ausführen; schlimmstenfalls stürzt sie ab.

Eine Reihe dieser Rechte, die von Android als »kritisch« markiert sind, bekommt die App lediglich mit expliziter Zustimmung des Benutzers. Bis zur Android-Version 5.1 (API-Level 22) werden diese Rechte nur bei der Neuinstallation einer App abgefragt (und gegebenenfalls bei einem Update, wenn zusätzliche Rechte benötigt werden): Die Benutzer müssen vor dem Aufspielen der App zustimmen, dass diese die entsprechenden Rechte in Anspruch nehmen darf. Wenn die Frage dazu verneint wird, lässt sie sich nicht installieren.

Seit Android 6.0 werden die Benutzer erst dann gefragt, ob sie mit der Vergabe eines Rechts an eine App einverstanden sind, wenn das Recht tatsächlich benötigt wird. Dadurch können Rechte einer App von Fall zu Fall nach Bedarf zugebilligt werden.

In Kapitel 4, Apps programmieren, finden Sie Details zum Festlegen und Abfragen von Berechtigungen in der Anwendung.

KAPITEL 2

Entwicklungsumgebung und Entwicklungsprozess

Ein fester Bestandteil von Android ist die umfangreiche, umfassend dokumentierte Entwicklungsumgebung, mit der sich Anwendungen komfortabel entwickeln, unter realitätsnahen Bedingungen testen, schließlich veröffentlichen und damit potenziellen Anwendern auf der ganzen Welt zugänglich machen lassen.

Um selbst Android-Apps entwickeln zu können, benötigen Sie die Entwicklungsumgebung Android Studio und das Android Software Development Kit (Android SDK). Daneben gibt es noch ein Native Development Kit (Android NDK), das zur Entwicklung von Programmen in C oder C++ und nur in sehr speziellen Fällen benötigt wird; es soll daher hier nicht weiter behandelt werden.

Die Darstellungen in diesem Kapitel beruhen auf der Android-Studio-Version 3.0 und der SDK-Version 27, Stand November 2017. Die Entwicklungsumgebung ist der Teil von Android, der sich am schnellsten fortentwickelt. Es ist daher nicht auszuschließen, dass sich Aussehen und Funktionsweise der Werkzeuge schon wieder in Details verändert haben, wenn Sie dieses Buch lesen.

Installation

Um den Arbeitsplatz eines Android-Entwicklers einzurichten, genügt es, Android Studio zu installieren. Alle benötigten Werkzeuge sind im Installationsprozess enthalten oder werden (mehr oder weniger) automatisch hinzugeladen.

Voraussetzungen

Sie benötigen einen neueren, möglichst leistungsfähigen Arbeitsplatz-PC mit einer aktuellen Version eines der Betriebssysteme Microsoft Windows, Linux oder Mac OS X und ein paar Gigabyte Plattenplatz. Im Einzelnen wird gegenwärtig die folgende Geräteausstattung vorausgesetzt:

Eines der folgenden Betriebssysteme:

Windows 7, 8 oder 10

Mac OS X (Intel) 10.10 bis 10.13

Linux mit GNOME- oder KDE-Desktop und glibc 2.19 oder höher

Ein 64-Bit-System (sofern Sie den Emulator verwenden wollen, was auf jeden Fall zu empfehlen ist).

Mindestens 4 GB RAM (besser 8 GB oder mehr).

Etwa 4 GB freier Plattenplatz.

Bildschirm mit mindestens 1.280 × 800 Pixeln.

Es ist nicht mehr erforderlich, dass auf dem Rechner eine Java-Entwicklungsumgebung (JDK) installiert ist, da Android Studio selbst ein OpenJDK mitbringt.

Wenn Sie Android Studio auf einem 64-Bit-Linux-Rechner betreiben wollen, benötigen Sie einige zusätzliche Bibliotheken. Näheres dazu ist unter https://developer.android.com/studio/install.html beschrieben.

Android Studio installieren

Nehmen Sie sich etwas Zeit. Die Android-Entwicklungsumgebung ist sehr umfangreich, und wenn Sie sie zum ersten Mal installieren, muss erst einmal einiges herunter- und nachgeladen, ausgepackt und initialisiert werden, bis Sie die erste App fertig angelegt haben.

Laden Sie die zu Ihrem Betriebssystem und Ihrem Prozessortyp passende Installationsdatei von der Seite https://developer.android.com/studio/index.html herunter. Dort finden Sie auch detailliertere Angaben zum Installationsprozess und den Installationsvoraussetzungen.

Wenn Sie ein 64-Bit-Windows-System haben, laden Sie am besten das All-inclusive-Installationspaket (android-studio-ide-XXX-windows.exe), starten es und folgen den Anweisungen. Sie bekommen dann Android Studio fertig installiert und können es über ein Desktopsymbol oder das Startmenü aufrufen.

Wenn Sie Linux verwenden, laden Sie die entsprechende Archivdatei (android-studio-ide-XXX-linux.zip) und packen das darin enthaltene Verzeichnis android-studio an geeigneter Stelle aus, z.B. im Verzeichnis /opt. Starten Sie dann das in dem Unterverzeichnis bin liegende Programm studio.sh.

$ sudo unzip android-studio-ide-171.4408382-linux.zip -d /opt

$ /opt/android-studio/bin/studio.sh

Nachdem Sie Android Studio gestartet haben, können Sie über das Menü Tools → Create Desktop Entry ein Startsymbol auf dem Desktop erzeugen.

Die Entwicklungsumgebung einrichten

Wenn Sie Android Studio zum ersten Mal starten, werden Sie zunächst gefragt, ob Sie die Konfiguration aus einer früheren Installation übernehmen möchten. Wenn ja, können Sie hier das entsprechende Verzeichnis angeben.

Danach startet ein Assistent, der Sie in mehreren Schritten durch die Einrichtung von Android Studio führt. Im ersten Schritt werden Sie nach dem Typ der Installation gefragt. Wählen Sie hier der Einfachheit halber Standard aus, andernfalls können Sie selbst festlegen, wo die Dateien des SDK auf dem Rechner abgelegt werden. Unabhängig von Ihrer Entscheidung erscheint noch die Auswahl zwischen verschiedenen, teilweise vom Betriebssystem abhängigen Bildschirmoptiken, zwischen denen Sie sich frei entscheiden können.

Auf der letzten Seite bekommen Sie dann die Liste Ihrer Einstellungen präsentiert, die im Wesentlichen diverse herunterzuladende Komponenten aufzählt. Bestätigen Sie diese, beginnt ein längerer Prozess, in dem zahlreiche, zum Android SDK gehörende Pakete heruntergeladen, ausgepackt und abgespeichert werden.

Nach dem Abschluss dieses Vorgangs erscheint ein Startfenster, in dem Sie auswählen können, ob Sie ein neues Projekt beginnen, ein bestehendes Projekt öffnen oder irgendeine andere Aktion ausführen möchten (siehe Abbildung 2-1).

Abbildung 2-1: Startfenster von Android Studio

Pfade setzen

Nach der Installation des Android SDK ist es sinnvoll, die Pfade zu den Befehlszeilenwerkzeugen in die PATH-Umgebungsvariable aufzunehmen. Dies sind unter Windows normalerweise diese Verzeichnisse:

C:\Users\<user>\AppData\Local\Android\sdk\tools\bin

C:\Users\<user>\AppData\Local\Android\sdk\platform-tools

Unter Linux sind es diese:

~/Android/sdk/tools/bin

~/Android/sdk/platform-tools

Die Entwicklungsumgebung im Überblick

Die Android-Entwicklungsumgebung ist sehr umfangreich und enthält eine Fülle von Werkzeugen, mit denen Programmierung und Tests unterstützt werden. Die wichtigsten von ihnen sollen hier kurz vorgestellt werden.

Android Studio

Android Studio ist eine integrierte grafische Entwicklungsumgebung speziell für Android. Sie basiert auf der äußerst beliebten und weit entwickelten Java-Entwicklungsumgebung IntelliJ IDEA der Prager Firma JetBrains. Da JetBrains zugleich Schöpfer von Kotlin ist, findet man hier auch eine hervorragende Unterstützung für das Programmieren in dieser Sprache.

Android Studio ist praktisch die »zentrale Schaltstelle« für alle Aufgaben zur Realisierung eines Android-Projekts. Dazu gehören insbesondere die folgenden Features:

Eine einfache und übersichtliche Möglichkeit, zwischen den verschiedenen Dateien eines Android-Projekts zu navigieren.

Komfortable Editoren für die unterschiedlichen Arten von Dateien, die in der Android-Programmierung benötigt werden, darunter Java- und Kotlin-Quellprogramme, GUI-Layouts und andere spezifische XML-Dateien, Icons usw.

Automatische Prüfung der syntaktischen Korrektheit und der Gesamtkonsistenz während der Entwicklung.

Arbeitsoberflächen für alle wichtigen Android-Tools wie den Debugger, den Monitor usw.

Anbindung an bekannte Versionsverwaltungssysteme wie Git und Subversion.

Android Studio konfigurieren

Android Studio verfügt über umfangreiche Konfigurationsmöglichkeiten. Diese sind über das Menü File → Settings zu erreichen. Es lohnt sich, den ganzen verschachtelten Einstellungsdialog einmal durchzugehen, um einen Überblick darüber zu bekommen, an welchen Stellschrauben sich insgesamt drehen lässt.

Alternative Entwicklungsumgebungen

Anstelle von Android Studio können Sie im Prinzip auch eine andere Entwicklungsumgebung einsetzen, da sich das Android SDK unabhängig von Android Studio verwenden lässt. Dies kann sich unter Umständen anbieten, wenn die App-Programmierung innerhalb eines größeren Projekts eine untergeordnete Rolle spielt.

Folgende bekannte Java-Entwicklungsumgebungen bieten besondere Unterstützung für Android:

IntelliJ IDEA

mit dem Android-Plug-in bietet praktisch die gleichen Möglichkeiten wie Android Studio, was die Android-Entwicklung angeht, ist darüber hinaus aber auch für reine Java-(bzw. Kotlin-)Projekte geeignet.

Eclipse

mit dem

Andmore

-Plug-in, das eine Weiterentwicklung der früher offiziellen Eclipse-Erweiterung ADT (

Android Development Tools

) darstellt, jetzt aber nicht mehr von Google direkt unterstützt wird.

NetBeans

mit dem

NBAndroid

-Plug-in ist eine weitere Möglichkeit. Allerdings wird NBAndroid offenbar seit einigen Jahren nicht mehr weiterentwickelt, und diese Version dürfte nicht annähernd die Möglichkeiten von Android Studio (oder auch Eclipse-Andmore) bieten.

Sowohl für Eclipse als auch für NetBeans gibt es Kotlin-Plug-ins, die von der Firma JetBrains zur Verfügung gestellt werden, sodass auch auf diesen Umgebungen die Android-Programmierung mit Kotlin prinzipiell denkbar ist.

Das Android Software Development Kit (SDK)

Das Android SDK ist das Kernstück der Android-Entwicklungsumgebung. Es kann unabhängig von Android Studio heruntergeladen und verwendet werden und erlaubt damit den Einsatz in anderen IDEs und in Continuous-Integration-Werkzeugen wie Hudson oder Jenkins. Darüber hinaus umfasst es eine Reihe von zusätzlichen Befehlszeilenwerkzeugen zu Test- und Profilierungszwecken. Die folgenden Bestandteile des Android SDK lassen sich direkt aus Android Studio heraus aufrufen und steuern.

Wichtige zum SDK gehörende Tools, die sich über das Untermenü Tools → Android direkt aus Android Studio heraus aufrufen lassen, sind:

SDK Manager

– ein grafisches Werkzeug zum Herunterladen und Verwalten der Android-Werkzeuge und Plattformpakete in den benötigten Versionen.

AVD-Manager

– ein Werkzeug zum Erzeugen und Verwalten von System-Images für verschiedene Gerätekonfigurationen für den Android-Emulator.

Android Device Monitor

– ein Hilfsmittel zum Überwachen einer laufenden App im Emulator oder in einem angeschlossenen Gerät.

Viele weitere Tools werden indirekt über Gradle-Scripts aktiviert.

Gradle

Gradle ist ein in letzter Zeit sehr populär gewordenes integriertes Werkzeug für den automatischen Build von Softwarepaketen mit ähnlicher Funktionalität wie Make, Ant oder Maven, aber wesentlich flexibler. Die Build-Scripts werden nicht wie bei Ant oder Maven in XML formuliert, sondern in Groovy, einer Java-basierten Skriptsprache, die neben dem üblichen prozeduralen Code auch einen deklarativen Programmierstil erlaubt.

Gradle hat die Aufgabe, anhand projekt- und modulspezifischer Build-Scripts die komplexen Build-Prozesse für den Bau der zu einem Projekt gehörenden Artefakte zu organisieren. Allerdings wird der größte Teil der Arbeit in einem Gradle-Android-Plug-in ausgeführt, das beim Build automatisch mit geladen wird und die Details der verschiedenen Abläufe enthält. Die projekt- und modulbezogenen Skripte enthalten im Wesentlichen nur die jeweils benötigten spezifischen Konfigurationseinstellungen.

Android-Emulator

Um das Testen von Anwendungen zu erleichtern, verfügt das Android SDK über einen auf dem Open-Source-Tool QEMU (https://www.qemu.org/) basierenden Emulator für Android-Geräte, der verschiedene Gerätekonfigurationen mit diversen Android-Plattformen darstellen kann. Um ihn zu nutzen, legen Sie sich ein oder mehrere sogenannte virtuelle Geräte (Android Virtual Devices, AVDs) an. Mithilfe der als »AVDs« bezeichneten Konfigurationen kann der Emulator verschiedene Gerätetypen mit unterschiedlichen Android-Versionen darstellen.

Alternativ besteht aber auch die Möglichkeit, ein physisches Android-Gerät, z.B. ein Mobiltelefon oder einen Tablet-Computer, über ein USB-Kabel anzuschließen (siehe den Abschnitt »Starten und debuggen« auf Seite 57).

Die Oberfläche zur Verwaltung der AVDs öffnen Sie aus Android Studio über das Menü Tools → Android → AVD Manager oder den entsprechenden Button.

Standardmäßig legt der AVD-Manager im SDK-Unterverzeichnis avd ein Verzeichnis mit Konfigurations- und Image-Dateien sowie eine .ini-Datei für jedes virtuelle Gerät an.

Plattformpakete

Die Plattformpakete für verschiedene Android-Versionen ermöglichen es, Apps zu schreiben, die auch auf älteren Geräten installiert und betrieben werden können, und diese entsprechend zu testen. Dazu gehören jeweils die Java-Bibliotheken einschließlich JavaDoc-Dokumentationen sowie die entsprechenden System-Images für den Betrieb im Android-Emulator.

API-Erweiterungen

Zum Android SDK gehört eine Reihe von Java-Bibliotheken, die die Funktionen, die Sie über die in den Geräten installierten Plattform-APIs erreichen können, um zusätzlichen Funktionen erweitern und ein in Grenzen von den Plattformversionen unabhängiges Programmieren ermöglichen.

Die Erweiterungsbibliotheken werden im Laufe des Build-Prozesses automatisch über Maven-Repositories heruntergeladen und in das Projekt eingebunden. Zu diesem Zweck müssen sie im Gradle-Script des Projekts entsprechend benannt werden (siehe den Abschnitt »Die Build-Scripts für Gradle« auf Seite 43). Gradle kümmert sich dann auch darum, zusätzliche Pakete einzubinden, die in Folge von Abhängigkeiten zwischen den Paketen benötigt werden.

In der Regel ist es sinnvoll, die neueste Version einer Erweiterungsbibliothek einzubinden, damit sie auch Features neuerer Geräte und neuerer Plattformversionen berücksichtigen kann.

Im Anhang in den »API-Übersichten« finden Sie eine Liste der in den Erweiterungsbibliotheken enthaltenen Pakete einschließlich der jeweils zugehörigen Gradle-Script-Einträge.

Die Unterstützungsbibliothek

Die Android-Unterstützungsbibliothek (Support Library) bietet die Möglichkeit, auch auf älteren Android-Geräten Features zu nutzen, die in neueren Versionen von Android entwickelt worden sind. Außerdem enthält sie zusätzliche Funktionen, die auch in den aktuellen Plattformversionen noch nicht implementiert sind.

Die Unterstützungsbibliothek besteht aus einer Vielzahl von Paketen für unterschiedliche Funktionen. Diese unterscheiden sich darin, von welcher Android-Plattformversion aus sie verwendet werden können. So kann beispielsweise ein Paket mit dem Package-Namen android.support.v7 in Geräten genutzt werden, auf denen Android-Plattform 2.1 (API-Level 7) oder höher läuft. Die allermeisten Pakete setzen keine Plattformversionen höher als 4.0 (API-Level 14) voraus.

Typischerweise sind die einzelnen Features der Unterstützungsbibliothek auf drei unterschiedlichen Wegen implementiert: als Erweiterungen bestehender Klassen, als parallel implementierte Typen und als neue Typen.