Programmier Tutorial - Apps für Android entwickeln - Android App programmieren

Android Tutorial: Eigene Android App programmieren


Um eine eigene Android™ App programmieren zu können, benötigt ihr vor allem eins: Ausdauer!

Doch lohnt sich der Aufwand?

Ja, denn Gründe dafür gibt es viele! So kann man die App auf Google Play veröffentlichen mit dem Ziel etwas Geld damit zu verdienen, die App selbst nutzen oder sie mit Freunden teilen.

Egal warum ihr eine eigene Android App entwickeln wollt, hier findet ihr das richtige Android Tutorial.

In mehreren Lektionen führen wir euch Schritt für Schritt zur eigenen Android Anwendung.

Ihr lernt wie man eine Android App programmiert und welche Details bei der Entwicklung von Android Apps beachtet werden müssen, damit eure Anwendung fehlerfrei läuft.

Auf dieser Übersichtsseite stellen wir die einzelnen Lektionen des Android Programmier Tutorials vor. Wir empfehlen die Beschreibungen der einzelnen Lektionen zu lesen. Ihr könnt aber auch per Schnellzugriff direkt zur jeweiligen Tutorial Lektion springen.

Falls ihr an einer Stelle im Tutorial einmal nicht weiter kommt, dann hilft euch vielleicht dieses Dokument weiter: Hilfreiche Anmerkungen zum großen Android Tutorial. Das Dokument wurde von einem fleißigen Leser (Stormy) mit viel Aufwand erstellt und ist richtig gut geworden. Vielen Dank nochmals dafür!

Schnellzugriff auf die Lektionen des Android Tutorials


Warum ihr eure eigenen Android Anwendungen programmieren solltet?

Jeden Tag werden über eine Million Android Geräte aktiviert. Aktuell sind mehr als 1 Milliarde Android Smartphones, Handys, Tablets oder andere Geräte aktiviert.

Somit bietet Android großartige Gelegenheiten für Entwickler von mobilen Anwendungen. Android Anwendungen können in den verschiedensten Situationen Anwendung finden.

Die Verwendung auf Smartphones oder Tablets ist nur ein Einsatzgebiet von Android.

Das Betriebssystem läuft auf vielen anderen Geräten, wie Fernseher, Uhren, Brillen und Mini-PCs.

Kurz: Die Android App Entwicklung bietet gewaltige Chancen. Ihr könnt sie nutzen!

Was könnt ihr in dem Android App programmieren Tutorial lernen?

In diesem Android App programmieren Tutorial lernt ihr die Fähigkeiten eine komplexe und nützliche App für Smartphones und Tablets zu entwickeln. Das Erlernte könnt ihr aber auch für andere Anwendungsgebiete nutzen und seid somit gut gerüstet für zukünftige Möglichkeiten, die Android immer wieder bietet. Seht ihr eine Programmiergelegenheit, dann könnt ihr dazu die passende Android App erstellen.

Wir entwickeln zusammen eine Finanz-App mit der Entwicklungsumgebung Android Studio. Unsere Android App wird simulierte Finanzdaten von unserem Web-Server abfragen und anschließend die Finanzinformationen auf dem Display ausgeben.

In dem unteren Video ist zu sehen, wie die App AktieHQ Finanzdaten online abfragt:

Am Ende dieses Android Tutorials kennt ihr die Grundlagen der Android App Entwicklung, versteht die Prinzipien und Vorgehensweisen bei der Android App Programmierung und könnt die Entwicklungswerkzeuge gekonnt einsetzen. Ihr habt die größten Herausforderungen der Entwicklungen für mobile Geräte kennengelernt und habt sie gemeistert.

Ziel des Android Kurses ist es euch zu vermitteln wie man eine Android Anwendung entwickelt, die für die Benutzer ein großartige Erfahrung ist und dass ihr mit dem erlernten Wissen über die Android Programmierung gut gewappnet für eure eigenen Android Projekte seid.

Welche Vorkenntnisse und Voraussetzungen werden benötigt?

Da Android Apps in der Programmiersprache Java programmiert werden, ist es notwendig, dass ihr erste Erfahrungen mit Java oder einer objektorientierten Programmiersprache bereits gemacht habt.

In unserem Java-Kurs könnt ihr die Sprache Java lernen oder bereits erlangtes Wissen erneuern bzw. vertiefen.

In dem Android Tutorial verwenden wir Android Studio für die Entwicklung unserer App. Daher ist es notwendig, dass ihr Android Studio downloaded und auf eurem PC installiert.

