Programmier Tutorial - Apps für Android entwickeln - Android Studio Projekt erstellen und einrichten

Programmier Tutorial: Apps für Android entwickeln – Teil 2: Neues Android Studio Projekt erstellen


Im zweiten Teil unseres großen Android™ 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 unten genannten Vorgaben erstellt werden.

Nachdem das Android Projekt von Android Studio generiert wurde, werden wir zur Projekt-Ansicht wechseln und anschließend weitere Ordner und Dateien für unser Projekt anlegen. Außerdem werden wir bereits vorhandene Dateien überarbeiten und an unsere Bedürfnisse anpassen.

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

Damit das AVD in dem Android Emulator startet, muss der Intel HAXM installiert sein. Daher sollten unbedingt alle Schritte aus dem Android Tutorial Teil 1: Android Studio installieren ausgeführt worden sein.

Sollte der Intel HAXM nicht auf eurem System laufen, könnt ihr im Android Emulator ein AVD ohne Hardware Beschleunigung ausführen. Wie das geht, zeigen wir in dem Beitrag: App auf Android Virtual Device im Android Emulator ohne Intel HAXM ausführen.

Nun wünschen wir euch viel Spaß bei dem zweiten Teil unseres großen Android Tutorials. Los geht’s!


1. Android Studio Projekt erstellen

In diesem Abschnitt werden wir unser erstes Android Studio Projekt erstellen. Dazu navigieren wir zum Willkommensbildschirm von Android Studio.

Wir werden den New Project-Wizard für das Erstellen unseres Android Projekts nutzen.

Der Wizard ist ein Hilfsdialog, der uns durch den Erstellungsprozess unseres Projekts führt und uns die benötigten Einstellungen vornehmen lässt.

Der Erstellungsprozess besteht aus den folgenden vier einfachen Arbeitsschritten und dauert nur einen kleinen Moment.

Schritt 1: Mit einem Klick auf Start a new Android Studio project starten wir den New Project-Dialog, der uns durch die Erstellung eines neuen Android Projekts führt

android studio project new

Schritt 1: Klick auf “Start a new Android Studio project” im Willkommensbildschirm von Android Studio

Schritt 2a: Der New Project-Dialog erscheint, in dem wir Einstellungen für unser Projekt vornehmen können. Zuerst geben wir als Application name AktieHQ und als Company Domain die eigene Webseite (z.B. programmierenlernenhq.de) an. Danach klicken wir auf Edit rechts am Rand in blauer Schrift.

android studio project name

Schritt 2a: Details über das neue Android Studio Projekt angeben

Schritt 2b: Nachdem wir auf Edit geklickt haben, können wir den Eintrag unter Package name anpassen. Wir fügen dazu an den generierten Namen einfach .app an. Danach klicken wir auf Done und auf Next.

android studio project package

Schritt 2b: Package name anpassen

Schritt 3: Als nächsten Schritt geben wir den Minimum SDK vor. Der Minimum SDK legt fest, welche Android-Version mindestens auf dem mobilen Gerät installiert sein muss, damit unsere App darauf läuft. Wir wählen API10: Android 2.3.3 (Gingerbread) aus und klicken anschließend auf Next.

android studio project minsdk

Schritt 3: Minimum-SDK für unsere App angeben

Schritt 4: Als letzten Schritt legen wir den grundsätzlichen Aufbau unserer App fest. Dazu wählen wir die erste Option Add No Activity aus, wodurch ein leeres Android Projekt angelegt wird. Mit einem Klick auf Finish schließen wir den Erstellungsprozess ab und lassen unser neues Projekt von Android Studio automatisch generieren.

android studio project no activity

Schritt 4: Die Android Projektdateien generieren lassen, dazu Add No Activity auswählen

2. Darstellung der Projektstruktur in Android Studio ändern

Unser Android Studio Projekt sollte nun von der Entwicklungsumgebung nach unseren Vorgaben generiert werden.

Dieser Vorgang nimmt einige Zeit in Anspruch und sollte auf keinen Fall unterbrochen werden.

Manchmal werden Zwischenmeldungen eingeblendet und informieren über den aktuellen Fortschritt.

Nachdem das Projekt generiert wurde, sollte sich Android Studio komplett geladen haben.

Abbildungen vergrößern
Um die Schritte in diesem Abschnitt besser ausführen zu können, ist es manchmal erforderlich die Abbildungen zu vergrößern. Klickt dazu einfach auf das jeweilige Bild. Ihr werdet dann die, von uns in den Bildern eingefügten, Markierungen und Anweisungen besser lesen können.

2.1 Zur Projekt-Ansicht von Android Studio wechseln

Nachdem das Projekt von Android Studio erstellt wurde, sollten wir folgenden Bildschirm sehen:

android studio project first start

Unser Android Projekt unmittelbar nachdem die Projektdateien generiert wurden

Nun wechseln wir als Nächstes in den Project-View (Projekt-Ansicht) von Android Studio. Dazu führen wir die folgenden Schritte aus:

  1. Mit der Maus auf den Menüeintrag View in der oberen Menüleiste klicken.
  2. Anschließend auf Tool Windows klicken.
  3. Und schließlich auf Project klicken, um die Projekt-Ansicht zu öffnen.
android studio project project view

Zur Projekt-Ansicht (Project-View) von Android Studio wechseln

Danach werden wir die Darstellung der Projektstruktur ändern. Wir klicken dazu auf das Element Android oben links über der Baumstruktur. Zur Verdeutlichung haben wir einen roten Rahmen über das Android-Element gelegt und diesen mit 1 markiert.

Nachdem wir auf Android geklickt haben, öffnet sich ein Kontext-Menü. Hier klicken wir auf den ersten Eintrag Project und haben damit die Darstellung der Projektstruktur auf den Project-View umgestellt.

android studio project view change

Zur Projekt-Ansicht von Android Studio wechseln

Nun klappen wir den Eintrag app wie in der folgenden Abbildung auf:

android studio project important files

Wichtige Dateien unseres Android Studio Projekts

Wir sehen in der oberen Abbildung drei wichtige Dateien (wobei eine davon ein Package ist, um genau zu sein) unseres Android Projekts:

  • Das Package (A) – Das Package unseres Projekts. Hier legen wir in späteren Teilen des Android Tutorials die Klassendateien ab. Es wird sich dabei um Activity- und Fragment-Klassen handeln.
  • Das Manifest (B) – Die AndroidManifest.xml Datei werden wir im Laufe des Android Tutorials immer wieder erweitern. Sie ist die Schaltzentrale unserer Android App.
  • Die Gradle-Datei (C) – In der build.gradle Datei werden die wichtigen Einstellungen für den Erstellungsprozess unserer Android App verwaltet. Hierin befinden sich Angaben über die Zielplattform (targetSdkVersion), für die entwickelt werden soll, und die Minimalplattform (minSdkVersion), bis zu welcher unsere Android App kompatibel sein soll.

Wir werden nun in den nächsten Abschnitten Ressourcen-Ordner und Ressourcen-Dateien erstellen, die wir für die weiteren Teile des Android Tutorials benötigen werden. Sie bilden die Grundlage unserer Android App.

Es werden einige dieser Ordner und Dateien sein. Aber keine Angst, wir werden sie der Reihe nach schrittweise anlegen. Die dafür notwendigen Arbeitsschritte sollten unbedingt wie beschrieben ausgeführt werden, da spätere Teile des Tutorials auf diesen Dateien und Ordnern aufbauen.

Am Ende dieser Lektion sollte eure Projektstruktur wie in der unteren Abbildung dargestellt aussehen:

android studio project important files all

Alle wichtigen Dateien unseres Android Studio Projekts am Ende dieser Lektion

Um dahin zu gelangen, werden wir nun die oben dargestellten Ordner und Dateien erstellen und die violett markierten Dateien überarbeiten.

3. Dateien des values-Ordner anpassen

In diesem Abschnitt werden wir die Dateien des values-Ordners überarbeiten und an unsere Anforderungen anpassen. Dazu werden wir die folgenden Arbeitsschritte ausführen:

  1. Die Datei styles.xml anpassen – In der styles.xml Datei wird das allgemeine Aussehen unserer Android App definiert. Wir werden in dieser Datei einige Zeilen löschen, damit wir die Datei colors.xml nicht mehr benötigen.
  2. Die Datei colors.xml löschen – In dieser Datei werden die Farben der Android App definiert, so dass darauf global zugegriffen werden kann. Wir benötigen für dieses Android Tutorial die colors.xml Datei nicht und löschen sie daher.
  3. Zwei Konstanten in der Datei strings.xml anlegen – In der strings.xml sind alle String-Konstanten unserer App definiert. Dadurch kann die Android App leicht in andere Sprachen lokalisiert werden. Dazu müssen nur die Konstanten dieser Datei übersetzt werden. Wir werden ihr zwei weitere String-Konstanten hinzufügen.
  4. Erstellen der dimens.xml Datei – Als letzten Arbeitsschritt in diesem Abschnitt werden wir eine neue Ressourcen-Datei erstellen, mit deren Hilfe wir Größenangaben für die gesamte Android App festlegen können.

Beginnen wir nun mit dem ersten Arbeitsschritt.

3.1 Die Datei styles.xml anpassen

Die Ressourcen-Datei styles.xml ist die erste Datei unseres Android Projekts, die wir überarbeiten. Dazu öffnen wir die Datei im Editorfenster von Android Studio mit einem Doppelklick auf den entsprechenden Eintrag in der linken Projektleiste.

Ihr solltet folgenden Quellcode in Android Studio sehen:

android studio project styles before

Die Ressourcen-Datei styles.xml zum Projektstart

Nun löschen wir zuerst die drei Zeilen, die von dem blauen Rahmen (B) umschlossen sind. Mit diesen Zeilen werden die drei Grundfarben unserer Android App definiert. Wir benötigen dies für unsere App nicht und löschen die Zeilen daher.

Bei früheren Versionen von Android Studio gab es ein Rendering-Problem, das mittlerweile behoben wurde. Daher ist die Änderung des orange unterstrichenen Ausdrucks (A) optional. Wir empfehlen euch trotzdem das Attribut parent leicht zu verändern. Dazu einfach Base.Theme.AppCompat.Light.DarkActionBar als Wert für das parent-Attribut eingeben.

Die styles.xml Datei sollte nun wie folgt aussehen:

android studio project styles after

Die Ressourcen-Datei styles.xml mit den vorgenommenen Änderungen

Da wir nun keine Grundfarben mehr für unsere App vorgeben, wird die colors.xml Datei nicht mehr benötigt. Wir löschen sie daher im nächsten Arbeitsschritt.

Dieser Abschnitt ist wahrscheinlich überholt. Ihr könnt ihn überspringen, wenn bei euch das Rendering Problem von Android Studio nicht auftritt. Das Rendering Problem war ein Bug in Android Studio 1.2.

