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


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.

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:

strings.xml

<string name="hello_world">Hallo ProgrammierenLernenHQ World!</string>
<string name="action_settings">Settings</string>

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:

dimens.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <dimen name="activity_horizontal_margin">16dp</dimen>
    <dimen name="activity_vertical_margin">16dp</dimen>

</resources>

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:

menu_main.xml

<?xml version="1.0" encoding="utf-8"?>

<menu
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
tools:context=".MainActivity">

<item
    android:id="@+id/action_settings"
    android:title="@string/action_settings"
    android:orderInCategory="100"
    app:showAsAction="never" />

</menu>

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 Directory klicken (Achtung: nicht auf „Android resource directory“ klicken).
android studio project layout folder

Erstellen des Layout-Ordners in Android Studio

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

  • Enter new directory name: layout

Anschließend bestätigen wir den Dialog mit einem Klick auf den OK-Button.

android studio project layout directory

Der New Directory Dialog mit den einzutragenden Namen für den Layout-Ordner

Nun legt Android Studio das 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:

fragment_main.xml

<?xml version="1.0" encoding="utf-8"?>

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin"
    tools:context=".MainActivityFragment">

    <TextView
        android:text="@string/hello_world"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</FrameLayout>

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:

MainActivityFragment.java

package de.programmierenlernenhq.aktiehq.app;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class MainActivityFragment extends Fragment{

    public MainActivityFragment() {
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {

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

    }

}

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:

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>

<fragment
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/fragment"
    android:name="de.programmierenlernenhq.aktiehq.app.MainActivityFragment"
    tools:layout="@layout/fragment_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

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:

MainActivity.java

package de.programmierenlernenhq.aktiehq.app;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }


    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        if (id == R.id.action_settings) {

            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

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:

AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="de.programmierenlernenhq.aktiehq.app">

    <application
        android:allowBackup="true"
        android:label="@string/app_name"
        android:icon="@mipmap/ic_launcher"
        android:theme="@style/AppTheme">

        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>

</manifest>
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

Hinweis: Dieser Abschnitt ist informativ. Ihr müsst und solltet daher auch keine Änderungen an der build.gradle Datei vornehmen.

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

Folgende Werte in der Gradle-Datei sind besonders interessant:

  • minSdkVersion: 10
  • targetSdkVersion: 23

Die minSdkVersion legt fest, bis zu welcher Plattform unsere App noch kompatibel ist. Der Wert API 10 steht für eine sehr alte Version von Android (Gingerbread), welche Android 2.3.3 entspricht. Bei euch wird wahrscheinlich ein höherer Wert stehen.

Die targetSdkVersion legt fest, für welche Zielplattform wir unsere App entwickeln wollen. Hier 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 148

  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. 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

      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

    2. Hallo Chris,

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

      Schöne Grüße, Alfred

    3. Post
      Author

      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. 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

      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. 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

      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. 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

      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. 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. 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

      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. 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. Hallo,

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

    Sorry.

  17. 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. 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

      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. 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

      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. 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

      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

    2. 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

    3. Post
      Author

      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

    4. Post
      Author

      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. Hi Chris,

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

    MainActivity.java

    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

      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

    2. Hallo Chris,

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

      Christian

    3. Hallo Chris,

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

      Christian

    4. Post
      Author

      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. 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

      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

    2. Post
      Author

      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. 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
    2. Hey Chris,

      vielen Dank, es ist des Rätsels Lösung :-)!

      Liebe Grüße,
      Max

  24. 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. 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

    2. Post
      Author

      Hallo Cedric,

      die Appcompat Support Library ist in deinem Quellcode nicht korrekt angegeben worden. Es müsste bspw. lauten:

      compile 'com.android.support:appcompat-v7:23.1.1'
      

      Viele Grüße, Chris

  25. 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

      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. 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

      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. 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. 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

      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

      Hallo Hans,

      Super! Dann viel Spaß und gutes Gelingen bei den weiteren Lektionen.

      Viele Grüße, Chris

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

    1. Post
      Author
  29. 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

      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

    2. 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

    3. Post
      Author
  30. 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. Okay, habe festgestellt dass ich dort etwas überlesen hatte, alles gut!

    2. Post
      Author

      Hallo Tobias,

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

      Viele Grüße, Chris

  31. 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

      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

      Hallo Frank,

      danke für’s Lob! Schön wenn alles funktioniert hat 🙂

      Viele Grüße, Chris

  32. 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

      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. 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:

    C:\Users\PeterK\AppData\Local\Android\Sdk\tools\emulator.exe -scale 0.5 -netdelay none -netspeed full -avd Nexus_9_API_23_Tablet
    emulator: WARNING: VM heap size set below hardware specified minimum of 192MB
    Could not load func glBindFramebuffer
    emulator: WARNING: Setting VM heap size to 384MB
    Could not load func glGenFramebuffers
    emulator: WARNING: Classic qemu does not support SMP. The hw.cpu.ncore option from your config file is ignored.
    Could not load func glFramebufferTexture2D
    Could not load func glCheckFramebufferStatus
    Could not load func glDeleteFramebuffers
    Could not load func glIsRenderbuffer
    Could not load func glBindRenderbuffer
    Could not load func glDeleteRenderbuffers
    Could not load func glGenRenderbuffers
    Could not load func glRenderbufferStorage
    Could not load func glGetRenderbufferParameteriv
    Could not load func glFramebufferRenderbuffer
    emulator: WARNING: Requested RAM size of 1536MB is too large for your environment, and is reduced to 864MB.
    Cannot set up guest memory 'android_arm': Invalid argument
    

    Wo könnte der Fehler liegen? Danke.

    VG PeterK

    1. Post
      Author

      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. ich habe ein problem und zwar wird bei mir gesagt das das R nicht vorhanden wird
    Bitte helft mir

    1. Post
      Author

      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. 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

      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. 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. 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

    2. Post
      Author

      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. 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. Hallo Chris,
      ich habe den x86_64 geladen und installiert, nun bekomme ich keine Fehlermeldung mehr
      LG Uwe

  38. 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

      Hallo Kaladial,

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

      Viele Grüße, Chris

  39. 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:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);
      try {
        ViewConfiguration config = ViewConfiguration.get(this);
        Field menuKeyField = ViewConfiguration.class.getDeclaredField("sHasPermanentMenuKey");
        if (menuKeyField != null) {
          menuKeyField.setAccessible(true);
          menuKeyField.setBoolean(config, false);
        }
      } catch (Exception ex) {
        // Ignore
      }
    }
    
    1. Post
      Author
  40. 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

      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. 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

      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. 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

      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. 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. Hi Christian,

    spitze Tutorial, gefällt mir bisher ganz gut. Danke dafür und mach bitte weiter. 😀
    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

      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. 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. 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'.
    &gt; 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

      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. 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 😀

    1. Hat sich erübrigt hab es irgendwie geschaft eine datei zu löschen 😀

    2. Post
      Author
  47. Hallo Chris,

    kann mich hier den Loben nur anschließen. Wirklich toll gemacht und ich bin froh Dein Tutorial gefunden zu haben.

    …und klar, ich hab auch ein Problem: Bei mir kommt beim virtuellen Tablet wie auch bei meinem realen Samsung S3 (Androit 4.2.2) nach der Installation: „App angehalten“. Hast Du vielleicht eine Idee wegen der Ursache? Grüße, Funda

  48. Hallo Chris,

    Danke für gelungenes Tutorial. Es ist leicht verständlich, hat präzise Beschreibungen, aber gleichzeitig nicht zu detailliert.
    Habe ein Problem und komme nicht weiter, vielleicht kann mir jemand helfen?
    Meine App läßt sich nicht auf dem AVD emulieren. Kompilieren funktioniert fehlerfrei und AVD läuft im Hintergrund. Trotzdem erscheint das „Select Deployment Target“ Fenster nicht.

  49. Hallo Chris!

    Ich habe ein Problem. Ich bin derzeit bei Kapitel 11.0, bei deinem Tutorial und würde nun gerne meine App im Emulator starten.
    Allerdings taucht bei dem Klicken auf den „Run ‚app‘ „-Button eine Fehlermeldung
    „Error running app: Default Activity not found“ auf. Der Emulator ist im Voraus wie im Tutorial angewiesen am Laufen. Auch den Code habe ich komplett noch einmal abgesucht, aber keinen Fehler gefunden. Kein Tutorial bisher war so ausführlich und verständlich erklärt.
    Es wäre schade, wenn ich wegen dieser Fehlermeldung aufgeben müsste.

    Wäre toll, wenn Du mir bei der Lösung des Problems helfen könntest.
    Ich habe nach der Fehlermeldung auch schon gegoogelt, aber selbst leider keine Lösung gefunden.

    1. Post
      Author

      Hallo Niels,

      ist die MainActivity in der AndroidManifest.xml Datei als Start-Activity festgelegt worden?

      Viele Grüße, Chris

  50. Hallo Chris,

    vielen dank für dieses tolle Tutorial, wirklich klasse.

    Ich bin im Moment grad dabei die App auf meinem Smartphone zu testen doch leider kommt bei beim Run schon der Fehler
    „Default Aktivity not found“

    Ich habe die Quellcodes schon auf Tippfehler untersucht, habe aber nichts gefunden.

    Hättest du noch eine Idee ?

    Danke dir schon mal

    Grüße Lars

    1. Post
      Author

      Hallo Lars,

      ist die MainActivity in der AndroidManifest.xml Datei als Start-Activity festgelegt worden?

      Viele Grüße, Chris

  51. Guten Tag,
    erst einmal ein großes Lob an die Seite, die ist einfach top! Sehr detailliert geschildert, so dass beim verstehen keinerlei Fragen aufkommen.
    Nun gab es jedoch trotzdem ein Problem, welches ich mir vorerst nicht erklären kann.
    Ich befolgte die Anweißungen wie geschildert, als ich die App jedoch starten wollte, schloss sie sich von selbst mit der Fehlermeldung „Leider wurde das Programm beendet“…sowohl an meinem richtigen Handy (LG G4) als auch beim Virtuel Device war dies der Fall :/

    Mfg
    Fabian

    1. Post
      Author

      Hallo Fabian,

      dies bedeutet, dass die App an einer Stelle im Quellcode abstürzt. Mit der Fehlermeldung, dem StackTrace, kann die Ursache dafür lokalisiert werden.

      Viele Grüße, Chris

  52. Danke, diese Seite hat mir sehr geholfen . . . zu verstehen, dass programmieren für mich wohl nichts ist obwohl es meine Kreativität erst veredeln würde.

    Sie hat mir geholfen heraus zu finden, dass man selbst wenn man alles haarklein Buchstabe für Buchstabe exakt so macht wie es beschrieben wird, die Texte ausschließlich unverändert kopiert, der App den selben Namen und die selbe internetadresse gibt, das .app hinten anfügt . . man immernoch nach Meinung des Programms „gravierende“ Fehler im Code ins Gesicht geschlagen bekommt für die die „passenden“ Lösungsvorschläge auch aus irgendeiner anderen Galaxis sind.

    Ich habe schon ein paar kleine Apps gebastel und Kleinigkeiten wie Animationen, Knöpfe und Backgrounds getestet, aber sobald ich ein komplett leeres Projekt anfange fliegen die Räder aus unerfindlichen Gründen sofort ab und das Projekt brennt und zischt. . egal wie exakt ich die Vorgaben kopiere.

    Schon beim erstellen der MainActivityFragment endet hier alles.
    Die erste Zeile . .
    package de.programmierenlernenhq.aktiehq.app;
    versteht das Programm absolut nicht mehr obwohl das Programm so heißt und auch die selbe Internetdomain hat. Steht auch im Manifest so. Durch kopieren auch gesichert. Keine Rechtschreibfehler.

    Ebenfalls sind auch alle R’s (wie in (R.layout.fragmentblabla ) ab und zu (je nach Laune) auch graaaviierrrende „Fehler“ obwohl alles EXAKT so angelegt ist wie beschrieben. Alles stundenlang überprüft und mehrmals neu angefangen . . und ehrlich gesagt auch AndroidStudio neu installiert.
    Das ganze Javazeug sowieso alles neu installiert.

    Ich weiß nicht warum Programmierer solche gigantischen, chaotische Codebäume errichten die absolut keinen Sinn ergeben und über so viele Wege erleichtert werden könnten. In einem Graphikprogramm ziehe ich auch einen Kreis und schreibe nicht in einer Abhandlung die x, y Koordinaten und weise dem dann 20 Datein zu damit der Kreis auch wirklich (wenigstens 40% der Zeit) erscheint . . und lasse dann alles abstürzen wenn ein Komma fehlt.

    Jetzt sitz ich da mit zig GB Krempel mehreren 10.000 Datein und vielen AppIdeen aber kann das Programm nicht dazu bringen die simpelsten Dinge einfach zu akzeptieren. Selbst WENN sie schon stumpf kopiert sind.
    Bestimmt ist irgendwo ein Kreuz bei: Nutzlose Fehler generieren in irgendeiner 12kb großen Mist-JDK Datei gesetzt oder so.

    Sorry ist für mich gerade der absolute Meltdown nach 2 Wochen rum probieren und üben.
    Meine gesamte Kreativität geht in diese Richtung. Nur das Coden will nicht.
    Trotzdem . . danke. .

    1. Post
      Author

      Hallo Arno 🙂

      ja, falls es zu Problemen kommt, ist es manchmal sehr frustrierend mit dem Programmieren. Mir hilft da oft, einfach eine Pause zu machen und etwas anderes zu erledigen. Später oder auch erst am nächsten Tag komme ich viel besser mit der Problemlösung voran.

      Viele Grüße, Chris

  53. Hallo,
    Folgender Fehler bereits nach Schritt 3

    Error:Execution failed for task ':app:processDebugManifest'.
    > Manifest merger failed : uses-sdk:minSdkVersion 10 cannot be smaller than version 14 declared in library [com.android.support:appcompat-v7:26.0.0-alpha1] C:\Users\Wolle43\.android\build-cache\556cacf1b493fd570d007f45320b5d5f95ea7ef4\output\AndroidManifest.xml
    	Suggestion: use tools:overrideLibrary="android.support.v7.appcompat" to force usage
    
  54. Ich bekomme folgende Fehlermeldung:

    08-27 09:54:41.699 22803-22803/de.programmierenlernenhq.aktiehq.app E/AndroidRuntime: FATAL EXCEPTION: main
    Process: de.programmierenlernenhq.aktiehq.app, PID: 22803
    java.lang.RuntimeException: Unable to start activity ComponentInfo{de.programmierenlernenhq.aktiehq.app/de.programmierenlernenhq.aktiehq.app.MainActivity}: android.view.InflateException: Binary XML file line #3: Binary XML file line #3: Error inflating class fragment
    at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2665)
    at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2726)
    at android.app.ActivityThread.-wrap12(ActivityThread.java)
    at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1477)
    at android.os.Handler.dispatchMessage(Handler.java:102)
    at android.os.Looper.loop(Looper.java:154)
    .....
    

    komme an der Stelle nicht weiter. woran könnte es liegen?

    1. Post
      Author

      Hallo Helge,

      wahrscheinlich liegt ein Tippfehler in einer der XML-Layout Dateien vor. Dieses Problem hatten bereits einige Leser.

      Viele Grüße, Chris

  55. Hallo,

    ich habe gerade angefangen das Tutorial zu machen. Es ist bis jetzt echt klasse. Total gut für einen totalen Anfänger wie mich.
    Ich habe aber jetzt ein Problem, ich nutze Android Studio 2.3.3 und da ist es alles ein bisschen anders. Bei mir wird z.B. die Frgment Klasse nicht gefunden:
    Es wird mir nur
    android.app.Fragment;
    statt
    android.support.v4.app.Fragment
    angeboten. Genause bei „ActionBarActivity“
    Kann ich die fehlende Bibliothek irgendwie einbauen. Kennen mich auch mit Gradle nicht aus. Die sdk version ist ja auch schon 25 und Tools 26.0.2
    Wird der Guide da noch angepasst? Da würde mich sehr freuen.

    1. Hat sich erledigt, nochmal alles neu installiert und es geht, irgendwas konnte nicht richtig runtergeladen werden.

  56. Hallo Chris,

    Ich habe dein tutorial bis zum erstellen der MainActivityFragment.java datei durchgearbeitet und jetzt folgendes Problem
    return inflater.inflate(R.layout.fragment_main, container, false);
    Bei dem r kommt bei mir ein fehler: Cannot resolve Symbol ‚R‘
    Danke für deine Hilfe jetzt schon 🙂

  57. Hallo Chris,
    ich habe ein Problem im Abschnitt 5.3 beim Quellcode der MainActivityFragment.java
    in der Zeile 18:

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

    dort wird das „R“ rot dargestellt, also anscheinend nicht erkannt.
    Da ich auch Anfänger bin und nicht weiß wofür das R steht, weiß ich auch nicht was ich zur Fehlerbehebung tun kann.

    Danke für deine Hilfe und natürlich auch für deine Website

    Grüße Tobey

  58. Hallo,

    klasse Tutorial, das beste was ich bisher gefunden habe!
    Nun bin ich ziemlich unerfahren und doch auf Hilfe angewiesen. Leider habe ich hierzu in den bisherigen Kommentaren nichts gefunden.

    Mein Problem ist, das ich zwar alles aus Teil 2 soweit nachvollziehen kann, aber beim Build laufe ich auf Fehler:

    Error:(3, 30) error: cannot find symbol class ActionBarActivity
    Error:(8, 35) error: cannot find symbol class ActionBarActivity
    Error:(10, 5) error: method does not override or implement a method from a supertype
    Error:(12, 9) error: cannot find symbol variable super
    Error:(13, 9) error: cannot find symbol method setContentView(int)
    Error:(17, 5) error: method does not override or implement a method from a supertype
    Error:(20, 9) error: cannot find symbol method getMenuInflater()
    Error:(24, 5) error: method does not override or implement a method from a supertype
    Error:(36, 16) error: cannot find symbol variable super
    

    Würde mich über Hilfe freuen.

    Gruß
    René

    1. Post
      Author

      Hallo Rene,

      das Tutorial wurde an den erforderlichen Stellen bereits überarbeitet. Zur Kontrolle wurde das gesamte Tutorial mit Android Studio 3.0.1 nachprogrammiert. Dabei hat alles wie erwartet funktioniert.

      Die beiden notwendigen Änderungen waren:

      – Verwenden der AppCompatActivity-Klasse als Superklasse der MainActivity
      – Erstellen des Layout-Ordners als ganz normales Verzeichnis (wie in Abschnitt 5.1 beschrieben)

      Viele Grüße, Chris

  59. Hallo Chris,

    ich arbeite gerade dein sehr gutes Tutorial durch um mich mit dem Studio vertraut zu machen.
    Nun zu meinem Problem:

    Ich arbeite mit Version 3.0 und habe a. beim Anlegen des Layout Ordners das Problem das dieser ohne Qualifizier nicht angelegt wird (ich habe das umgangen indem ich beim Erstellen nur Directory und nicht Android Resources Directory angegeben habe und b. das die Klasse ActionBarActivity nicht im Package vorhanden ist.

    Wie kann ich das Lösen?

    MfG Peter

    1. Post
      Author

      Hallo Peter,

      vielen Dank für Dein Lob und den Hinweis!

      Das Tutorial wird momentan an die Erfordernisse von Android Studio 3.0 angepasst. Lektion 2 wurde bereits überarbeitet. Anstelle eines “Android Resource Directory” wird nun ein ganz normales Directory angelegt, wie von Dir beschrieben. Auf diese Weise kann das Layout-Verzeichnis ohne qualifier erstellt werden.

      Weiterhin muss die MainActivity sich jetzt von der AppCompatActivity-Klasse ableiten, da die alte ActionBarActivity-Klasse nicht mehr von der Android Plattform unterstützt wird.

      Viele Grüße, Chris

  60. Hallo,
    erst mal ein großes Danke für die ganzen Erklärungen. Leider komme ich bei Schritt 5.1 nicht weiter.
    Sobald ich den Layout Ordner anlegen möchte sagt er mir : „Enter or select a quailier“.
    Dabei wird es sich wohl um den Namen handeln. Sobald ich Layout mit großem L Schreibe, kann ich den Ordner erstellen. Nur kann ich danach nicht die nächsten Punkte bearbeiten.
    Eine Idee was ich falsch mache?
    LG und danke

    1. Post
      Author

      Hallo Marco,

      seit Android Studio 3.0 kommt es zu den von Dir beschriebenen Problem. Ich habe Lektion 2 jetzt überarbeitet, so dass wieder alles funktionieren sollte.

      Anstelle eines “Android Resource Directory” wird nun ein ganz normales Directory angelegt. Auf diese Weise kann das Layout-Verzeichnis ohne qualifier erstellt werden.

      Weiterhin muss die MainActivity sich jetzt von der AppCompatActivity-Klasse ableiten, da die alte ActionBarActivity-Klasse nicht mehr von der Android Plattform unterstützt wird.

      Viele Grüße, Chris

  61. Hallo,
    super tutorial, so ein gut erklärtes Anfänger Tutorial habe ich mir immer gewünscht.
    Leider stoße ich schon sehr früh (Kapitel 2 5.1) auf Probleme die ich nicht beheben kann. Wird diese Anleitung es in naher Zukunft an Andoid Studio 3.0.. angepasst? Es hat sich doch einiges geändert. Kann leider das Resource Directory Layout nicht anlegen. „Enter or select qualifier“. Hoffe doch sehr, dass ich bald weiter lernen kann.

    Grüße, Till

    1. Post
      Author

      Hallo Till,

      danke für Dein Lob!

      Das Tutorial wird momentan an die Erfordernisse von Android Studio 3.0 angepasst. Lektion 2 wurde bereits überarbeitet. Anstelle eines „Android Resource Directory“ wird nun ein ganz normales Directory angelegt. Auf diese Weise kann das Layout-Verzeichnis ohne qualifier erstellt werden.

      Weiterhin muss die MainActivity sich jetzt von der AppCompatActivity-Klasse ableiten, da die alte ActionBarActivity-Klasse nicht mehr von der Android Plattform unterstützt wird.

      Viele Grüße, Chris

  62. Hallo, ich habe Android Studio 3.0 installiert und wie schon bemerkt konnte ich kein “Android Resource Directory” ohne qualifier anlegen kann. Ich habe dann das Tutorial dann mit Basic Activity aufgebaut.
    Habe nun aber das Problem das mir der obere Bereich für die Menueauswahl nicht angezeigt wird.
    Wann kommt der überarbeitete Teil Lektion 2, im Netz sehe ich nur die Version für Android Studio 2.0
    Kann mir da jemand helfen?

    Das Tutorial wird momentan an die Erfordernisse von Android Studio 3.0 angepasst. Lektion 2 wurde bereits überarbeitet. Anstelle eines “Android Resource Directory” wird nun ein ganz normales Directory angelegt. Auf diese Weise kann das Layout-Verzeichnis ohne qualifier erstellt werden.

    1. Post
      Author

      Hallo Mediastudio,

      das Tutorial wurde an den erforderlichen Stellen bereits überarbeitet. Zur Kontrolle wurde das gesamte Tutorial mit Android Studio 3.0.1 nachprogrammiert. Dabei hat alles wie erwartet funktioniert.

      Die beiden notwendigen Änderungen waren:

      – Verwenden der AppCompatActivity-Klasse als Superklasse der MainActivity
      – Erstellen des Layout-Ordners als ganz normales Verzeichnis (wie in Abschnitt 5.1 beschrieben)

      Viele Grüße, Chris

  63. Zu erwähnen ist, es ist wirklich ein Tutorial mit dem man als Einsteiger einen guten Erfolg erzielt.

    Gruß
    mediastudio

  64. Hallo,

    ein wirklich tolles Tutorial. Sehr gut gemacht. Besonders hat mit die bildliche Darstellung mit der Vergrößerung gefallen. Wenn man diese zur genauen Kontrolle seines geschriebenen Codes verwendet, kann man nichts falsch machen.

    Bei mir hat, nachdem der AVD-Manager beim Marshmallow-Image noch etwas nachladen mußte, alles prima geklappt.

    Grüße Harald

    Ich bin selber Entwickler und habe bisher in anderen Entwicklungsumgebungen gearbeitet. Da hätte ich mir bei der einen oder anderen auch so ein gut gemachtes Tutorial zum Einarbeiten gewünscht.

    Ein ganz dickes Lob.

    1. Post
      Author
  65. Hallo zusammen,
    erstmal großes Lob an das Team, das diese Website leitet und erstellt hat. So gut und detailiert erklärt wie hier findet man es kaum wo anders im Web.
    Ich hätte einen kleine frage zu 1.Schritt 3: Ist es möglich auch noch in Android Studio version 3.1. für mindestens Android 2.3.3 zu Programmieren? Das minimum ist momentan 4.0 aber mein Kumpel für den ich etwas programmieren möchte hat noch Android 2.3.7 .
    Gibt es einen Weg, dies zu ermöglichen?

    Gruß Lukas 🙂

    1. Post
      Author

      Hallo Lukas,

      man kann bis zu Android 2.3.3 ohne Probleme mit Android Studio programmieren und natürlich auch für noch ältere Android Versionen. Wichtig dabei ist, die dafür benötigten Support Libraries zu verwenden.

      Viele Grüße, Chris

  66. Hallo,

    super Tutorial. Mir gefällt besonders wie detailliert alles beschrieben ist und mit Bildern ergänzt.

    Ein Problem habe ich jedoch und vielleicht kann mir jemand helfen.
    Das Projekt wird ohne Fehler erstellt, startet und wird direkt wieder beendet. Für Hilfe bin ich sehr dankbar.

    Gruß Christian

    1. Post
      Author

      Hallo Christian,

      deine App stürzt an einer Stelle im Quellcode ab. Die Fehlerursache kann mit Hilfe des Stack Trace gefunden werden. Den Stack Trace kannst du wie folgt auslesen:

      1. Deine App in einem AVD auf dem Emulator ausführen.
      2. Die App zum Absturz bringen.
      3. In dem Logcat Tool Window von Android Studio den Stack Trace betrachten. Nach dem Fehler kann man mit dem Begriff „fatal“ suchen.

      Viele Grüße, Chris

  67. Hi Chris,

    das Tut ist einfach klasse. Konnte schon eine Menge lernen. Ich bin sogar schon bei Kap. 12. Jedoch ist mir aufgefallen, dass bei meiner App es im Overflow nur einen Punkt „Aktualisieren“ gibt. Settings wird nicht erkannt.

    Ich habe das gesamte Tut noch einmal bis Kap 12 gemacht und es erscheint immer noch nicht.

    Normalerweise sollte das Settings in dem Overflow Menu doch ab diesem Kapitel integriert sein?

    Danke für deine Hilfe.

    LG Daniel

    1. Post
      Author

      Hallo Kirsche,

      das ist ja merkwürdig. Es sollten alle Einträge der Menü-Datei im Overflow-Menü der App Bar angezeigt werden. Warum bei dir nur Aktualisieren erscheint, ist sehr überraschend. Hast du in den zugehörigen XML Menü-Dateien den Settings Eintrag korrekt definiert?

      Viele Grüße, Chris

  68. Hey ho, hab mich sehr über das Tutorial gefreut. Danke.
    Ich habe nur das Problem das ich, wenn ich es laufen lassen möchte, die Fehlermeldung „Build: build failed“ bekomme. Dazu dann in dem rechten Feld diese „Erklärung“:

    org.gradle.api.tasks.TaskExecutionException: Execution failed for task ':app:compileDebugJavaWithJavac'.
    	at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeActions(ExecuteActionsTaskExecuter.java:100)
    	at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.execute(ExecuteActionsTaskExecuter.java:70)
    	at org.gradle.api.internal.tasks.execution.OutputDirectoryCreatingTaskExecuter.execute(OutputDirectoryCreatingTaskExecuter.java:51)
    	at org.gradle.api.internal.tasks.execution.SkipUpToDateTaskExecuter.execute(SkipUpToDateTaskExecuter.java:62)
    	at org.gradle.api.internal.tasks.execution.ResolveTaskOutputCachingStateExecuter.execute(ResolveTaskOutputCachingStateExecuter.java:54)
    	at org.gradle.api.internal.tasks.execution.ValidatingTaskExecuter.execute(ValidatingTaskExecuter.java:60)
    	at org.gradle.api.internal.tasks.execution.SkipEmptySourceFilesTaskExecuter.execute(SkipEmptySourceFilesTaskExecuter.java:97)
    	at org.gradle.api.internal.tasks.execution.CleanupStaleOutputsExecuter.execute(CleanupStaleOutputsExecuter.java:87)
    	at org.gradle.api.internal.tasks.execution.ResolveTaskArtifactStateTaskExecuter.execute(ResolveTaskArtifactStateTaskExecuter.java:52)
    	at org.gradle.api.internal.tasks.execution.SkipTaskWithNoActionsExecuter.execute(SkipTaskWithNoActionsExecuter.java:52)
    	at org.gradle.api.internal.tasks.execution.SkipOnlyIfTaskExecuter.execute(SkipOnlyIfTaskExecuter.java:54)
    	at org.gradle.api.internal.tasks.execution.ExecuteAtMostOnceTaskExecuter.execute(ExecuteAtMostOnceTaskExecuter.java:43)
    	at org.gradle.api.internal.tasks.execution.CatchExceptionTaskExecuter.execute(CatchExceptionTaskExecuter.java:34)
    	at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter$EventFiringTaskWorker$1.run(DefaultTaskGraphExecuter.java:248)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:336)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:328)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor.execute(DefaultBuildOperationExecutor.java:199)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor.run(DefaultBuildOperationExecutor.java:110)
    	at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter$EventFiringTaskWorker.execute(DefaultTaskGraphExecuter.java:241)
    	at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter$EventFiringTaskWorker.execute(DefaultTaskGraphExecuter.java:230)
    	at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker.processTask(DefaultTaskPlanExecutor.java:123)
    	at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker.access$200(DefaultTaskPlanExecutor.java:79)
    	at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker$1.execute(DefaultTaskPlanExecutor.java:104)
    	at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker$1.execute(DefaultTaskPlanExecutor.java:98)
    	at org.gradle.execution.taskgraph.DefaultTaskExecutionPlan.execute(DefaultTaskExecutionPlan.java:626)
    	at org.gradle.execution.taskgraph.DefaultTaskExecutionPlan.executeWithTask(DefaultTaskExecutionPlan.java:581)
    	at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker.run(DefaultTaskPlanExecutor.java:98)
    	at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63)
    	at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:46)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    	at org.gradle.internal.concurrent.ThreadFactoryImpl$ManagedThreadRunnable.run(ThreadFactoryImpl.java:55)
    	at java.lang.Thread.run(Thread.java:745)
    Caused by: org.gradle.api.internal.tasks.compile.CompilationFailedException: Compilation failed; see the compiler error output for details.
    	at org.gradle.api.internal.tasks.compile.JdkJavaCompiler.execute(JdkJavaCompiler.java:50)
    	at org.gradle.api.internal.tasks.compile.JdkJavaCompiler.execute(JdkJavaCompiler.java:35)
    	at org.gradle.api.internal.tasks.compile.NormalizingJavaCompiler.delegateAndHandleErrors(NormalizingJavaCompiler.java:98)
    	at org.gradle.api.internal.tasks.compile.NormalizingJavaCompiler.execute(NormalizingJavaCompiler.java:51)
    	at org.gradle.api.internal.tasks.compile.NormalizingJavaCompiler.execute(NormalizingJavaCompiler.java:37)
    	at org.gradle.api.internal.tasks.compile.incremental.SelectiveCompiler.execute(SelectiveCompiler.java:73)
    	at org.gradle.api.internal.tasks.compile.incremental.SelectiveCompiler.execute(SelectiveCompiler.java:34)
    	at org.gradle.api.internal.tasks.compile.incremental.IncrementalCompilationFinalizer.execute(IncrementalCompilationFinalizer.java:39)
    	at org.gradle.api.internal.tasks.compile.incremental.IncrementalCompilationFinalizer.execute(IncrementalCompilationFinalizer.java:24)
    	at org.gradle.api.tasks.compile.JavaCompile.performCompilation(JavaCompile.java:207)
    	at org.gradle.api.tasks.compile.JavaCompile.compile(JavaCompile.java:133)
    	at com.android.build.gradle.tasks.factory.AndroidJavaCompile.compile(AndroidJavaCompile.java:125)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at org.gradle.internal.reflect.JavaMethod.invoke(JavaMethod.java:73)
    	at org.gradle.api.internal.project.taskfactory.IncrementalTaskAction.doExecute(IncrementalTaskAction.java:46)
    	at org.gradle.api.internal.project.taskfactory.StandardTaskAction.execute(StandardTaskAction.java:39)
    	at org.gradle.api.internal.project.taskfactory.StandardTaskAction.execute(StandardTaskAction.java:26)
    	at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter$1.run(ExecuteActionsTaskExecuter.java:121)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:336)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:328)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor.execute(DefaultBuildOperationExecutor.java:199)
    	at org.gradle.internal.progress.DefaultBuildOperationExecutor.run(DefaultBuildOperationExecutor.java:110)
    	at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeAction(ExecuteActionsTaskExecuter.java:110)
    	at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeActions(ExecuteActionsTaskExecuter.java:92)
    	... 32 more
    

    Und zusätzlich beim Java compiler krieg ich den „error: expected. Ich nehme mal an, irgendwas wurde nicht definiert?
    Bin das Tutorial schon mehrmals nochmal durch gegangen und hab es mit „meinem“ Text verglichen, aber nichts gefunden. Kann mir jemand helfen?

    1. Post
      Author

      Hallo Tom,

      es liegt ein Problem beim Kompilieren des Projekts vor. Die Fehlermeldung deutet auf einen Kompilierfehler hin. Die fehlerhafte Stelle im Quellcode wird leider nicht in der Fehlermeldung angegeben, daher weiß ich nicht woran es genau liegt.

      Viele Grüße, Chris

  69. Hallo,
    das Tutorial ist sehr gut aufgebaut und für Einsteiger geeignet.

    Ich bin bis zum Abschnitt 11 gut vorangekommen aber jetzt habe ich ein Problem, wenn ich auf „Run app“ drücke, öffnet sich ein „Edit configurator“ fenster und ich weis leider nicht weiter. Kann mir jemand da weiterhelfen?
    Danke

    MfG
    Marckus

  70. Hallo

    Super Infos hier. Vielen Dank. Was ich bisher einfach nirgends finden konnte, ist eine Auskunft zum Thema Default-Sprache der Strings. Wenn ich Android Studio richtig verstehe, ist als Default-Sprache englisch voreingestellt. Zwar kann man dann zum Beispiel die Strings auf deutsch übersetzen. Aber was muss ich machen, dass die Default-Sprache deutsch ist und die Übersetzungen später ins englische erfolgen können?

    1. Post
      Author

      Hallo Emanuel,

      mit Android Studio können String-Dateien für verschiedene Sprachen sehr einfach bereitgestellt werden. In diesem Beitrag auf Developer.Android.com ist dies super übersichtlich erklärt:

      Localize your app

      Viele Grüße, Chris

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.