Dadurch könnt ihr die einzelnen Lektionen des Android Kurses leichter verfolgen. Weiterhin ist es sehr hilfreich, wenn ihr ein Android Smartphone oder Tablet besitzt. Dies ist aber nicht unbedingt erforderlich, da die entwickelte Android App sowohl auf dem Android Gerät als auch auf dem Android Emulator getestet und ausgeführt werden kann.

Inhalt des Android App programmieren Kurses

Der Android App programmieren Kurs gliedert sich in einzelne Lektionen, in denen jeweils ein ganz bestimmtes Themengebiet der Android App Entwicklung und damit verwandte Themen behandelt werden.

Die Reihenfolge der Lektionen muss zwingend eingehalten werden, da die Android App von Lektion zu Lektion weiterentwickelt wird und nachfolgende Lektionen somit auf Vorherige aufbauen. Weiterhin bilden die drei ersten Lektionen die Grundlage des Tutorials und sollten unbedingt in Ruhe ausgeführt werden.

Lektion 1: Android Studio installieren

Android Studio Willkommensbildschirm

Android Studio Willkommensbildschirm

In der ersten Lektion unseres großen Android App entwickeln Tutorials werden wir die Installation von Android Studio ausführlich beschreiben.

In den späteren Kapiteln werden wir dann mit Hilfe von Android Studio eine eigene App programmieren. Die App nennen wir AktieHQ und sie ist eine Finanz-App.

In dieser Schritt für Schritt Anleitung werden wir zunächst prüfen, ob Java richtig eingerichtet ist (u.a. ob der Java-Path korrekt gesetzt ist).

Anschließend werden wir Android Studio installieren und die grundlegenden Einstellungen vornehmen, die für das Entwickeln eigener Apps notwendig sind. Für das Emulieren unserer Android App werden wir auch Intel HAXM installieren.

Für alle Leser, bei denen es nicht möglich ist Intel HAXM zu installieren bzw. zu verwenden, haben wir eine zusätzliche Lektion erstellt. Darin zeigen wir, wie man eine App im Android Emulator ohne Intel HAXM ausführt. Diese Lektion ist optional und nur relevant, wenn ihr HAXM nicht verwenden könnt.

Für die weiteren Lektionen unseres Android Tutorials werden wir mit exakt dieser Android Studio Installation arbeiten. Daher solltet ihr alle Schritte der Anleitung genau befolgen und keinen der Schritte auslassen.


Lektion 2: Neues Android Studio Projekt erstellen

In Lektion 2 unseres großen Android Anwendung entwickeln Tutorials werden wir unser erstes Android Studio Projekt erstellen. Dieses Projekt werden wir für die gesamte Tutorial-Serie verwenden und sollte daher exakt nach den in der Lektion genannten Vorgaben erstellt werden.

android studio project avd app

Unsere erste App wird auf dem AVD im Android Emulator ausgeführt

An den Projektdateien werden wir in Abschnitt 2 einige kleine Änderungen vornehmen und dadurch unser Projekt an die Zielplattform anpassen.

Danach erstellen wir ein AVD (Android Virtual Device), mit dessen Hilfe wir unsere App im Android Emulator ausführen und testen können.

In der Abbildung rechts ist die erste Version unserer Android App zu sehen. Sie wird im Android Emulator ausgeführt und aus Android Studio heraus gestartet.

Mit dem Emulator könnt ihr sehr effektiv eure eigene Android App schreiben. Damit das AVD in dem Android Emulator startet, muss Intel HAXM installiert sein. Daher sollten unbedingt alle Schritte aus Lektion 1 des Android Tutorials ausgeführt worden sein.

Lektion 3: Eigene Android App auf dem Handy installieren

In der dritten Lektion unseres großen Android Anwendung programmieren Tutorials werden wir unsere eigene Android App auf einem Smartphone installieren.

Die App werden wir auf ein Samsung Galaxy S4 mini Smartphone übertragen und anschließend auf dem Android Gerät ausführen.

Bisher haben wir unsere Android App nur auf dem Android Virtual Device (AVD) installiert und getestet. Das Testen der App auf einem AVD ist sehr hilfreich, kann aber das Testen auf einem physikalischen Android Gerät nicht ersetzen. Außerdem sind einige Android Funktionen nur auf einem Smartphone (Handy) oder Tablet verfügbar.

Damit die App auf das Android Gerät übertragen werden kann, müssen die Entwickleroptionen aktiviert werden. Die folgende Grafik zeigt wie dies funktioniert:

Android Entwickleroptionen aktivieren

Android Entwickleroptionen aktivieren – Anleitung für Samsung Galaxy S4 mini

Die Kommunikation mit Android Virtual Devices und angeschlossenen realen Android Geräten wird von der Android Debug Bridge erledigt. Über die ADB können wir unsere selbst erstellten Android Apps auf ein Android Gerät übertragen und installieren. Dies kann direkt aus Android Studio heraus oder über die Kommandozeile erfolgen.

Weiterhin zeigen wir in Lektion 3 wie die Entwicklungsumgebung (Android Studio) und das Android Gerät eingerichtet werden müssen, damit die eigene App auf dem Android-betriebenen Gerät getestet und debugged werden kann. Das Debugging ist ein wichtiges Werkzeug, dass sehr beim Schreiben der eigenen Android App hilft.

Lektion 4: Daten mit einem ListView anzeigen

android app smartphone

Unsere App mit dem ListView und Aktiendaten zum Test auf dem Smartphone

In der vierten Lektion unseres großen Android App entwickeln Tutorials werden wir unsere eigene Android App um einen ListView erweitern. Mit dem ListView werden wir den Nutzern unserer App die Online-Finanzdaten anzeigen.

Mit einem Listview lassen sich große und komplexe Listen sehr effizient und benutzerfreundlich darstellen. Die Listen sind scrollbar und registrieren Benutzereingaben.

In diesem frühen Teil der Android Tutorial-Serie werden wir als Aktiendaten nur Testdaten (mock data) verwenden und keine echten Finanzdaten. Die Daten speichern wir in einer ArrayList und geben diese Liste an den ListView weiter.

Dazu werden wir die folgenden Schritte ausführen:

  • Haupt-Layout eines Fragments in Android definieren
  • Anlegen eines Layouts für die Listenelemente
  • Erzeugen der Beispieldaten (mock data)
  • Erstellen eines ArrayAdapters und Hinzufügen der Beispieldaten
  • Erstellen des ListViews und Zuweisen des ArrayAdapters und Layouts
  • Ausführen unserer Android App auf dem Smartphone, Tablet und im Emulator

Lektion 5: Refactoring und Logging in Android Studio

In Lektion fünf unseres großen Android Tutorials werden wir den Projektordner unserer Android App etwas aufräumen. Dazu verwenden wir das Refactoring-Werkzeug von Android Studio. Wir werden die Klasse MainActivityFragment umbenennen und auch die zugehörige Layout-Datei.

Weiterhin werden wir das Logging System von Android vorstellen und die sechs Logging-Level näher beleuchten. Für die Entwicklung von Android Anwendungen ist das Ausgeben von Status- und Fehlermeldungen unverzichtbar. Daher werden wir Logging Meldungen beispielhaft in unsere App einfügen.

Die folgende Abbildung zeigt den Dalvik Debug Monitor Server (DDMS) von Android Studio:

android ddms 3

Log-Meldungen eines vorgegebenen Meldungs-Tag (Tag) herausfiltern

Das Android Logging System ermöglicht uns System Debug Ausgaben zu betrachten und auch zu sammeln.

Die Log-Meldungen der Android Anwendungen und des Systems selbst werden in Ringpuffern gespeichert und können mit Hilfe des logcat-Befehls betrachtet und gefiltert werden.

Die Log-Buffer von Android können auf zwei Arten ausgelesen werden:

  • Über die Konsole mit dem Android Debug Bridge (ADB) Befehl: adb logcat
  • Mit Hilfe des Dalvik Debug Monitor Server (DDMS) in Android Studio

Wir werden in Lektion 5 beide Logging-Arten vorstellen und euch somit die Wahl überlassen, welche Art für euch die Passende ist.

Lektion 6: Options Menu und Action Bar in Android

In der sechsten Lektion unseres großen Android Tutorials werden wir das Options Menu von Android vorstellen und einen Menüeintrag in die Android Action Bar einfügen.

Der Menüeintrag wird anklickbar sein und uns eine kleine Statusmeldung (Toast) auf dem Display ausgeben. Den Button werden wir später nutzen, um simulierte Online-Finanzdaten bei unserem Web-Server abzufragen.

app android menu

Ausführen unserer Android App und Testen des Options Menu

Um in unsere Android App einen neuen Menüeintrag einzufügen, müssen wir als ersten Schritt eine XML-Layout Datei für das Menü erstellen. In dieser XML Datei wird das neue Menüelement definiert.