Es kann sein, dass bei euch die folgende Fehlermeldung auf dem Startbildschirm angezeigt wird:

android studio project willkommen

Fehlermeldung im Startbildschirm von Android Studio nachdem das neue Projekt erstellt wurde

Dabei handelt es sich um ein Problem beim Rendering des App-Designs in Android Studio. Das Problem lässt sich leicht mit einer Änderung der AppTheme-Angabe beheben.

Dazu müssen wir eine Änderung an der styles.xml Ressourcendatei in Android Studio vornehmen. Die Zeile:


muss durch Hinzufügen von Base. wie folgt geändert werden:


Die beiden unteren Abbildungen zeigen, wie die Änderung des AppThemes in Android Studio vorgenommen wird. In der linken Leiste ist die Projektstruktur im Android-View zu sehen. Dort wählen wir die Datei styles.xml aus und nehmen anschließend im Editorfenster die Änderung entsprechend vor.

android studio project theme

Die Angabe für das App-Theme ist nicht korrekt

android studio project basetheme

Ändern der Angabe für das App-Theme zu Base.Theme.AppCompat.Light.DarkActionBar

Jetzt sollte der Rendering Fehler behoben sein und wir können uns eine Design-Vorschau unserer App in Android Studio anzeigen lassen.

Es müssen vorher aber die Abschnitte 4 bis 7 dieses Android Tutorials abgearbeitet worden sein, bevor die Layout-Dateien im Projekt angelegt wurden.

Dazu klicken wir in der Projektstruktur auf die Layout-Datei fragment_main.xml, welche sich in dem Ordner res/layout befindet. Mit einem Doppelklick öffnet sich die Layout-Datei im Editor. Wenn der Design-Tab ausgewählt ist, sollten wir nun das Design unserer Android App angezeigt bekommen.

Wenn alles funktioniert hat, solltet ihr jetzt eine Vorschau eurer App sehen:

android studio project startbildschirm

Rendering Fehler wurde behoben – Das Design unserer App kann nun in Android Studio betrachtet werden

Weitere Informationen zu diesem Rendering-Problem könnt ihr hier finden.

3.2 Die Datei colors.xml löschen

Die Ressourcen-Datei colors.xml wird nun nicht mehr benötigt und kann daher gelöscht werden. Dazu gehen wir folgendermaßen vor:

  1. Mit der rechten Maustaste auf den colors.xml Eintrag in der Projektleiste klicken.
  2. Anschließend den Eintrag Delete... des Kontext-Menüs anklicken.
android studio project colors delete

Löschen der Ressourcen-Datei colors.xml, da wir sie nicht mehr benötigen

Danach öffnet sich der Safe Delete-Dialog, den wir mit einem Klick auf den OK-Button bestätigen:

android studio project colors dialog

Bestätigen des Löschvorgangs mit Klick auf OK

Die Datei colors.xml sollte nun bei euch gelöscht und nicht mehr in der Projektliste aufgeführt sein.

3.3 Zwei Konstanten in der Datei strings.xml anlegen

Die Ressourcen-Datei strings.xml ist die erste Datei unseres Android Projekts, in die wir eigenen Quellcode einfügen. Dazu öffnen wir die Datei im Editorfenster von Android Studio mit einem Doppelklick auf den entsprechenden Eintrag in der linken Projektleiste.

Ihr solltet folgenden Quellcode in Android Studio sehen:

android studio project strings before

Die Ressourcen-Datei strings.xml zum Projektstart

In dieser XML-Datei werden alle String-Konstanten der Android App gesammelt. Dadurch können wir von anderen Stellen im Code auf diese zentrale Stelle zugreifen. Möchten wir einmal eine Bezeichnung in unserer App verändern, müssen wir nur die entsprechende Konstante in der strings.xml Datei ändern. Dies ist besonders vorteilhaft bei der Lokalisierung der Android App.

Wir definieren nun zwei String-Konstanten in der strings.xml Datei. Dazu fügen wir die folgenden beiden Zeilen in die Datei ein:


In Android Studio sollte die Ressourcen-Datei strings.xml nun folgendermaßen aussehen:

android studio project strings after

Die Ressourcen-Datei strings.xml mit den vorgenommenen Änderungen

Auf die beiden neuen String-Konstanten greifen wir später von einer anderen Stelle zu.

3.4 Erstellen der dimens.xml Ressourcen-Datei

Nun, als letzten Arbeitsschritt in diesem Abschnitt, legen wir die Ressourcen-Datei dimens.xml an. In ihr werden Abstandsangaben global gespeichert.

Um die Datei dimens.xml anzulegen, gehen wir wie folgt vor:

  1. Mit der rechten Maustaste auf den Ordner values in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Values resource file klicken.
android studio project dimens create

Erstellen der Ressourcen-Datei dimens.xml in Android Studio

Als Nächstes öffnet sich der New Values Resource File-Dialog, in dem wir den Namen der Ressourcen-Datei vorgeben. Wir geben in das Textfeld als Namen dimens.xml ein und bestätigen mit OK.

android studio project dimens name

Dateinamen für die neue Ressourcen-Datei festlegen.

In die neu erstellte Datei fügen wir den folgenden Quellcode ein:


Mit den oberen Zeilen legen wir globale Werte für den horizontalen und vertikalen Abstand in unserer Android App fest. Auf diese hier definierten Konstanten werden wir später von den Layout-Dateien aus zugreifen.

In Android Studio sollte die dimens.xml Ressourcen-Datei nun wie folgt aussehen:

android studio project dimens code

Die neu angelegte Ressourcen-Datei dimens.xml mit den vorgenommenen Änderungen

Mit diesem letzten Arbeitsschritt in diesem Abschnitt haben wir die Vorbereitungen am values-Ordner abgeschlossen.

Im nächsten Abschnitt werden wir eine Menü-Ressource für unsere Android App anlegen und darin einen Menüeintrag definieren.

4. Anlegen einer Menü-Ressource für unsere Android App

Wir werden in diesem Android Tutorial eine App programmieren, die über ein Options Menu verfügt. Damit wir unserer Android App dieses Menü hinzufügen können, müssen wir das Menü in einer Menü-Ressourcendatei definieren.

Um dies zu tun, sind die folgenden beiden Arbeitsschritte notwendig:

  1. Anlegen des Ordners menu – In dem Menu Resource-Ordner werden die Layout-Dateien der Menüs unserer Android App gesammelt.
  2. Erstellen der Datei menu_main.xml – Diese Menu Resource-Datei wird die Einträge für das Menü unserer MainActivity enthalten. Wir werden sie als Basis des Options Menu unserer App nutzen.

Beginnen wir nun mit dem ersten Arbeitsschritt und legen den menu-Ordner an.

4.1 Anlegen des menu-Ordners in Android Studio

Um eine Menu Resource-Datei anzulegen, muss vorher ein passender Ordner in dem Android Projekt vorhanden sein. Diesen werden wir zuerst anlegen. Dazu führen wir folgende Schritte durch:

  1. Mit der rechten Maustaste auf den Ordner res in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Android resource directory klicken.
android studio project menu directory

Erstellen des Menu Ressourcen-Ordners menu in Android Studio

Anschließend öffnet sich der New Resource Directory-Dialog. Wir nehmen in ihm folgende Einstellungen vor:

  • Directory name: menu
  • Resource type: menu
  • Source set: main

Weitere Einstellungen nehmen wir nicht vor und bestätigen den Dialog mit einem Klick auf den OK-Button.

Der New Resource File Dialog mit den einzutragenden Einstellungen

Der New Resource File Dialog mit den einzutragenden Einstellungen für den menu-Ordner

Nun legt Android Studio das Ressourcen-Verzeichnis für unsere Menü-Ressourcendateien automatisch an.

4.2 Erstellen der menu_main.xml Ressourcen-Datei

Als nächsten Schritt erstellen wir die Ressourcen-Datei menu_main.xml, die Informationen über die Einträge unseres Options Menu enthält. Dazu führen wir die folgenden Schritte aus:

  1. Mit der rechten Maustaste auf den eben erstellten Ordner menu in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Menu resource file klicken.
android studio project menu file

Erstellen der Menü Ressourcen Datei menu_main.xml in Android Studio

Danach öffnet sich der New Menu Resource File-Dialog, in dem wir als Namen für unsere Menü Ressourcendatei menu_main.xml eingeben.

android studio project menu filename

Dateinamen für die neue Menü Ressourcen Datei festlegen.

Wir öffnen nun die neu erstellte Menü Ressourcendatei menu_main.xml im Editorfenster und fügen den folgenden Quellcode ein:


Mit dem oberen Quellcode definieren wir ein Menü mit einem Menüeintrag. Der Menüeintrag besitzt eine id und einen title. Den Wert für den title lesen wir aus der strings.xml Ressourcendatei aus.

In Android Studio sollte die menu_main.xml Datei nun wie folgt aussehen:

android studio project menu code

Die Menü Ressourcen Datei menu_main.xml mit den vorgenommenen Änderungen

Somit haben wir nun die Voraussetzungen für ein Menü geschaffen. Wir werden später diese Menü Ressourcendatei in der MainActivity nutzen und mit ihr das Options Menu füllen.

Kommen wir nun im nächsten Abschnitt zu einer der wichtigsten Android Komponenten, den Fragmenten.

5. Ein Fragment in Android Studio anlegen

Wir werden nun das MainActivityFragment anlegen. Da ein Fragment eine Layout-Datei benötigt, über die es sein Aussehen definiert, müssen wir vorher eine solche Layout-Datei für unser Fragment anlegen. Diese Datei muss in einem Resource Directory liegen, welches wir auch in diesem Abschnitt anlegen werden.

Somit besteht das Anlegen des MainActivityFragments aus den folgenden drei Arbeitsschritten:

  1. Anlegen des Ordners layout – Wir legen einen Ressourcen-Ordner für die Layout-Dateien der Fragmente und Activities an.
  2. Erstellen der Layout-Datei fragment_main.xml – In dem erstellten Ordner lassen wir die Layout-Datei fragment_main.xml erstellen und definieren in ihr das Aussehen unseres MainActivityFragments.
  3. Erstellen der Klassendatei MainActivityFragment.java – Nun können wir das Fragment in dem Java Package unseres Android Projekts anlegen lassen und es mit Quellcode füllen.

Beginnen wir nun mit dem ersten Arbeitsschritt.

5.1 Anlegen des layout-Ordners in Android Studio

Der layout-Ordner enthält die Layout-Dateien der Activities und Fragmente der Android Anwendung. Über die Layout-Dateien wird das Aussehen der Activities und Fragmente definiert. Wir werden nun einen Layout Ressourcen-Ordner anlegen.