Anschließend wird dem Menüelement (Menu Item) eine Bezeichnung zugewiesen. Dazu wird die strings.xml Datei von uns entsprechend angepasst.

Damit unser Menüeintrag auch in unserer Android Anwendung angezeigt wird, muss das neue Menü in dem Fragment bekanntgegeben werden. Dazu werden wir die Datei AktienlisteFragment.java um die Methoden onCreate, onCreateOptionsMenu und onOptionsItemSelected erweitern.

Lektion 7: Hintergrund-Thread in Android mit AsyncTask

In Lektion 7 unseres großen Android App entwickeln Tutorials wird es technisch. Wir werden einen asynchronen Task in unsere App integrieren und mit diesem eine Hintergrundberechnung durchführen. Dazu steigen wir tiefer in die Themen Prozesse und Threads von Android ein.

Der erstellte AsyncTask wird später die Online-Aktiendaten abfragen und in ein, für unsere Android Anwendung, nutzbares Format umwandeln. Dies muss immer asynchron in einem Nebenthread erfolgen, da die Bedienbarkeit der Anwendung stets gewährleistet sein muss.

Würde bspw. eine längere Berechnung im Hauptthread ausgeführt werden, wäre dadurch die App nicht mehr in der Lage auf Benutzereingaben zu reagieren. Dies kann sogar zu einer Application not responding-Meldung führen.

Daher sollten beim Umgang mit Threads zwei einfache Regeln stets befolgt werden:

  1. Niemals den UI-Thread (Main-Thread) blockieren.
  2. Niemals auf das Android User Interface Toolkit außerhalb vom UI-Thread zugreifen.

Die folgende Abbildung zeigt wie unsere App die Beispieldaten mit Hilfe des asynchronen Tasks lädt:

android asynctask

Der asynchrone Task lädt im Hintergrund die Beispieldaten und informiert über den Fortschritt

Natürlich sind die angezeigten Finanzdaten bisher noch Beispieldaten. Wir kommen den echten Online-Finanzdaten aber immer näher. Mit dem hier getesteten asynchronen Task können wir in der nächsten Lektion des Android Tutorials die Online-Aktiendaten anfragen.

Mit dem Wissen über asynchrone Tasks könnt ihr eigene Android Apps erstellen, die auch mehr als einen Nebenthread besitzt.

Lektion 8: Daten von einer Webseite abfragen in Android

In der achten Lektion unseres großen Android Anwendung entwickeln Tutorials werden wir unsere App mit dem Internet verbinden.

android ddms log

Anfrage-String und erhaltene XML Aktiendaten in DDMS betrachten

Über die Internetverbindung fragen wir die simulierten Online-Finanzdaten bei unserem Web-Server ab und speichern die erhaltenen Daten in einem String im XML-Format.

Zur Kontrolle geben wir den Inhalt des Strings als Log-Meldung aus. Später werden wir den XML-String auslesen und bestimmte Aktiendaten in der App anzeigen.

Die Abfrage über das Internet muss in einem asynchronen Task ausgeführt werden, dies wird von Android so verlangt.

Daher haben wir in der vorherigen Lektion den asynchronen Task HoleDatenTask definiert und implementiert. Er ist unser Hintergrund-Thread, mit dem wir das HTTP-Request durchführen.

Bevor aber von unserer App aus auf das Internet zugegriffen werden kann, müssen wir von Android bzw. dem Benutzer die Erlaubnis für den Zugriff einholen. Dieser Schritt ist sehr einfach und erfordert nur eine kleine Änderung in der AndroidManifest.xml Datei. Der Freigabeprozess ist auch für andere Zugriffsarten gleich, so dass ihr ihn verwenden könnt, wenn ihr eine weitere Android App erstellen möchtet.

Unser Vorgehen in dieser Lektion des Android Tutorials wird wie folgt sein:

  1. Vorstellen, wie wir die Finanzdaten abfragen werden
  2. Erlaubnis für den Internetzugriff in Android einholen
  3. Online Anfrage nach den Finanzdaten in dem asynchronen Task HoleDatenTask
  4. Testen unserer Android App und Kontrollieren des Aktiendaten-Strings in der Log-Meldung

Lektion 9: XML-Daten auslesen und anzeigen in Android

In Lektion 9 unseres großen Android Anwendung programmieren Tutorials werden wir den String, der die XML-Finanzdaten enthält, auslesen. Die, für uns interessanten, XML-Finanzinformationen werden wir dabei in einem StringArray speichern und anschließend auf dem Android Gerät ausgeben.

Zu Beginn der neunten Lektion werden wir das XML-Datenformat kurz vorstellen und auf die Besonderheiten der Extensible Markup Language (XML) eingehen.

Anschließend werden wir das XML-Format der Online-Aktiendaten analysieren und die, für uns relevanten, Finanzinformationen auswählen.



Danach erweitern wir unsere bisherige Android App um die Fähigkeit XML-Daten auszulesen. Als Datenquelle greifen wir auf die Online-Aktiendaten zurück, die in einem String im XML-Format abgelegt sind.

Die ausgelesenen Finanzinformationen speichern wir dann in einem StringArray und geben sie anschließend auf dem Android Smartphone oder Tablet aus.

app android xml

Mit einem Klick auf Aktualisieren werden echte Online-Aktiendaten aus dem Internet geladen

Mit der neunten Lektion unseres großen Android App programmieren Tutorials haben wir einen großen Schritt gemacht.

Unsere Anwendung liefert echte Online-Finanzdaten und erfüllt somit eine nützliche Funktion. Von dieser Entwicklungsstufe ausgehend, können wir unsere App jetzt nach unseren Vorstellungen gestalten und dadurch die Benutzerfreundlichkeit deutlich erhöhen.

Lektion 10: Activities und Intents in Android

Im zehnten Teil unseres großen Android App entwickeln Tutorials werden wir unsere App AktieHQ um eine zusätzliche neue Bildschirmseite (Activity) erweitern.

Mit Hilfe der neuen Activity werden wir detaillierte Finanzinformationen zu einem bestimmten Element des ListViews, welcher Aktienliste darstellt, anzeigen.

Die neue Activity werden wir mit Hilfe des Android Intent Mechanismus starten.

Dazu beantworten wir die Fragen:

  • Was sind Activities in Android?
  • Was ist ein Intent in Android?
  • Wie startet man eine Activity in Android?

In Android besitzen Intents eine sehr große Bedeutung und bestimmen wie auf Eingaben des Benutzers reagiert werden soll. Also welche Activity (Bildschirmseite) gestartet werden soll und welche Daten dabei an diese übermittelt werden.

In der zehnten Lektion dieses Android Tutorials tauchen wir in dieses spannende Thema ein und programmieren unseren ersten “Intent”.

android intent activity

Wird ein ListView-Element angeklickt, starten wir mit einem Intent eine neue Activity

Weiterhin behandeln wir in Lektion 10 das Reagieren auf Benutzereingaben. Dazu registrieren wir einen OnItemClickListener für den ListView unserer Android Anwendung. Wir verwenden den ClickListener zum Starten der neuen Activity, sobald der Benutzer auf einen Listenelement klickt.

Die Informationen über das angeklickte Listenelement geben wir mit Hilfe eines Intents an die aufgerufene Activity weiter. Dadurch können wir die angeklickten Aktiendetails auf der neuen Bildschirmseite anzeigen.

Lektion 11: Settings, Preferences und Einstellungen in Android

Im elften Teil unseres großen Android App programmieren Tutorials werden wir unserer App AktieHQ einen Einstellungen-Bildschirm (Settings-Activity) hinzufügen. Unsere Android App wird zwei Einstellungsoptionen (Preferences) erhalten.

In der Lektion erklären wir was Settings und Preferences in Android sind und wie einfach diese in eine Android Anwendung eingebunden werden können.

Dazu legen wir die neue Activity EinstellungenActivity an und definieren für diese zwei Preferences (list of settings) in der XML-Datei preferences.xml. Anschließend laden wir das Preference-Layout aus dieser Datei in die Settings-Activity.

Damit unsere Android App auf Einstellungsänderungen der Benutzer reagiert, registrieren wir für die Preferences einen OnPreferenceChangeListener. Die aktuellen, vom User festgelegten, Werte der Einstellungen lesen wir aus den SharedPreferences aus und verwenden sie als Parameter für die Anfrage der Online-Finanzdaten.

Die folgende Abbildung zeigt den aktuellen Entwicklungsstand unserer Android App und wie die Einstellungen in die Anwendung integriert wurden:

android preference checkbox

Die neue Preference (CheckBoxPreference) wird in der EinstellungenActivity angezeigt