Dazu gehen wir folgendermaßen vor:

  1. Mit der rechten Maustaste auf den Ordner res in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Android resource directory klicken.
android studio project layout folder

Erstellen des Layout Ressourcen-Ordners layout in Android Studio

Anschließend öffnet sich der New Resource Directory-Dialog. Wir nehmen in ihm folgende Einstellungen vor:

  • Directory name: layout
  • Resource type: layout
  • Source set: main

Weitere Einstellungen nehmen wir nicht vor und bestätigen den Dialog mit einem Klick auf den OK-Button.

android studio project layout directory

Der New Resource File Dialog mit den einzutragenden Einstellungen für den layout-Ordner

Nun legt Android Studio das Ressourcen-Verzeichnis für unsere Layout-Ressourcendateien automatisch an.

5.2 Erstellen der fragment_main.xml Ressourcen-Datei

Als nächsten Schritt erstellen wir die Ressourcen-Datei fragment_main.xml, die Informationen über das Aussehen unseres Fragments enthält. Dazu führen wir die folgenden Schritte aus:

  1. Mit der rechten Maustaste auf den eben erstellten Ordner layout in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Layout resource file klicken.
android studio project layout file

Erstellen der Layout Ressourcen Datei fragment_main.xml in Android Studio

Danach öffnet sich der New Layout Resource File-Dialog, in dem wir als Namen für unsere Layout Ressourcendatei fragment_main.xml eingeben. Das Root element belassen wir bei LinearLayout.

android studio project layout filename

Dateinamen für die neue Layout Ressourcen Datei festlegen.

Wir öffnen nun die neu erstellte Layout Ressourcendatei fragment_main.xml im Editorfenster. Um den Quelltext zu sehen, müssen wir unten im Editorfenster den Tab Text anklicken. Nachdem wir das getan haben, fügen wir den folgenden Quellcode ein:


Mit dem oberen Quellcode definieren wir das Layout für unser MainActivityFragment. Das Fragment besteht aus einem FrameLayout, welches ein TextView-Element enthält. Der TextView gibt als Text eine Grußbotschaft aus, die wir in der Ressourcen-Datei strings.xml definiert haben. Auch die Innenabstände des FrameLayouts werden über eine externe Datei definiert und zwar über die dimens.xml Ressourcen-Datei.

Zur Info: Der Wert des Attributs tools:context “.MainActivityFragment” erscheint aktuell noch in roter Schrift, da dieser nicht aufgelöst werden kann. Dieses Problem löst sich im nächsten Schritt von selbst, wenn wir die Klasse MainActivityFragment.java anlegen.

In Android Studio sollte die fragment_main.xml Datei nun wie folgt aussehen:

android studio project fragment layout

Die Layout Ressourcen Datei fragment_main.xml mit den vorgenommenen Änderungen

Nun haben wir ein Layout für unser MainActivityFragment angelegt, somit können wir als Nächstes das Fragment selbst erstellen lassen.

5.3 Erstellen der Klassendatei MainActivityFragment.java

Als letzten Arbeitsschritt in diesem Abschnitt werden wir die Klassendatei MainActivityFragment.java anlegen. Was ein Fragment ist, werden wir später noch ausführlich in diesem Android Tutorial besprechen. Jetzt geht es erst einmal nur darum das Fragment zu erstellen, so dass wir es später erweitern können.

Das Fragment legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf das Package de.programmierenlernenhq.aktiehq.app klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Java Class klicken.
android studio project fragment class

Erstellen der Klassendatei MainActivityFragment.java in Android Studio

Anschließend öffnet sich der Create New Class-Dialog, in dem wir als Klassennamen MainActivityFragment eingeben. Den Wert für Kind lassen wir auf Class stehen. Den Dialog bestätigen wir mit Klick auf OK.

android studio project fragment classname

Klassennamen für die Fragment-Klasse festlegen.

Android Studio legt nun automatisch die neue Java Klasse an. Den erzeugten Quellcode werden wir durch eigenen Code ersetzen.

Dazu öffnen wir die Klassendatei MainActivityFragment.java im Editorfenster und fügen den folgenden Quellcode ein:


Die Fragment-Klasse hat noch keine besondere Funktion. Sie verfügt lediglich über die Callback-Methode onCreateView(), in der wir das Layout des Fragments laden. Wie das geschieht und was Callbacks sind, werden wir in späteren Lektionen dieses Android Tutorials ausführlich besprechen.

In Android Studio sollte die Klassendatei MainActivityFragment.java nun wie folgt aussehen:

android studio project fragment code

Die Klassendatei MainActivityFragment.java mit den vorgenommenen Änderungen

Für den Moment begnügen wir uns mit dem reinen Quellcode, die Erklärungen folgen später. Als Nächstes werden wir die MainActivity anlegen, den Hauptbildschirm unserer Android App.

6. Eine Activity in Android Studio anlegen

Nun werden wir die MainActivity anlegen. Auch eine Activity benötigt eine Layout-Datei, über die sie ihr Aussehen definiert. Daher werden wir vorher eine solche Layout-Datei für unsere Activity anlegen. Diese Datei muss in dem layout-Ordner abgelegt werden, welchen wir bereits im vorherigen Abschnitt anlegt haben.

Somit besteht das Anlegen der MainActivity aus den folgenden beiden Arbeitsschritten:

  1. Erstellen der Layout-Datei activity_main.xml – In dem layout-Ordner lassen wir die Layout-Datei activity_main.xml erstellen und definieren in ihr das Aussehen unserer MainActivity.
  2. Erstellen der Klassendatei MainActivity.java – Nun können wir die Activity in dem Java Package unseres Android Projekts anlegen lassen und es mit Quellcode füllen.

Beginnen wir nun mit dem ersten Arbeitsschritt.

6.1 Erstellen der activity_main.xml Ressourcen-Datei

Als ersten Schritt erstellen wir die Ressourcen-Datei activity_main.xml, die Informationen über das Aussehen unserer Activity enthält. Dazu führen wir die folgenden Schritte aus:

  1. Mit der rechten Maustaste auf den Ordner layout in der Projektleiste klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Layout resource file klicken.
android studio project layout activity

Erstellen der Layout Ressourcen Datei activity_main.xml in Android Studio

Danach öffnet sich der New Layout Resource File-Dialog, in dem wir als Namen für unsere Layout Ressourcendatei activity_main.xml eingeben. Das Root element belassen wir bei LinearLayout.

android studio project layout activity name

Dateinamen für die neue Layout Ressourcen Datei festlegen.

Wir öffnen nun die neu erstellte Layout Ressourcendatei activity_main.xml im Editorfenster. Um den Quelltext zu sehen, müssen wir unten im Editorfenster den Tab Text anklicken. Nachdem wir das getan haben, fügen wir den folgenden Quellcode ein:


Mit dem oberen Quellcode weisen wir unserer MainActivity als Layout ein Fragment zu, nämlich das MainActivityFragment. Das Fragment wird den gesamten Fensterinhalt der MainActivity ausfüllen. Was der Quellcode genau bedeutet, werden wir in späteren Teilen des Android Tutorials erfahren.

In Android Studio sollte die activity_main.xml Datei nun wie folgt aussehen:

android studio project layout activity code

Die Layout Ressourcen Datei activity_main.xml mit den vorgenommenen Änderungen

Nun haben wir ein Layout für unsere MainActivity angelegt, somit können wir als Nächstes die Activity selbst erstellen lassen.

6.2 Erstellen der Klassendatei MainActivity.java

Als letzten Arbeitsschritt in diesem Abschnitt werden wir die Klassendatei MainActivity.java anlegen. Was eine Activity ist, werden wir später noch ausführlich in diesem Android Tutorial besprechen. Jetzt geht es erst einmal nur darum die Activity zu erstellen, so dass wir sie später erweitern können.

Die Activity legen wir folgendermaßen an:

  1. Mit der rechten Maustaste auf das Package de.programmierenlernenhq.aktiehq.app klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf Java Class klicken.
android studio project activity class

Erstellen der Klassendatei MainActivity.java in Android Studio

Anschließend öffnet sich der Create New Class-Dialog, in dem wir als Klassennamen MainActivity eingeben. Den Wert für Kind lassen wir auf Class stehen. Den Dialog bestätigen wir mit Klick auf OK.

android studio project activity classname

Klassennamen für die Activity-Klasse festlegen.

Android Studio legt nun automatisch die neue Java Klasse an. Den erzeugten Quellcode werden wir durch eigenen Code ersetzen.

Dazu öffnen wir die Klassendatei MainActivity.java im Editorfenster und fügen den folgenden Quellcode ein:


Auch die Activity-Klasse macht noch nicht sehr viel. Sie verfügt über drei Callback-Methoden, in denen das Layout der Activity geladen und das Options Menu eingerichtet wird. Was dabei passiert, werden wir in späteren Lektionen dieses Android Tutorials ausführlich besprechen. Dafür ist es im Moment noch zu früh.

In Android Studio sollte die Klassendatei MainActivity.java nun wie folgt aussehen:

android studio project activity code

Die Klassendatei MainActivity.java mit den vorgenommenen Änderungen

Jetzt haben wir die Basis für unsere Android App gelegt. Wir haben eine Activity erstellt, die ein Fragment im Inneren besitzt. Wir haben der Activity ein Options Menu zugefügt, welches wir vorher über die entsprechende Ressourcen-Datei definiert hatten.

Außerdem haben wir allgemeine Ressourcen-Dateien angelegt, auf die wir im Laufe der nächsten Lektionen dieses Android Tutorials immer wieder zugreifen werden.

Das alles hört sich sehr gut an, aber zum Starten unserer Android App fehlt noch ein wichtiger Schritt. Wir müssen die MainActivity in der Schaltzentrale unserer App bekannt machen. Dies werden wir im nächsten Abschnitt vornehmen.

7. Anpassen der AndroidManifest.xml Datei

Bevor wir unsere Android App im Emulator ausführen können, müssen wir die Activity bekannt geben, die zum Start ausgeführt werden soll. Dafür verantwortlich ist die AndroidManifest.xml Datei. Sie ist die Schaltzentrale unserer Android Anwendung.

Wir öffnen nun die AndroidManifest.xml Datei im Editorfenster:

android studio project manifest before

Die AndroidManifest.xml Datei zum Projektstart

Beim Erstellen unseres Android Projekts hat Android Studio bereits den Namen der Application eingetragen und das AppTheme festgelegt.

Wir werden nun den Quellcode der AndroidManifest.xml Datei mit dem folgenden Code ersetzen:


Solltet Ihr einen anderen Package-Namen verwendet haben, dann muss Zeile 2 entsprechend angepasst werden. Anstelle von “de.programmierenlernenhq.aktiehq.app” müsst ihr dann den, von euch verwendeten, Package-Namen einsetzen.