In dem Bild sind beide Einstellungen zu sehen, die EditTextPreference und die CheckBoxPreference. Mit der Ersten legen wir die individuelle Aktienliste fest, für die Finanzinformationen ausgegeben werden sollen. Mit der Zweiten wechseln wir zwischen der individuellen Aktienliste und einer vordefinierten Indizeliste.

Lektion 12: Mit impliziten Intent andere App starten in Android

Im zwölften Teil unseres großen Android App programmieren Tutorials werden wir unsere Android Anwendung um eine Web-Funktionalität erweitern. Unsere Finanz-App soll in der Lage sein, zu dem ausgewählten Finanzinstrument weiterführende Informationen in einer Web-Browsing App anzuzeigen.

Die Web-Funktionalität werden wir nicht selbst programmieren, sondern stattdessen auf die Funktionen einer anderen Web-App zugreifen. Dazu verwenden wir einen impliziten VIEW-Intent, mit dem wir die andere Android App starten werden.

An unserem Android Projekt nehmen wir folgenden Erweiterungen vor:

  • Hinzufügen eines weiteren Menüeintrag im Options Menu der AktiendetailActivity
  • Erstellen des impliziten Intents und Anfügen der notwendigen Daten
  • Starten einer anderen App mit Hilfe des impliziten Intents

Der implizite Intent wird als Aktion eine ACTION_VIEW und als hinterlegte Daten die Data URI der aufzurufenden Webseite besitzen. Anhand dieser Informationen ist das Android System in der Lage die passende Web-App zu finden und auszuführen.

Die untere Abbildung zeigt wie mit dem neuen Menüeintrag mittels impliziten Intent eine andere Web-App gestartet wird und diese für uns das ausgewählte Finanzinstrument in einem Browser anzeigt:

android impliziter intent

Mit einem Klick auf den Menüeintrag “Mehr Infos anzeigen” wird per impliziten Intent eine Web-App gestartet

Neben dem praktischen Teil, beschäftigen wir uns in der zwölften Lektion des Android Tutorials auch ausgiebig mit der Theorie zu dem spannenden Thema Implizite Intents in Android. Wir erklären was implizite Intents sind und stellen einige der bekanntesten impliziten Intents vor.

Lektion 13: Der ShareActionProvider in Android

Im dreizehnten Teil unseres großen Android Tutorials erweitern wir unsere Android Anwendung um einen ShareActionProvider. Damit ist unsere Finanz-App in der Lage eigene Inhalte mit anderen Anwendungen zu teilen.

Mit der Einführung des ShareActionProviders in Android 4.0 (API Level 14) ist es sehr einfach möglich, eine effektive und benutzerfreundliche Share-Funktion in die Action Bar der eigenen Android App zu integrieren.

Dank der Android Support Library können wir den ShareActionProvider auch für frühere Android-Versionen nutzen.

Der Provider nutzt ein ACTION_SEND Intent und adressiert diesen an jede App, welche die entsprechende Aktion ausführen kann. Dabei wird der zu teilende Inhalt als EXTRA dem Intent hinzugefügt, entweder als Text, eine URI oder Binärdaten.

In dieser Lektion werden wir zunächst im Theorie-Teil auf die Grundlagen des ShareActionProviders ausführlich eingehen.

Anschließend fügen wir unserer App den ShareActionProvider hinzu.

Die Share-Aktion werden wir über einen weiteren Menüeintrag der AktiendetailActivity ausführen.

Als Inhalt werden die angezeigten Finanzinformationen über den ShareActionProvider andere Apps zur Verfügung gestellt.

Die untere Abbildung zeigt wie mit dem neuen Menüeintrag mittels ShareActionProvider eine andere Share-App gestartet wird und dieser das angezeigte Finanzinstrument übermitteln:

android ShareActionProvider

Mit einem Klick auf den Share-Menüeintrag wird mit Hilfe des ShareActionProviders der Aktienkurs geteilt

Nachdem die aufgerufene Anwendung den Share-Vorgang abgeschlossen hat, landen wir wieder zurück in unseren eigenen Android App.

Lektion 14: Daten neu laden mit dem SwipeRefreshLayout in Android

Im vierzehnten Teil unseres großen Android Tutorials werden wir unserer Finanz-App ein SwipeRefreshLayout hinzufügen und dadurch per Swipe Down-Geste die Aktiendaten aktualisieren (refresh) lassen.

Mit einem SwipeRefreshLayout können wir unserer Android App sehr einfach das Swipe to Refresh UI-Pattern hinzufügen. Dieses erkennt selbständig die Swipe Down-Geste (Nach Unten-Wischen) und führt anschließend das Aktualisieren des verknüpften Inhalts durch.

In dieser Lektion werden wir zunächst im Theorie-Teil auf die Grundlagen des SwipeRefreshLayouts ausführlich eingehen.

Anschließend führen wir etwas Refactoring an unserem Android Projekt durch und lagern den Aktualisieren-Code in die neue Methode aktualisiereDaten() aus.

Danach fügen wir das SwipeRefreshLayout in die Layout-Datei des AktienlisteFragments ein und weisen ihm eine ID zu. Mit der Methode findViewById() werden wir dann später nach dem View-Element suchen.

Als letzten Schritt registrieren wir für das SwipeRefreshLayout einen OnRefreshListener, indem wir das Interface SwipeRefreshLayout.OnRefreshListener implementieren. Dadurch ist unsere Android Anwendung in der Lage die im ListView hinterlegten Daten per Swipe Down-Geste zu aktualisieren.

Die untere Abbildung zeigt wie unsere App mittels SwipeRefreshLayout die Aktienliste neu lädt:

swiperefreshlayout android app

Das SwipeRefreshLayout erkennt die Swipe Down-Geste und aktualisiert den ListView

Das Aktualisieren der Daten wird im Hintergrund durch den asynchronen Task HoleDatenTask ausgeführt.

Lektion 15: Der Activity und Fragment Lifecycle in Android

Im fünfzehnten Teil unseres großen Android App Tutorials werden wir ein UI-Problem unserer Finanz-App beheben. Bisher gehen die angezeigten Aktiendaten bei einer Bildschirmdrehung verloren. Dies liegt an dem Activity und Fragment Lebenszyklus von Android.

Bei einer Bildschirmrotation erzwingt das Android System die Zerstörung und anschließende Wiederherstellung der UI-Elemente. Dadurch wird die Instanz des AktienlisteFragments zerstört und wieder neu erstellt. Dabei gehen alle Aktiendaten verloren. Diese Problem werden wir in Lektion 15 beheben.

In dieser Lektion werden wir zunächst im Theorie-Teil auf die Grundlagen des Activity Lifecycles ausführlich eingehen.

Anschließend implementieren wir die Lifecycle-Callbacks in der MainActivity unserer App und analysieren den Log-Output, um ein besseres Verständnis vom Lebenszyklus zu erlangen.

Danach behandeln wir die Theorie des Fragment Lifecycles in Android und implementieren die entsprechenden Lifecycle-Callbacks in dem AktienlisteFragment unserer Anwendung. Auch diesmal analysieren wir die Log-Meldungen in Android Studio.

Als Nächstes besprechen wir, wie in Android der Zustand von Fragmenten und Activities gespeichert und wiederhergestellt werden kann. Anschließend implementieren wir die onSaveInstanceState() Methode der AktienlisteFragment-Klasse und speichern damit den Fragment-Zustand und somit die angezeigten Aktiendaten. Von nun an kann unsere Android App auch bei einer Bildschirmdrehung die Daten beibehalten.

Die untere Abbildung zeigt wie sich unsere App bei einer Bildschirmdrehung verhält:

android lifecycle rotation

Die Finanz-App kann jetzt auch bei einer Bildschirmrotation die Aktiendaten beibehalten

Im letzten Abschnitt dieser Lektion ändern wir das Startverhalten unserer MainActivity von standard auf singleTop ab. Dadurch bleiben die Aktiendaten auch bei einer Navigation mittels Up-Button erhalten.

Die untere Abbildung zeigt wie sich unsere App bei einer Up-Navigation verhält:

android lifecycle up button

Die Finanz-App kann jetzt auch bei der Up-Navigation die Aktiendaten beibehalten

Damit schließen wir diese große Lektion ab, in der wir, neben dem Lebenszyklus von Activities und Fragmenten, auch eine Menge über das Speichern und Wiederherstellen des UI-Zustands gelernt haben.