Jetzt haben wir unsere MainActivity bekannt gemacht und für sie einen intent-filter definiert. Intents werden wir später ausführlich kennenlernen, es gibt implizite und explizite Intents. Über Intents werden Activities gestartet.

In diesem Fall wurde unsere MainActivity als Start-Activity festgelegt, die aufgerufen werden soll, sobald unsere Android App gestartet wird.

Die AndroidManifest.xml Datei sollte in Android Studio nun wie folgt aussehen:

android studio project manifest after

Die AndroidManifest.xml Datei mit den vorgenommenen Änderungen

Jetzt haben wir alle Vorbereitungen fast abgeschlossen. Theoretisch könnten wir unsere Android App jetzt starten. Bevor wir dies aber tun, werden wir die Einstellungen in der build.gradle Datei überprüfen und wenn nötig anpassen.

8. Die build.gradle Datei anpassen

In der Datei build.gradle werden wichtige Einstellungen für das Erstellen (build) unserer Android App vorgegeben. Da Android SDK stetig weiterentwickelt wird, sind die Einstellungen in der Gradle-Datei bei jedem User von Android Studio etwas anders.

Als dieses Android Tutorial entwickelt wurde, war gerade die Android API 23 aktuell. Android entwickelt sich schnell weiter, so dass es bald die Android API 24 geben wird. Dann werden auch die Werte in der Gradle-Datei etwas anders als die hier gezeigten sein.

Soviel zur Einleitung in die Gradle-Problematik. Wir öffnen nun die Datei build.gradle in dem app-Ordner unseres Projekts. Dazu klicken wir doppelt auf die build.gradle-Datei.

Nun sollte sich die build.gradle-Datei im Editorfenster von Android Studio geöffnet haben. Sie wird uns als app-Tab angezeigt:

android studio project gradle

Einstellungen an der build.gradle Datei unseres Android Projekts

Es sollten folgende Werte in der Gradle-Datei angegeben sein:

  • minSdkVersion: 10
  • targetSdkVersion: 23

Alle anderen Werte können bei euch durchaus etwas anders sein. Ihr solltet nur die beiden oben aufgeführten Werte ändern, wenn diese bei euch anders sind.

Die targetSdkVersion legt fest, für welche Zielplattform wir unsere App entwickeln wollen. Wir wählen API 23, welche Android 6.0 entspricht und momentan auf den neuesten mobilen Geräten installiert ist. Später, zu Testzwecken, wird auch unser Android Virtual Device diese API emulieren.

Die compileSdkVersion richtet sich nach den verwendeten Android SDK Build-tools, die mit der Zeit aktualisiert werden. Der dort eingetragene Wert muss zu den Build-tools passen. Momentan sind sie in der Version 23.0.3 verfügbar.

Achtung! Man kann keine beliebigen Werte in die Gradle-Datei eintragen. Es müssen immer die entsprechenden Android SDK Tools auf dem Entwicklungssystem installiert sein und sie müssen mit der korrekten Versionsnummer benannt werden.

Die SDK Tools werden über den SDK Manager von Android Studio verwaltet, den wir in der vorherigen Lektion des Tutorials kennengelernt haben. Daher ist es wichtig, dass ihr die Anweisungen im vorherigen Teil des Android Tutorials genau befolgt.

8.1 Kompilieren unserer Android App (Make Project)

Als letzten Schritt in diesem Abschnitt lassen wir unser Projekt neu erstellen. Wir klicken dafür in der oberen Menüleiste auf den Eintrag Build und dort auf den Befehl Make Project.

android studio project build

Das Projekt neu erstellen mit dem Befehl: Build -> Make Project

Daraufhin wird unser Android Studio Projekt kompiliert und dabei neu erstellt, somit werden unsere Änderungen in den neuen Build übernommen.

Im nächsten Abschnitt werden wir ein Android Virtual Device (AVD) einrichten, auf dem wir dann unsere App emulieren werden.

9. Android Virtual Device (AVD) einrichten

Unsere App können wir auf einem Android Gerät oder in der Entwicklungsumgebung ausführen.

In diesem Teil des Tutorials werden wir den Android Emulator einrichten, so dass wir unsere App am PC ausführen und testen können. Dazu müssen wir zunächst ein virtuelles Gerät einrichten.

Von Android Studio wird uns dafür der Android Virtual Device Manager, kurz AVD Manager, zur Verfügung gestellt.

Wir können den Manager auf zwei Arten öffnen. Mit einem Klick auf das AVD Manager-Symbol in der oberen Menüleiste oder direkt über das Hauptmenü, indem wir auf Tools>Android>AVD Manager klicken. Siehe die folgenden beiden Abbildungen:

android studio project avd manager

Android Virtual Device Manager über das AVD Manager-Symbol öffnen

android studio project avd manager

Android Virtual Device Manager über das Menü öffnen

Nachdem der AVD Manager das erste Mal gestartet wurde, öffnet sich der Your Virtual Devices-Dialog des Managers. Wir haben an dieser Stelle die Möglichkeit ein Android Virtual Device einzurichten.

Da unsere Android App auch auf Tablets laufen wird, richten wir nun ein AVD ein, das wir als Tablet-Emulator nutzen werden.

Mit einem Klick auf Create Virtual Device... können wir ein neues AVD erstellen lassen:

android studio project avd

Android Virtual Device Manager: Der Your Virtual Devices Dialog

Als Erstes müssen wir ein Hardware-Profil für das AVD festlegen. Wir wählen als Category den Eintrag Tablet aus und als Device den oberen Eintrag Nexus 9. Anschließend klicken wir auf den Next-Button.

android studio project avd profil

Hardware-Profil für unser AVD auswählen

Jetzt wählen wir als System Image das oberste Image mit dem Release Name Marshmallow mit API Level 23 und x86 aus. Die anderen Images aus der Liste können heruntergeladen werden, so dass man später AVDs mit verschiedenen API-Versionen einrichten kann. Wir begnügen uns aber an dieser Stelle mit einem AVD.

Das ausgewählte System Image wird auf dem Emulator ausgeführt werden. Da wir für Android API 23 als Zielplattform (siehe targetSdkVersion) entwickeln, wählen wir Android 6.0, welches API Level 23 entspricht. Mit einem Klick auf Next wechseln wir zum nächsten Dialog.

android studio project avd image

API 23 als System Image für unser Android Virtual Device festlegen

Jetzt haben wir unser AVD fast eingerichtet. In diesem letzten Dialog nehmen wir die beiden folgenden Änderungen vor:

  • AVD Name: Nexus 9 API 23 Tablet
  • Scale: 2dp on device = 1px on screen

Die übrigen Einstellungen übernehmen wir unverändert. Anschließend klicken wir auf den Finish-Button und lassen unser AVD mit dem Namen Nexus 9 API 23 Tablet erstellen.

android studio project avd name

Android Virtual Device Konfiguration abschließen

Nun wird unser Android Virtual Device (AVD) von dem AVD Manager erstellt. Dieser Vorgang kann einige Momente dauern.

10. Android Virtual Device (AVD) im Emulator starten

Nachdem das Android Virtual Device (AVD) nach unseren Vorstellungen erstellt wurde, möchten wir es in dem Android Emulator ausführen.

Schritt 1: AVD Manager öffnen und auf Launch this AVD in the emulator-Button klicken. Dazu öffnen wir den AVD Manager entweder über das Hauptmenü oder das AVD Manager-Symbol in der oberen Menüleiste.

Der AVD Manager sollte jetzt auch das, von uns eingerichtete, Android Virtual Device (AVD) als Eintrag in der Your Virtual Devices-Liste anzeigen. Zum Starten des AVDs müssen wir nur noch auf das grüne Play-Symbol rechts in der Actions-Spalte klicken.

android studio project avd starten

Schritt 1: AVD Manager öffnen und das erstellte AVD starten

Das erstellte AVD wird nun im Emulator gestartet. Der Startvorgang kann manchmal sehr lange dauern. Es ist also etwas Geduld gefragt. Nach 10 Minuten sollte der Vorgang aber abgeschlossen sein.

Die Startzeit ist von vielen Komponenten abhängig, daher ist eine genaue Zeitangabe nicht möglich. Außerdem nimmt das erste Starten zusätzliche Zeit in Anspruch. Dies alles solltet ihr berücksichtigen, um nicht vorzeitig den Startprozess abzubrechen.

Nachdem das AVD im Emulator gestartet wurde, sehen wir in dem neu erschienenen Emulator-Fenster den Startbildschirm unseres AVDs. Wir werden als Nächstes in Android Studio auf die Android-Ansicht wechseln, in der wir die Kommunikation mit unserem Virtual Device überwachen können.

Schritt 2: In Android Studio auf die Android-Ansicht wechseln. Dazu klicken wir in Android Studio auf den Menüeintrag 6: Android Monitor in der Statusleiste unten links (Markierung 1). Dadurch wechselt die Ansicht auf Android DDMS. In dieser Ansicht können wir unsere Android Virtual Devices überwachen.

android studio project avd open

Schritt 2: Auf Android-View in Android Studio wechseln und das AVD überwachen

Da wir im Moment nur ein AVD im Emulator gestartet haben, wird auch nur dieses in der Liste angezeigt (Markierung 2). Wir können den Namen des AVDs, den API-Level und die auf dem Device ausgeführten Prozesse erkennen.

Rechts im Bild ist das Emulator-Fenster, in dem unser AVD ausgeführt wird, in den Vordergrund gebracht worden. Wir können nun das AVD im Emulator ausprobieren und einige Apps aufrufen oder verschiedene Einstellungen zu Testzwecken vornehmen.

11. Android App auf dem Android Virtual Device (AVD) emulieren

Jetzt ist es an der Zeit unsere App im Android Emulator auszuführen.

Wichtig ist, dass der Emulator bereits gestartet ist und in einem eigenen Fenster ausgeführt wird (siehe vorheriger Abschnitt).

Wir können unsere App auf zwei verschiedene Arten starten. Mit einem Klick auf das Run 'app'-Symbol in der oberen Menüleiste oder direkt über das Hauptmenü, indem wir auf Run>Run 'app' klicken. Siehe die folgenden beiden Abbildungen:

android studio project avd run

Variante A – Android App über das Run App-Symbol starten

android studio project avd run app

Variante B – Android App über das Menü starten

Die App wird nicht direkt gestartet. Es ist noch ein weiterer Zwischenschritt notwendig. Nachdem wir auf das Run 'app'-Symbol geklickt haben, wird unser Projekt im Hintergrund neu erstellt. Sobald der Build-Prozess erfolgreich abgeschlossen wurde, öffnet sich das kleine Fenster “Select Deployment Target“, in dem wir das Android Virtual Device festlegen, auf dem unsere App ausgeführt werden soll.

In dem Fenster Select Deployment Target können wir aus den verbundenen virtuellen und physischen Android Geräten auswählen.

Da wir bereits in dem Android Emulator das Nexus 9 API 23 Tablet (Android 6.0, API 23)-AVD in einem anderen Fenster ausführen, wählen wir unter dem Punkt Connected Devices dieses AVD aus. Anschließend klicken wir auf den OK-Button.

android studio project avd choose

Auswählen des AVDs auf dem die App ausgeführt werden soll

Nun wird die Android App auf unserem erstellten AVD installiert. Den Vorgang können wir im Run-View überwachen. In der folgenden Abbildung sind die aufgezeichneten Meldungen dargestellt:

android studio project avd

Im Run-View angezeigte Informationen über den Status der App-Installation auf dem AVD

Nachdem die App auf unserem AVD installiert worden ist, wird sie mittels Konsolenbefehl automatisch von Android Studio gestartet.

Wenn alles funktioniert hat, ist unsere App jetzt im Emulator-Fenster gestartet worden und wir erhalten als Text folgenden String angezeigt: Hallo ProgrammierenLernenHQ World!. Außerdem können wir uns im Android Monitor-View den Prozess unserer ersten App anzeigen lassen.

In der folgenden Abbildung sehen wir, dass unsere erste App im Emulator auf dem erstellten AVD ausgeführt wird. Zudem können wir im Android Monitor-View den Prozess unserer App erkennen (siehe Markierung A).

android studio project avd app

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

Da unsere Android App auf dem AVD installiert wurde, können wir sie auch selbst auf dem Emulator starten. Dazu gehen wir einfach in das App-Menü des AVDs und klicken auf das Symbol unserer Android Anwendung.

Die App bleibt auf dem AVD installiert. Wir können also beim nächsten Mal das AVD auf dem Emulator ausführen und in diesem unsere dann bereits installierte App starten. Das Starten erfolgt intuitiv über das App-Menü unseres Android Virtual Devices.

android studio project app

Unsere App ist jetzt auf dem Android Virtual Device installiert

Zusammenfassung

Mit dem Ende der zweiten Lektion unseres großen Android Tutorials sind wir für die Entwicklung eigener Android Apps bestens vorbereitet. Wir hatten bereits in der vorherigen Lektion Android Studio installiert und nach unseren Bedürfnissen eingerichtet.

Damit wir unsere Apps direkt auf dem Rechner testen und debuggen können, haben wir nun in dieser Lerneinheit den Android Emulator und ein Android Virtual Device (AVD) eingerichtet. Auf dem AVD haben wir zu Testzwecken bereits unsere erste einfache App ausführen lassen.

Soweit sind die Vorbereitungen abgeschlossen und das Programmieren unserer ersten komplexeren App kann beginnen.


Comments 106

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

  2. Pingback: Android Tutorial: Eigene Android App installieren

  3. Pingback: Android Tutorial: Daten mit einem Listview anzeigen

  4. Pingback: Android Tutorial: Refactoring und Logging in Android Studio

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

  6. Christopher Wippel

    Bei mir fehlt: MainActivityFragment.java . Ich habe lediglich die eine MainActivity.java. Habe aber alle Schritte befolgt, wie bekomme ich die? – wäre sehr dankbar über einen Tipp.

    Liebe Grüße
    Chris

    1. Post
      Author
      Chris

      Hallo Christopher,

      zwei Möglichkeiten die mir einfallen, sind:

      1. Eventuell ist bei dir nicht die neueste Version von Android Studio installiert. Im Tutorial wird Android Studio v1.2 verwendet. Dieses generiert bei einem neuen Projekt (Blank Activity with Fragment) eine MainActivity und ein MainActivityFragment. In der Version 0.8 wurde das Fragment noch in der Klasse MainActivity angelegt. Welche Version von Android Studio verwendest du?

      2. In Abschnitt 2 bei Schritt 4 muss als Aufbau “Blank Activity with Fragment” ausgewählt werden. Vielleicht hast du an dieser Stelle etwas anderes ausgewählt.

      Ich hoffe einer der beiden Tipps löst dein Problem.

      Viele Grüße, Chris

      1. alfred

        Hallo Chris,

        also im screen-shot Schritt 2.4 wird No Activity ausgewählt ._(

        Schöne Grüße, Alfred

        1. Post
          Author
          Chris

          Hallo Alfred,

          danke für den Hinweis. In einer älteren Version des Tutorials wurde noch mit “Blank Activity with Fragment” gearbeitet. Dies habe ich aber Mitte letzten Jahres überarbeitet.

          Viele Grüße, Chris

  7. Harry

    Die erstellte AVD wird bei mir nicht gestartet. Bei mir erscheint also kein neues Fenster mit einem Device obwohl ich meiner Meinung nach alles exakt wie hier im Tutorial gemacht habe. Ich bin ziemlich ratlos. Habe es mehrfach probiert. Wo könnte der Fehler denn liegen?

    1. Post
      Author
      Chris

      Hallo Harry,

      es kann sein, dass das AVD zu viel RAM benötigt. In der AVD-Einstellung kann man den zugewiesenen Speicher vorgeben. Vielleicht hilft es den entsprechenden Wert zu reduzieren.

      Dieser Link ist eventuell hilfreich: http://stackoverflow.com/questions/28269121/android-studio-emulator-memory-limit

      Für das Tutorial kannst du aber auch das bereits eingerichtete AVD (automatisch bei der Installation von Android Studio) benutzen, falls dieses bei dir starten sollte.

      Viele Grüße, Chris

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

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

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

  11. Sepp Lichter

    Hallo Harry,

    ich bekomme beim Befehl RUN APP immer die Meldung, dass das Build nicht erzeugt werden kann. Meldung in Messages Gradle Build:

    Error:(2) Error retrieving parent for item: No resource found that matches the given name ‘android:TextAppearance.Material.Widget.Button.Inverse’.
    Error:(2) Error retrieving parent for item: No resource found that matches the given name ‘android:Widget.Material.Button.Colored’.
    Error:Execution failed for task ‘:app:processDebugResources’.
    > com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException: Process ‘command ‘C:\Users\DEBOSS\AppData\Local\Android\sdk\build-tools\22.0.1\aapt.exe” finished with non-zero exit value 1

    Da ich auch absoluter Anfänger bin, weiß ich nicht, was ich tun muss, um diese Fehler zu korrigieren… kannst Du etwas damit anfangen bzw. Hilfestellung geben?

    Vielen Dank
    Sepp

    1. Post
      Author
      Chris

      Hallo Sepp,

      die Fehlermeldungen kenne ich bisher nicht. Vielleicht hatte ein anderer Leser schon einmal ein ähnliches Problem und kann helfen.

      Falls mir eine Lösung zu den Problemen einfällt, gebe ich sie durch.

      Viele Grüße, Chris

  12. Moritz Haas

    Hallo zusammen,
    ich arbeite mit Version 1.4 des Android Studio und hier gab es beim Wizard zur Erstellung des Projektes in Schritt 4 den Eintrag “Blank Activity With Fragment” nicht. Deshalb habe ich (wahrscheinlich) auch die Datei “Fragment Main” nicht, sondern nur “activity_main.xml” und “content_main.xml”.
    Ich habe statt “Blank Activity With Fragment” “Empty Activity” gewählt. Muss ich jetzt die Datei(en) von Hand erstellen/editieren, oder gibt es eine andere Möglichkeit.
    VG Moritz

    1. Post
      Author
      Chris

      Hallo Moritz,

      danke für dein Feedback. Leider wird ab und zu der Wizard von Android Studio verändert. Ich werde demnächst den Teil 2 des Tutorials aktualisieren, so dass es für die neue Version von Android Studio passt. Bis dahin müssen die Dateien manuell angelegt werden, so dass die Projektstruktur den Bildern des Android Tutorials entspricht.

      Viele Grüße, Chris

      (Update: Teil 2 des Android Tutorials wurde aktualisiert. Jetzt sollte es für alle Versionen von Android Studio passen, da der Wizard nicht mehr verwendet wird.)

  13. Luca

    Habe das problem das bei aufgabe 11 diese Fehlermeldung kommt und ich nicht weiß was ich jetzt machen soll?
    ‘Cannot launch AVD in emulator.
    Output:
    emulator: ERROR: x86 emulation currently requires hardware acceleration!
    Please ensure Intel HAXM is properly installed and usable.
    CPU acceleration status: HAX kernel module is not installed!’

    1. Post
      Author
  14. Bärbel

    Hallo, Chris,

    die anschauliche und übersichtliche Darstellung Deines Tutorials hilft mir, offene Fragen zu klären und gern nutze ich es als Anleitung oder schlage hier nach, wenn ich etwas wissen will. Nochmals vielen Dank für diesen gelungenen Kursus!

    Ich habe zum 2. Teil noch eine Frage. Warum hast Du bei der Projekterstellung den Namen des Package mit .app erweitert? Hat das Auswirkungen auf die weitere Programmierung?

    Viele Grüße, Bärbel

    1. Post
      Author
      Chris

      Hallo Bärbel,

      schön wenn das Tutorial hilfreich ist, dann hat sich die Arbeit gelohnt.

      Zu deiner Frage. Das Package habe ich mit .app erweitert, weil in ganz alten Versionen von Android Studio dieses .app automatisch bei Projekterstellung angefügt wurde. Es ist also ein Überbleibsel aus vergangener Zeit. Würde ich das Tutorial noch einmal komplett neu erstellen, dann würde ich .app nicht wieder anfügen, da es nicht benötigt wird und auch keine Auswirkungen auf die weitere Programmierung hat.

      Viele Grüße, Chris

  15. Max

    Hallo!
    Erst einmal ein dickes Lob für Deine Seite!!! Danke.

    Zur Frage:
    Hat es einen Grund, warum die Datei “dimens.xml” uns “strings.xml” heißt aber in der Datei fragment_main.xml auf “dimen/…” und “string/…” zugegriffen werden soll?

    VG
    Max

  16. Max

    Hallo,

    habe vor ca. 30 Min. geschrieben wegen Dimens und Dimen.
    Hat sich erledigt. Falsch abgeschrieben.

    Sorry.

  17. Moritz Haas

    Hallo zusammen,
    ich habe das Problem, dass ich weder Intel HAXM noch die Alternativsoftware nutzen kann. Das ist ja nicht so schlimm, ich kann die App ja auch direkt auf einem Gerät testen. Nun gibt es nach erfolgreicher Übertragung und Installation zu dieser Fehlermeldung: “Could not identify launch activity: Default Activity not found” in der “Run”-Konsole.
    Kann mir bitte jemand helfen?
    Viele Grüße

    Moritz Haas

  18. Moritz Haas

    Edit: Habe einfach noch einmal den Quellcode von dieser Seite in die Datei “AndroidManifest.xml” kopiert und jetzt läuft’s.
    Übrigens: Ich finde das Tutorial toll und werde es jedem weiterempfehlen, der sich mit Android-Apps beschäftigen möchte.
    Viele Grüße

    Moritz Haas

    1. Post
      Author
      Chris

      Hallo Moritz,

      gut wenn es jetzt funktioniert. Bei Android können schon kleine Tippfehler zur großen Problemen führen.

      Danke, dass du unser Android Tutorial weiterempfehlen möchtest!

      Viele Grüße, Chris

  19. Willi

    Guten Abend!

    Erstmal ganz großes Lob und Danke an die Macher des Tutorials!

    Leider habe ich folgende Fehlermeldung:

    Error:Execution failed for task ‘:app:dexDebug’.
    > com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException: Process ‘command ‘C:\Program Files\Java\jdk1.7.0_79\bin\java.exe” finished with non-zero exit value 1

    wenn ich versuche die app zu emulieren, somit passiert auch nichts im Emulator und ich werde auch nicht gefragt welches Device ich nutzen möchte.
    Ich versuche seit ein Paar Stunden vergeblich Antworten zu finden und möchte nicht, dass mein Interesse, bevor ich überhaupt mit dem programmieren angefangen habe, schwindet.

    Gebt mir bitte ein Tipp! :)

    1. Post
      Author
      Chris

      Hallo Willi,

      Danke für Dein Lob!

      Sorry für die späte Antwort, es ging leider nicht früher.

      Zu der Fehlermeldung. Ich selbst hatte diesen Fehler bisher noch nicht, aber auf der Webseite StackOverflow.com kann man eine Menge darüber finden. Es scheint ein Problem mit den angegebenen Libraries in der build.gradle Datei zu sein. Und zwar, wenn Libraries doppelt in den Tag dependencies eingetragen sind oder andere Konflikte erzeugen.

      Vielleicht ist dieser Link für Dich hilfreich:

      java finished with non zero exit value android gradle

      Falls andere Leser unseres Tutorials dieses Problem bereits hatten und eine Lösung dazu kennen, können sie die Lösung gerne in einen Kommentar beschreiben. Wir würden uns sehr darüber freuen :)

      Viele Grüße, Chris

  20. Anne

    Hallo,
    ersmal danke für das tolle Tutorial.
    Bei mir ergibt sich nun bei 6.3 das Problem, das in der Zeile

    return inflater.inflate(R.layout.fragment_main, container, false);

    das R als falsch markiert wird, was ich auch nachfolziehen kann, das ‘R’ niergends
    deklariert und initialiert ist.

    Wie kann ich das Problem umgehen?

    Viele Grüße,
    Anne

    1. Post
      Author
      Chris

      Hallo Anne,

      Danke für Dein Lob!

      Mit deiner Ressourcen-Variable R scheint etwas nicht zu stimmen. Die wird von Android Studio generiert und sollte automatisch gefunden werden. Die Ressourcen-Variable R muss nicht deklariert und initialisiert werden.

      Der folgende Link führt zur Google Suchanfrage: android studio r cannot be resolved to a variable

      Es könnte aber auch ein Tippfehler in Deinem Quellcode sein. Tippfehler schleichen sich schnell ein. Wenn Du möchtest, kannst Du mir Deine Projektdateien als ZIP per E-Mail zusenden. Ich werde dann mal drüber schauen, vielleicht kann ich den Fehler finden. Die E-Mail Adresse kannst Du im Impressum nachschauen.

      Viele Grüße, Chris

      1. Ronny

        Hi Chris,

        auch von mir ein großes Danke fürs Tutorial.

        Aber auch ich habe das gleiche Problem wie Anne – und finde die Ursache nicht.
        Hast du von Anne den sourcecode erhalten und konntest ihn analysieren?

        Allerdings habe ich gelesen, dass auch ein fehlerhaftes XML-File dafür verantwortlich sein kann. Und tatsächlich ist bei mir im AndroidManifest.xml eine mir nichts sagende Warnung im application Teil:

        “App is not indexable by Google Search; consider adding at least one Activity with an ACTION-View intent filler”.

        Viele Grüße
        Ronny

        1. Post
          Author
          Chris

          Hallo Ronny,

          den Quellcode von Anne habe ich nicht erhalten. Wenn Du möchtest, kannst Du mir Deine Projektdateien als Zip senden. Ich würde mich dann mal auf Fehlersuche begeben.

          Viele Grüße, Chris

          1. Post
            Author
            Chris

            Zur Info: Das Problem konnte gelöst werden. Es war ein winziger Tippfehler im Quellcode der dimens.xml Datei von Ronny. Es war 16p anstelle von 16dp angegeben. Dadurch konnte Android Studio den Build-Vorgang nicht abschließen und die Ressourcenvariable R nicht auflösen. Nach Beheben des Tippfehlers funktionierte der Quellcode wieder wie erwartet.

  21. Christian

    Hi Chris,

    Danke für das Tutorial – sehr schön!!!
    Leider hane ich beim Kompilieren einige Fehler (siehe Kommentar von Sepp):

    Error:(3) Error retrieving parent for item:
    No resource found that matches the given name
    ‘android:TextAppearance.Material.Widget.Button.Inverse’.

    Error:(18) Error retrieving parent for item:
    No resource found that matches the given name
    ‘android:Widget.Material.Button.Colored’.

    Error:Execution failed for task ‘:app:processDebugResources’.
    > com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException:
    Process ‘command ‘C:\Users\Nutzer\AppData\Local\Android\sdk\build-tools\22.0.1\aapt.exe” finished with non-zero exit value 1

    Hat irgendjemand einen Tipp?
    Danke,
    Christian

    1. Post
      Author
      Chris

      Hallo Christian,

      es könnte an einem Tippfehler in einer der XML-Dateien. Wenn Du möchtest, kannst Du mir Deine Projektdateien als Zip senden. Ich würde mich dann mal auf Fehlersuche begeben. Vielleicht kann ich die Ursache des Problems finden.

      Viele Grüße, Chris

      1. Christian

        Hallo Chris,

        das fände ich SUPER, aber wie hänge ich ein Attachment (ZIP) an???

        Christian

        1. Christian

          Hallo Chris,

          habe die Emailadresse gefunden. Wäre super, wenn du dir die Mühe machen würdest – DANKE!!!

          Christian

      2. Post
        Author
        Chris

        Zur Info: Das Problem konnte behoben werden. Es lag an einem Tippfehler im Package-Namen des Android Projekts von Christian. Als der Package-Name korrekt geschrieben wurde lief die App wie erwartet.

  22. Andre

    Hi!
    Danke für das Tutorial. Ich möchte es sehr gern Schritt für Schritt durchgehen und der Einstieg gefällt mir außerordentlich gut und ich habe schon so einige getestet. Aber leider hakt es auch bei mir am “package R”. Zuerst habe ich einen dummen Fehler begangen und im Code immer deinen Projektpfad angegeben, also auch in der Java-Datei “de.programmierenlernen… .app”. Aber auch nach Aktualisierung der Software und der ausbesserung meines Fehlers ändert sich nix daran, dass am R-Paket gemeckert wird. Es betrifft also die beiden Dateien im Ordner (in meinem Fall) “de.meinewebseite.www.aktiehq.app”, die MainActivity und die MainActivityFragment.
    Grüße und nochmals Danke.

    1. Post
      Author
      Chris

      Hallo Andre,

      meistens ist das Problem ein Tippfehler in einer der XML-Dateien. Ohne Deinen Quellcode zu sehen, ist es aber nicht möglich den Fehler zu lokalisieren. Wenn Du möchtest, kannst Du mir Deine Projektdateien als Zip senden. Die E-Mailadresse steht im Impressum. Ich würde mich dann mal auf Fehlersuche begeben. Vielleicht kann ich die Ursache des Problems finden.

      Viele Grüße, Chris

      1. Post
        Author
        Chris

        Zur Info: Das Problem konnte behoben werden. Es lag eine fehlerhafte Package Angabe in der activity_main.xml Layoutdatei im Quellcode von Andre vor, wodurch die MainActivityFragment-Klasse nicht gefunden werden konnte. Nachdem der korrekte vollqualifizierende Klassenname in der XML-Layoutdatei angegeben wurde, war der Fehler behoben.

        Solche kleinen Tippfehler in XML-Dateien führen oft zu dem Problem mit der Ressourcendatei R, die dann nicht mehr aufgelöst werden kann.

  23. Max

    Hallo ;)

    ich versuche gerade, die App im AVD zu starten. Leider passiert nichts, außer, dass das Tablet in Dauerschleife hochfährt (im Android Monitor wiederholt sich immer wieder alles nachdem es 2 Minuten durchlief). Außerdem steht unter “Run” folgende Meldung: HAXM is not working and emulator runs in emulation mode. Wäre über Hilfe dankbar!

    Liebe Grüße,
    Max

    1. Post
      Author
  24. Cedric

    Hallo,
    ich habe jetzt alles soweit fertig will die App starten, dieses geht jedoch leider nicht. Es kommt immer folgende Fehlermeldung:
    Error:A problem occurred configuring project ‘:app’.
    > Could not resolve all dependencies for configuration ‘:app:_debugCompile’.
    > Could not find any version that matches com.android.support:appcompat-v7:10.+.
    Versions that do not match:
    23.1.1
    23.1.0
    23.0.1
    23.0.0
    22.2.1
    + 11 more
    Searched in the following locations:
    https://jcenter.bintray.com/com/android/support/appcompat-v7/maven-metadata.xml
    https://jcenter.bintray.com/com/android/support/appcompat-v7/
    file:/C:/Users/Cedric/AppData/Local/Android/sdk/extras/android/m2repository/com/android/support/appcompat-v7/maven-metadata.xml
    file:/C:/Users/Cedric/AppData/Local/Android/sdk/extras/google/m2repository/com/android/support/appcompat-v7/maven-metadata.xml
    file:/C:/Users/Cedric/AppData/Local/Android/sdk/extras/google/m2repository/com/android/support/appcompat-v7/
    Required by:
    AktieHQ:app:unspecified

    Ich kann allerdings auch nur beim “Virtual Devices” die API 23 erfolgreich mit einem typen verbinden, ich habe mir schon sämtliche andere API`s runter geladen, doch auch die funktionieren nicht. Es kommt immer der Fehlermeldung: “Faild to load”.

    Was kann ich jetzt noch machen ?

    Super Anleitung :)

    MfG Cedric

    1. Cedric

      Im “build.gradle” wird mir außerdem folgender Fehler ausgeworfen:

      dependencies {
      compile fileTree(dir: ‘libs’, include: [‘*.jar’])
      testCompile ‘junit:junit:4.12′
      compile ‘com.android.support:appcompat-v7:10.+’

      letztere Zeile ist rot unterstrichen

  25. Michel

    Hi Chris,
    ein paar Freunde und ich müssen für die Schule eine App programmieren und dein Tutorial ist dabei sehr hilfreich. Jedoch haben wir momentan auch das Problem, dass “R” nirgends deklariert ist. Es würde uns freuen, wenn du dir unsere App auch mal ansehen könntest und uns eventuell weiterhelfen könntest.

    1. Post
      Author
      Chris

      Hallo Michael,

      dir Ressourcenvariable R muss nicht von uns deklariert werden. Wenn “R” nicht aufgelöst werden kann, liegt meist ein Tippfehler in einer der XML-Dateien vor. Wenn Ihr möchtet, könnt Ihr mir Eure Projektdateien als ZIP per E-Mail zusenden. Ich werde dann mal drüber schauen, vielleicht kann ich den Fehler finden. Die E-Mail Adresse kannst Du im Impressum finden.

      Viele Grüße, Chris

  26. jozo

    Hi Michael,

    vielen Dank für dein tolles Tutorial. Ich habe es schrittweise immer in mein code kopiert und bekomme folgende Fehlermeldung: cannot find symbol variable menu_main. Es ist bis auf den Appnamen genauso wie bei dir.

    1. Post
      Author
      Chris

      Hallo Jozo,

      es ist schwierig den Fehler ohne Quellcode zu finden. Wenn Du möchtest, kannst Du mir Deine Projektdateien als ZIP per E-Mail zusenden. Ich werde dann mal drüber schauen, vielleicht kann ich den Fehler finden. Die E-Mail Adresse kannst Du im Impressum finden.

      Viele Grüße, Chris

    2. reinhard

      Hi jozo,

      der Fehler kommt z.B. wenn deine menu_main.xml nicht im “menu”-Verzeichnis liegt, sondern (das war mein Test) im “layout”-Verzeichnis.

  27. Linus

    Hi Chris,
    erstmal bedanke ich mich für das Tutorial, es hat mir sehr beim Einstieg zu Android Studio geholfen. Da ich es in diesem Tutorial nicht gefunden habe, würde ich gerne wissen, ob es möglich ist, dass man z.B. auf einen Button drückt und dann zu einer Internetseite weitergeleitet wird?

    Grüße Linus

    1. Post
      Author
      Chris

      Hallo Linus,

      das ist ohne großen Aufwand mit Android möglich. Einfach für den vorgesehenen Button einen ClickHandler registrieren. Mit dem ClickHandler kann dann auf Button-Klicks reagiert werden und bspw. mit Hilfe eines impliziten Intents eine vorgegebene URL im Browser geöffnet werden.

      In Teil 12 werden implizite Intents ausführlich behandelt.

      Ich hoffe die Infos helfen Dir ein bisschen weiter.

      Viele Grüße, Chris

    1. Post
      Author
  28. Manfred

    Hurra,
    dank diesem Tutorial habe ich meine 1. app erstellt und zwar mit der neuesten Android-Version 23 .

    1. Post
      Author
  29. Daniel

    Ich finde es klasse wie Ihr das hier präsentiert! und ich versuche mich gerade an dem Tutorial, bin aber ein absoluter Anfänger.
    Beim versuch euer Tutorial umzusetzen ergibt sich bei mir aber ein Problem welches ich so nicht lösen kann, vlt könnt Ihr helfen?

    Ich hänge in folgender Zeile aus der MainActivityFragment.java mit einer Fehlermeldung fest.

    return inflater.inflate(R.layout.fragment_main, container, false);

    Das R wird bei mir Rot und möchte ne weiterführende aktion
    Würd mich also über einen Tipp freuen!
    Gruß
    Daniel

    1. Post
      Author
      Chris

      Hallo Daniel,

      wenn “R” nicht aufgelöst werden kann, liegt meist ein Tippfehler in einer der XML-Dateien vor. Wenn Du möchtest, kannst Du mir Deine Projektdateien als ZIP per E-Mail zusenden. Ich werde dann mal drüber schauen, vielleicht kann ich den Fehler finden. Die E-Mail Adresse kannst Du im Impressum finden.

      Viele Grüße, Chris

      1. Daniel

        Hallo Chris,
        danke für die Antwort und das Angebot.
        Hab es gestern noch in den Griff bekommen. Also läuft dieser Teil des Tutorial jetzt!
        Gruß und weiter so mit den tollen Tutorials!
        Daniel

        1. Post
          Author
  30. Tobias

    Hi Chris,

    ersteinmal großes Lob an dich, gibt kaum eine Seite die den Einstieg in die App-Programmierung so einfach werden lässt wie diese. Bin auch noch blutiger Anfänger, gestern damit begonnen.

    Jetzt hab ich allerdings ein Problem:
    An dem Punkt wo wir unsere Layout-Datei “fragment_main-xml” öffnen sollen , wird bei mir leider kein Code angezeigt, oder die Fläche, wo er hinsoll. Stattdessen steht weiter unten nur:

    *Rendering Problems
    Exeption raised during rendering:
    com.android.ide.common.rendering.api.LayoutlibCallback.getXmlFileParser(Ljava/lang/String;)Lorg/xmlpull/v1/XmlPullParser;

    Hast du ne Ahnung was das bedeutet? Vielen Dank schonmal,
    Greets

      1. Post
        Author
        Chris

        Hallo Tobias,

        schön wenn es jetzt funktioniert. Bei Android können kleine Details große Auswirkungen haben.

        Viele Grüße, Chris

  31. Claudia

    Hey
    eure Seite ist wirklich Klasse, ein riesen Lob!
    einfach nur top für Einsteiger, super Erklärungen und alles Schritt für Schritt .
    Hut ab!

    Leider funktioniert bei mir der Code seit den Fragmenten nicht mehr.
    diverse Teile sind rot, zb das bekannte “R” und “Fragment” im MainActivityFragment.
    aber auch die MainActivity hat viele rote Stellen zb “ActionBarActivity”.

    Könnt Ihr mir da weiterhelfen ?
    ich weiss dass die Antwort ” Schick mir den Code” sein könnte, allerdings ist mein Code 1:1 wie eurer. nichts abgetippt, Schreibfehler sind also eher unwahrscheinlich..

    gibt es da andere Probleme? vielleicht mit Versionen o.Ä.
    das Tutorial ist ja schon etwas älter, hab die meistens Programme auf neueren Stand..

    Eine Rückmeldung von euch wäre super!
    Liebe Grüsse aus der Schweiz
    Claudia

    1. Post
      Author
      Chris

      Hallo Claudia,

      danke für Dein Lob!

      Wenn die Ressourcenvariable R nicht mehr aufgelöst werden kann, dann liegt meist ein Tippfehler in einer der XML-Dateien vor. Die Tippfehler sind für Einsteiger sehr schwer zu finden, daher frage ich meist direkt nach den Projektdateien, das reduziert den Zeitaufwand deutlich. Mit den Quellcode der Leser konnte ich bisher immer schnell den Tippfehler finden. Es waren bisher immer Tippfehler.

      Also wenn Du möchtest, kannst Du uns Deine Projektdateien als ZIP per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Die Fehlersuche mache ich übrigens absolut kostenlos.

      Viele Grüße, Chris

    1. Post
      Author
  32. Monica

    Hallo!
    Sehr übersichtliches Tutorial. Hab jetzt alles wie in der Anleitung gemacht bekomme nur bei der Anzeige immer diese Fehlermeldung. Wo könnte der Fehler liegen?

    com.android.ddmlib.AdbCommandRejectedException: device ‘emulator-5554′ not found
    Error while Installing APK

    Danke für die Hilfe.
    Monica

    1. Post
      Author
      Chris

      Hallo Monica,

      danke für Dein Lob!

      Ich hatte diese Fehlermeldung bisher noch nicht, kann daher leider keine direkte Lösung vorschlagen. Aber bei StackOverflow wurde dieses Problem schon von mehreren Nutzern besprochen.

      Ich habe einige Links gefunden, die Dir eventuell weiterhelfen können:

      Bei Einigen haben die Befehle adb kill-server und dann adb start-server geholfen.

      Viele Grüße, Chris

  33. PeterK

    Hallo Chris,

    ein sehr ausführliches Tutorial. Leider hänge ich im Teil 2 fest bei der Emulation.
    Script komplett befolgt. AVD gestartet. Im Studio bekomme ich die Fehlermeldungen:

    Wo könnte der Fehler liegen? Danke.

    VG PeterK

    1. Post
      Author
      Chris

      Hallo Peter,

      hmm, schwer zu sagen. Es liegt auf jeden Fall ein Problem mit dem verfügbaren Arbeitsspeicher vor. Du kannst einmal versuchen die RAM Einstellungen für das erstellte Android Virtual Device (AVD) auf z.B. 750 MB zu reduzieren.

      1. Dazu den AVD Manager im oberen Menü mit Tools>Android>AVD Manager öffnen.
      2. Dann auf das Stift-Symbol des erstellten AVDs klicken: AVD Einstellungen ändern (Bild)
      3. Dann die RAM Einstellung etwas verringern: RAM Einstellung eines AVD (Bild)

      Vielleicht hilft das schon…

      Viele Grüße, Chris

  34. alex

    ich habe ein problem und zwar wird bei mir gesagt das das R nicht vorhanden wird
    Bitte helft mir

    1. Post
      Author
      Chris

      Hallo Alex,

      wenn die Ressourcen-Variable R nicht aufgelöst werden kann, dann liegt meist ein Tippfehler in einer der XML-Dateien vor oder der Package-Name ist nicht überall gleich.

      Viele Grüße, Chris

  35. Jasmin

    Hey,
    von mir gibt es ein dickes Lob. Das Tutorial ist echt super für Anfänger.
    Ich hab das Tutorial genau befolgt, bekomme aber beim Ausführen der App jedes Mal die Meldung:

    Error:Execution failed for task ‘:app:transformClassesWithDexForDebug’.
    > com.android.build.api.transform.TransformException: java.lang.RuntimeException: com.android.ide.common.process.ProcessException: java.util.concurrent.ExecutionException: com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException: Process ‘command ‘C:\Program Files\Java\jdk1.7.0_79\bin\java.exe” finished with non-zero exit value 1

    und

    Error:java.lang.UnsupportedClassVersionError: com/android/dx/command/Main : Unsupported major.minor version 52.0

    Kann mir vielleicht jemand helfen?

    Danke schon mal :)
    Jasmin

    1. Post
      Author
      Chris

      Hallo Jasmin,

      danke für Dein Lob!

      Wenn Du möchtest, kannst Du mir Deine Projektdateien als ZIP per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich den Fehler finden kann.

      Viele Grüße, Chris

  36. Tobi

    Hallo Chris,

    das Tutorial ist wirklich super, wenn man vorher gar nicht mit Android Studio gearbeitet hat – sehr ausführlich und perfekt für Anfänger :)

    Nur habe ich, wie viele andere auch, ein Problem mit dem Symbol R – in meinen XML Dateien konnte ich keinen Fehler finden und clean/rebuild löst das Problem auch nicht. Kann das eine andere Ursache haben?

    Viele Grüße
    Tobi

    1. Tobi

      Hallo,

      ich bins wieder, Tobi – hab den Fehler gefunden :)
      Es war natürlich doch ein Fehler in einer XML-Datei – ein vergessenes “>”.

      Danke nochmal für das super Tutorial!

      Viele Grüße
      Tobi

      1. Post
        Author
        Chris

        Hallo Tobi,

        danke für Dein Lob!

        Ja in die XML-Dateien scheichen sich sehr schnell Tippfehler ein. Schade, dass Android Studio das nicht besser anzeigt. Manchmal ist es für Beginner deswegen zum Verzweifeln. Aber mit der Zeit lernt man dazu und wird Frust resistenter.

        Viele Grüße, Chris

  37. Uwe

    nun doch noch eine Frage,
    was bedeutet dieses Problem ?
    Rendering Problems Exception raised during rendering: android.graphics.drawable.VectorDrawable_Delegate.nCreateTreeFromCopy(JJ)J (Details)

    es funktioniert alles, möchte jedoch schon wissen, was dieses Rendering Problem bedeutet, offensichtlich im Modul menue_main.xml

    1. Uwe hohnstock

      Hallo Chris,
      ich habe den x86_64 geladen und installiert, nun bekomme ich keine Fehlermeldung mehr
      LG Uwe

  38. Kaladial

    Achtung: auch bei 6.2 muss auf den richtigen Android:Namen (Package) geachtet werden ansonsten geht die app nicht und stürzt ab!

    Ich habe bei meiner version das Scale in Punkt 9 ( letztes Bild ) nicht. gibt es da andere Möglichkeiten?
    Bei mir liegt das Tab immer auf der Seite und ich muss es erst rum drehen

    1. Post
      Author
      Chris

      Hallo Kaladial,

      die anzuwendende Skalierung kann auch manuell vorgegeben werden. Hier werden einige Möglichkeiten dazu beschrieben.

      Viele Grüße, Chris

  39. Frank Krätzig

    Hallo leute, ich habe die App auf einem Android handy vor der 4.4 Version ausprobiert.
    Wenn ihr den Menü button nicht seht, dann probiert mal folgendes aus in der OnCreate Routine:

    1. Post
      Author
  40. Johannes Huber

    Hallo,
    erstmal danke für das Tutorial, ist super verständlich und gut gemacht!
    Dennoch habe ich ein Problem beim Starten des Programms. In dem AVD wird nur
    “Unfortunately, de.programmierenlernenhq.aktiehq.app has stopped”
    angezeigt. Das steht bei mir unter Run:

    E/AndroidRuntime: FATAL EXCEPTION: main
    Process: de.programmierenlernenhq.aktiehq.app, PID: 6193
    java.lang.RuntimeException: Unable to start activity de.programmierenlernenhq.aktiehq.app.MainActivity:
    java.lang.IllegalStateException: You need to use a Theme.AppCompat theme (or descendant) with this activity.
    .
    .
    .
    Caused by: java.lang.IllegalStateException: You need to use a Theme.AppCompat theme (or descendant) with this activity.
    at android.support.v7.app.AppCompatDelegateImplV7.createSubDecor(AppCompatDelegateImplV7.java:343)
    .
    .
    .
    Application terminated.

    Kann mir da jemand helfen?

    Grüße, Johannes

    1. Post
      Author
      Chris

      Hallo Johannes,

      ich habe die lange Fehlermeldung in deinem Kommentar etwas gekürzt. Das gewählte Theme scheint die Absturzursache zu sein. Laut Fehlermeldung muss als Theme ein Theme.AppCompat-Theme ausgewählt werden. Welches ist denn bei dir ausgewählt? In der styles.xml Datei kannst du nachschauen welches Theme als AppTheme festgelegt wurde.

      Wenn du möchtest, kannst Du mir deine styles.xml Datei per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich etwas herausfinden kann.

      Viele Grüße, Chris

  41. Berny

    Bis jetzt hat alles wunderbar gefunkt. Hohes Lob für die Anleitung.
    Nur im MainActivity wird in der Zeile
    public class MainActivity extends ActionBarActivity
    das ActionBarActitvity automatisch durchgestrichen und eine Meldung erscheint:
    “…is deprecated; useAppCompactActivity”.
    Das Build war trotzdem erfolgreich auch ohne Änderung. Aber bei der Emulation gab es : “Error running MainActivity: The activity must be exported or contain an intent-filter”
    Was ist da zu tun??
    Gruß Berny

    1. Post
      Author
      Chris

      Hallo Berny,

      danke für’s Lob!

      Wahrscheinlich liegt ein Fehler in der AndroidManifest.xml Datei vor. Wenn du möchtest, kannst Du mir deine AndroidManifest.xml Datei per E-Mail zusenden. Die E-Mail Adresse kannst Du im Impressum finden. Ich schaue dann mal, ob ich etwas herausfinden kann.

      Viele Grüße, Chris

  42. Berny

    Nachtrag zu meiner Anfrage von heute:
    Schließlich erschien folgende Meldung:
    Error running app: Default Activity not found.
    Enable smart keyboard internationalization for Studio.: We have found out that you are using a non-english keyboard layout. You can enable smart layout support for Deutsch language.You can change this option in the settings of Studio more…
    Gruß Berny

    1. Post
      Author
      Chris

      Hallo Berny,

      die Meldung mit dem smart keyboard Hinweis ist nicht kritisch, sondern passt die Tastenkürzel (keyboard shortcuts) von Android Studio an das deutsche Tastaturlayout an.

      Viele Grüße, Chris

  43. Berny

    Hallo Chris,
    nach Umbenennung in “AppCompactActivity” war der Fehler verschwunden und alles lief nach Wunsch.
    Besten Dank für die schneller Beratung.
    Gruß Berny

  44. Denis

    Hi Christian,

    spitze Tutorial, gefällt mir bisher ganz gut. Danke dafür und mach bitte weiter. :D
    Wie es in der Informatik nunmal so ist, hat das kompilieren auch bei mir nicht auf Anhieb hingehauen. Ich hatte auch das Problem mit der Ressourcenvariable R. Gelöst hat sich das Problem durch einen Blick in die Gradle-Datei. Der Fehler lag in folgender Zeile:

    compile ‘com.android.support:appcompat-v7:23.4.0′

    Die Lösung war die Android Version von 25.1.0 auf 23.4.0 anzupassen. Wär vielleicht ganz gut, wenn du das nochmal explizit erwähnen könntest.

    Liebe Grüße

    1. Post
      Author
      Chris

      Hallo Denis,

      danke für die lobenden Worte!

      Die Java-Bibliothek appcompat-v7 stellt die Kompatibilität der App zu älteren Android Version sicher. Beim Kompilieren sollte keine Version verwendet werden, die sich von der verwendeten compileSDKVersion unterscheidet.

      Viele Grüße, Chris

    2. Carsten Brauer

      Merci! Bei mir lag es ebenfalls an dieser Zeile, allerdings stand dort 25.1.1, während der Rest des Projektes auf 23.0 stand! :):):) Nun habe ich dort 23.0.0 eingetragen und zack! Läuft.

  45. Carsten Brauer

    Leider auch hier eine Fehlermeldung beim Kompilieren: AS 2.2.3, in der build.gradle sieht es so aus:
    apply plugin: ‘com.android.application’

    android {
    compileSdkVersion 23
    buildToolsVersion “23.0.3”
    defaultConfig {
    applicationId “org.brauer_it.aktiehq.app”
    minSdkVersion 10
    targetSdkVersion 23
    versionCode 1
    versionName “1.0”
    testInstrumentationRunner “android.support.test.runner.AndroidJUnitRunner”
    }
    buildTypes {
    release {
    minifyEnabled false
    proguardFiles getDefaultProguardFile(‘proguard-android.txt’), ‘proguard-rules.pro’
    }
    }
    }

    dependencies {
    compile fileTree(dir: ‘libs’, include: [‘*.jar’])
    androidTestCompile(‘com.android.support.test.espresso:espresso-core:2.2.2′, {
    exclude group: ‘com.android.support’, module: ‘support-annotations’
    })
    compile ‘com.android.support:appcompat-v7:25.1.1′
    testCompile ‘junit:junit:4.12′
    }

    Die Fehlermeldung:
    Information:Gradle tasks [:app:clean, :app:generateDebugSources, :app:mockableAndroidJar, :app:prepareDebugUnitTestDependencies, :app:generateDebugAndroidTestSources, :app:assembleDebug]
    C:\Users\Carsten\AndroidStudioProjects\AktieHQ\app\build\intermediates\res\merged\debug\values-v24\values-v24.xml
    Error:(3) Error retrieving parent for item: No resource found that matches the given name ‘android:TextAppearance.Material.Widget.Button.Borderless.Colored’.
    Error:(4) Error retrieving parent for item: No resource found that matches the given name ‘android:TextAppearance.Material.Widget.Button.Colored’.
    Error:(3) Error retrieving parent for item: No resource found that matches the given name ‘android:TextAppearance.Material.Widget.Button.Borderless.Colored’.
    Error:(4) Error retrieving parent for item: No resource found that matches the given name ‘android:TextAppearance.Material.Widget.Button.Colored’.
    Error:Execution failed for task ‘:app:processDebugResources’.
    > com.android.ide.common.process.ProcessException: Failed to execute aapt
    Information:BUILD FAILED
    Information:Total time: 4.858 secs
    Information:5 errors
    Information:0 warnings
    Information:See complete output in console

      1. Post
        Author
        Chris

        Hallo Carsten,

        momentan kann ich mich aus Zeitgründen leider kaum den Kommentaren widmen, daher kommt meine Antwort so spät :(

        Schön das Du den Fehler beheben konntest. Die build.gradle Datei ist bei jedem Leser etwas anders, dadurch kann es schnell zu Fehlermeldungen beim Kompilieren kommen.

        Viele Grüße, Chris

  46. Paul

    Hallo erstmal richtig geiles Tutorial aber ich habe ein “kleines” Problem mir wird auf meinem Handy und Virtuel device kein Text ausgegeben aber die app öffnet sich auch ganz normal . Kann mir bitte jemand helfen :D

      1. Post
        Author

Hinterlasse eine Antwort

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