Comments 15

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

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

  3. Fritz

    Die beste deutschsprachige Beschreibung, die ich bisher im Netz finden konnte.

    Bevor man mit dem Installieren anfängt, sollte man prüfen ob der verwendete Prozessor z.B. VT (Intel) unterstützt.

    Hab das leider erst bemerkt als ich die haxm.msi starten wollte. Bis dahin konnte ich alles einwandfrei nach dieser Anleitung durchführen.
    Bleibt mir jetzt nicht anderes übrig als ein Board mit den entsprechenden Prozessoreigenschaften zu kaufen.

    Das Tool für Intel findet sich hier:
    https://downloadcenter.intel.com/download/7838/Intel-Processor-Identification-Utility-Windows-Version

    1. Post
      Author
      Chris

      Hallo Fritz,

      danke für das Lob!

      Wenn man ein Android Gerät besitzt und mit dem PC verbindet, kann man die App auch darauf sehr gut testen.

      Viele Grüße, Chris

      1. Mathias

        Hallo,
        Android-Handy einfach per USB-Kabel mit dem Rechner verbinden ?
        Kannst du das etwas genauer beschreiben?

        Vielen Dank im voraus und großes Lob für alles das was ich bisher hier gelesen habe,

        Grüße
        Mathias

        1. Post
          Author
          Chris

          Hallo Mathias,

          danke für das Lob! Das Verbinden von Android Geräten (Smartphones oder Tablets) ist von Hersteller zu Hersteller unterschiedlich.

          In dem Beitrag: Eigene Android App auf dem Handy installieren habe wir gezeigt, wie das Verbinden mit einem Samsung Galaxy S4 mini Smartphone ausgeführt wird.

          Bei Deinem Android Gerät sollte es ähnlich sein, jedoch könnte ein anderer Treiber für das Erkennen des Android Geräts notwendig sein. Die meisten Hersteller geben Hinweise für das Verbinden mit dem PC in ihrer Anleitung an. Hat die Verbindung mit dem PC geklappt, dann ist der nächste Schritt die Verbindung des Geräts mit Android Studio über die Android Debug Bridge herzustellen. Wie das geht, haben wir auch im verlinkten Beitrag dargestellt.

          Viele Grüße, Chris

  4. Pingback: App auf AVD im Android Emulator ohne Intel HAXM ausführen

  5. Pingback: Android SQLite Tutorial - Teil 1: SQLite Projekt anlegen

  6. Pingback: Android SQLite Tutorial - Teil 2: SQLite Datenbank integrieren

  7. Alexander Chou

    ich war 1 programmier von andere sprache. wieviel zeit braucht man das zu lernen (durschschnittlich),
    wieviel kostet? danke

    1. Post
      Author
      Chris

      Hallo Alexander Chou,

      für die Android Programmierung sind gute Kenntnisse der Programmiersprache Java erforderlich. Also muss man zwei Technologien lernen: Java und das Android System. Ich schätze, dass man innerhalb von 2 Jahren ein guter Android Programmierer werden kann, wenn man mit viel Fleiß und Interesse an der Sache dran bleibt.

      Wenn man sich Android selbst beibringt, sind die Kosten sehr gering (Android Device, Literatur). Die Teilnahme an Android Schulungen kostet meist über 1000 Euro. Die Schulungen dauern mehrere Tage an. Die Zeit ist ausreichend, um einen Überblick über die Android Programmierung zu erhalten, nicht aber um Android selbst programmieren zu können. Als Einstieg OK, aber das wirkliche Lernen liegt im eigenen Programmieren danach.

      Viele Grüße, Chris

  8. Pingback: Android Tutorial: Android Studio 2 installieren und einrichten

  9. Rüdiger

    Hallo,
    (noch) habe ich keinen Plan vom Programmieren, aber alles kann man lernen und das werde ich, auch wenn ich bereits 48 bin.

    Mich würde es interessieren, ob es Möglichkeiten gibt, eine APK zu dekompilieren um dann an dieser Änderungen vorzunehmen.
    Dass dies nicht unbedingt legal ist, ist mir klar, aber es wäre für private Zwecke und man könnte sich ja auch die Erlaubnis beim Entwickler einholen.

    Noch habe ich die sehr umfangreiche Anleitung nur überflogen, aber es macht einen sehr guten Eindruck.

    Vielen Dank!

    1. Post
      Author
      Chris

      Hallo Rüdiger,

      um an den Quellcode einer App zu kommen, muss die APK-Datei dekompiliert werden. Es gibt einige Tools die das Dekompilieren der APK-Datei sehr einfach durchführen. Anschließend kann man den Quellcode betrachten. Dieser kann jedoch vorher, beim Kompilieren, absichtlich verkompliziert worden sein, damit er nur noch schwer nachvollzogen werden kann. Einfach mal “apk dekompilieren” googeln, da finden sich gute Anleitungen.

      Viele Grüße, Chris

  10. Pingback: Android App Programmierung - Tools, Tutorials und Tipps - Technik und Finanzen

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *