Android_Tutorial_Lektion06_fotolia_RA_Studio_46292813

Programmier Tutorial: Apps für Android entwickeln – Teil 6: Die Start-Activity unserer Android App erstellen

In dieser Lektion werden wir mit dem Programmieren an unserer Android App beginnen.

Als Erstes erstellen wir die Start-Activity unserer Anwendung. Sie wird den Hauptbildschirm unsere App repräsentieren und daher den Namen MainActivity tragen.


Was eine Activity ist und wozu sie in Android verwendet wird, werden wir zu Beginn dieser Lektion ausführlich besprechen. Anschließend lassen wir die Start-Activity von Android Studio erzeugen und geben sie in der Schaltzentrale unserer App, dem App Manifest, bekannt.

Dazu müssen wir einige Änderungen an der AndroidManifest.xml Datei vornehmen. Dies ist auch ein guter Zeitpunkt, die Manifest-Datei unseres Projekts besser kennenzulernen. Sie ist eine der wichtigsten Projektdateien und für die Entwicklung von Android Anwendungen von großer Bedeutung.

Am Ende der Lektion kompilieren wir unser Android Studio Projekt und überprüfen auf diese Weise, ob alle Änderungen am Quellcode korrekt durchgeführt wurden.

1. Eine Activity in Android Studio erstellen

Android Apps bestehen fast immer aus einer oder mehreren Activities. Jede Activity erfüllt dabei eine ganz bestimmte Aufgabe. So gibt es oft eine MainActivity, die den Hauptbildschirm der App repräsentiert.

Wir werden nun zunächst untersuchen, was genau eine Activity im Android System darstellt. Anschließend werden wir die erste Activity unserer App erstellen lassen und den generierten Quellcode durch unseren eigenen erstzen.

1.1 Was ist eine Activity in Android?

Normale PC-Anwendungen bestehen meist aus einem Hauptbildschirm, in dem der Benutzer seine Aktionen durchführen kann. Der Hauptbildschirm wird nur sehr selten verlassen. Android Apps sind anders aufgebaut. Sie bestehen aus einer beliebigen Menge an Bildschirmseiten. Jede dieser Bildschirmseiten führt dabei eine ganz bestimmte Aktivität aus, daher die Bezeichnung Activity.

Vorstellen kann man sich eine Activity am besten als eine Bildschirmseite, deren Aussehen über eine XML-Layout Datei definiert und deren Verhalten durch Java-Quellcode vorgeben wird. Innerhalb der App sollte jede Activity genau für eine exakt formulierte Aufgabe verantwortlich sein.

Um Activities verwenden zu können, müssen diese bekannt gegeben werden. Dies geschieht in dem App Manifest, der AndroidManifest.xml Datei. Dabei können auch zusätzliche Eigenschaften für sie definiert werden, wie bspw. ihre übergeordnete Activity oder Bildschirmorientierung.

Dass eine Android App aus mehreren Activities besteht, hat einen großen Vorteil. Denn jede Activity ist ein in sich geschlossenes Element und nur lose in die gesamte App eingebunden. Und genau daraus ergibt sich der große Nutzen des Activity-Mechanismus. Denn eine Activity kann auch von anderen Apps aufgerufen werden, um genauer zu sein, von App-fremden Acitivities.

Der Aufruf erfolgt über den globalen Aufrufmechanismus von Android mit Hilfe von Intents, auf die wir in einer späteren Lektion ausführlich eingehen werden.

1.2 Erstellen der MainActivity unserer App in Android Studio

Nun möchten wir mit dem Programmieren beginnen und die erste Activity unserer Android App erstellen. Sie wird der Hauptbildschirm der App sein. Also der erste Bildschirm der nach dem Starten der App zu sehen sein wird. Zu Beginn wird unsere Activity so einfach wie möglich sein und nur einen kurzen Text auf dem Bildschirm anzeigen. Später werden wir sie immer weiter ausbauen.

Um die Activity anzulegen, muss eine Java Klassendatei in dem Package-Ordner des Projekts erstellt werden. Dafür gibt es zwei Vorgehensweisen: über die obere Menüleiste oder über den Package-Ordner in der Project-Ansicht. Wir werden den zweiten Weg wählen, da er intuitiver und weniger fehleranfällig ist.

Als Erstes muss dafür die Project-Ansicht exakt so wie in Abschnitt 2 dieser Lektion beschrieben aufgeklappt werden. Der Package-Ordner sollte nun wie folgt zu sehen sein:

project_tool_window_package

Unser erstelltes Android Studio Projekt im Project-View dargestellt

In diesen Package-Ordner werden wir nun die Klassendatei der Activity anlegen lassen. Dazu nutzen wir den Create New Class-Dialog von Android Studio.

Für das Erstellen der MainActivity.java Klassendatei führen wir die folgenden Schritte aus:

  1. Mit der rechten Maustaste auf den Package-Ordner de.codeyourapp.zitate klicken.
  2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
  3. Danach auf den Eintrag Java Class klicken.
create_new_activity_contextual_menu

Erstellen der Activity Klassendatei in den Package-Ordner des Projekts

Anschließend öffnet sich der Create New Class-Dialog, der uns bei der Erstellung der neuen Java Klasse unterstützt. Wir müssen nur einige Felder des Dialogs ausfüllen.

In dem Create New Class-Dialog nehmen wir nun die folgenden Einstellungen vor:

  1. Als Klassennamen tragen wir in das Feld Name MainActivity ein.
  2. Den Wert für Kind lassen wir auf Class stehen.
  3. Die Felder Superclass und Interface(s) lassen wir leer.
  4. Als Package sollte bereits automatisch unser Package-Ordner de.codeyourapp.zitate eingetragen sein.
  5. Alle anderen Einstellungen übernehmen wir unverändert.
  6. Den Dialog bestätigen wir mit einem Klick auf den OK Button.
create_new_activity_dialog

Den Namen für die neue Java Klasse festlegen

Android Studio legt nun automatisch die neue Java Klasse an. Dabei wird auch der minimale Quellcode für das Klassengerüst erzeugt. Diesen benötigen wir aber nicht und werden ihn daher vollständig durch unseren eigenen Code ersetzen.

Dazu öffnen wir die Klassendatei MainActivity.java im Editorfenster von Android Studio mit einem Doppelklick auf den entsprechenden Eintrag in der linken Project-Ansicht.

Anschließend ersetzen wir den gesamten Quelltext mit folgendem Code:

MainActivity.java

package de.codeyourapp.zitate;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        TextView welcomeMessageTV = new TextView(this);
        welcomeMessageTV.setText("Hello CodeYourApp World!");
        setContentView(welcomeMessageTV);
    }
}

Unsere Activity ist momentan noch so einfach wie möglich aufgebaut, damit der Quellcode leichter nachvollzogen werden kann. Momentan gibt unsere Activity nur einen kurzen Text auf dem Bildschirm aus. Mehr kann sie noch nicht.

In Zeile 1 definieren wir zu welchem Package die MainActivity-Klasse gehört. An dieser Stelle muss der Package-Name verwendet werden, der auch in dem Project-View angezeigt wird.

In den Zeilen 3 bis 5 befinden sich die Import-Anweisungen. Durch sie werden die drei Klassen AppCompatActivity, Bundle und TextView eingebunden. Auf diese Weise ist es möglich, auf sie mit ihren einfachen Namen (z.B. Bundle) zuzugreifen, anstelle den vollqualifizierten Namen (z.B. android.os.Bundle) verwenden zu müssen.

In den Zeilen 7 bis 17 wird die Klasse MainActivity definiert. Als Super-Klasse wurde die Klasse AppCompatActivity gewählt, welche indirekt von der Klasse Activity abgeleitet ist. Somit besitzt unsere MainActivity-Klasse alle Eigenschaften der Activity-Klasse und zusätzliche Kompatibilitätsmechanismen der AppCompatActivity-Klasse, wodurch unsere App auch zu älteren Android Versionen kompatibel bleibt.

Die onCreate() Methode der MainActivity-Klasse

Unsere Klasse besitzt genau eine Methode, die onCreate() Methode, bei der es sich um eine sogenannte Callback-Methode handelt. Sie wird von dem Android System aufgerufen, wenn die Activity erstellt wird.

Daher muss jede Activity in Android mindestens diese Callback-Methode implementieren. In ihr muss die grundlegende Initialisierung der Activity erfolgen, wie bspw. Membervariablen instanziieren, Elemente der Benutzeroberfläche laden oder Hintergrund-Threads initialisieren. Zudem kann in ihr der vorherige Zustand der Activity mit Hilfe des savedInstanceState Objekts wiederhergestellt werden.

Da die onCreate() Methode für unsere MainActivity-Klasse so bedeutsam ist, werden wir sie uns nun genauer ansehen:

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    TextView welcomeMessageTV = new TextView(this);
    welcomeMessageTV.setText("Hello CodeYourApp World!");
    setContentView(welcomeMessageTV);
}

Die Methode besitzt den formalen Parameter savedInstanceState, der vom Typ Bundle ist. Bei Methodenaufruf wird über ihn der vorherige Zustand der Activity übergeben. Wir werden den Parameter in späteren Lektionen nutzen, um den Zustand der Activity wiederherzustellen. Momentan benötigen wir ihn jedoch noch nicht.

In Zeile 2 wird die Implementation der onCreate() Methode der Super-Klasse aufgerufen. Sie führt die grundlegende Initialisierung der Activity durch. Würde der Aufruf nicht erfolgen, wäre unsere App nicht lauffähig und eine Exception, die SuperNotCalledException, würde geworfen werden.

In den Zeilen 4 bis 6 erzeugen wir ein TextView-Objekt und legen den Text Hello CodeYourApp World! als dessen Inhalt fest. Dieses View-Objekt nutzen wir als Argument bei dem Aufruf der setContentView() Methode. wodurch es zum Inhalt der Activity wird. Das View-Objekt wird dabei direkt in die View-Hierarchie der Activity eingefügt.

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

create_new_activity_code

Die Klassendatei MainActivity.java mit dem eingefügten Quellcode

Jetzt haben wir die Basis für unsere Android App gelegt. Wir haben die MainActivity erstellt und somit den Hauptbildschirm unserer mobilen Anwendung angelegt.

Zum Starten unserer Android App ist aber noch ein weiterer wichtiger Schritt notwendig. Und zwar muss die MainActivity in der Schaltzentrale unserer Anwendung, dem App Manifest, bekannt gegeben werden. Dies werden wir im nächsten Abschnitt vornehmen.

2. Bekanntgabe der erstellten Activity im App Manifest

Bevor wir unsere App im Emulator oder auf einem Android Gerät ausführen können, müssen wir eine Activity bekannt geben, die zum Start der Anwendung ausgeführt werden soll. Die Bekanntgabe der Start-Activity erfolgt in der AndroidManifest.xml Datei. Sie ist die Schaltzentrale jeder Android App.

Wir öffnen nun die AndroidManifest.xml Datei im Editorfenster von Android Studio durch einen Doppelklick auf die entsprechende Datei in der Project-Ansicht. Sie befindet sich in dem app/src/main/ Ordner unseres Android Studio Projekts:

android_manifest_generated

Die AndroidManifest.xml Datei zum Projektstart

Auch bei euch sollte die Manifest-Datei wie in der oberen Abbildung aussehen. Direkt nach Projektbeginn enthält sie nur ein <application> Element, das die Basiseigenschaften unserer Anwendung definiert.

Activities werden mit Hilfe eines <activity> Elements in der Manifest-Datei bekannt gegeben. Alle Activities der App müssen durch ein <activity> Element repräsentiert sein. Wird eine Activity nicht auf diese Art bekannt gegeben, wird sie vom Android System nicht gesehen und kann niemals ausgeführt werden.

Momentan sind in dem App Manifest unseres Android Projekts keine Activities angegeben. Das werden wir als Nächstes ändern und unsere eben erstellte MainActivity-Klasse für die Anwendung bekannt geben. Die Bekanntgabe der Activity muss innerhalb des <application> Elements erfolgen.

Wir werden nun unsere Activity bekannt geben, indem wir auf unsere Start-Activity innerhalb des <application> Elements verweisen.

Dazu ersetzten wir in der AndroidManifest.xml Datei das gesamte <application> Element mit dem im unteren Quellcode markierten Code-Block:

AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="de.codeyourapp.zitate">

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

        <activity
            android:name=".MainActivity"
            android:launchMode="singleTop">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

    </application>

</manifest>

Das <application> Element besteht nun aus einem öffnenden und einem schließenden Tag und enthält in seinem Inneren ein <activity> Element. Dies muss auch bei euch unbedingt so sein.

In den Zeilen 12 bis 19 legen wir den Haupt-Einstiegspunkt unserer Anwendung fest. Also die Activity, die geöffnet werden soll, wenn der Benutzer die App über das Launcher-Symbol startet.

  • Das <activity> Element – Das <activity> Element besitzt die Attribute android:name und android:launchMode. Dem android:name Attribut muss der Name der Klasse zugewiesen werden, welche die Activity implementiert. Dabei sollte der vollqualifizierende Klassenname (de.codeyourapp.zitate.MainActivity) verwendet werden. Ist in dem <manifest> Element das package Attribut gesetzt, kann auch die Kurzschreibweise (.MainActivity) genutzt werden. Dabei wird der Klassenname an den Package-Namen angehängt.

    Das Attribut android:launchMode gibt vor, wie eine Activity in einem Task gestartet werden soll, zum Beispiel ob eine weitere Instanz der Activity erzeugt oder eine bereits vorhandene Activity fortgesetzt werden soll. In Android sind vier verschiedene launch modes definiert: standard, singleTop, singleTask und singleInstance. Wir setzen das Attribut android:launchMode auf den Wert singleTop, wodurch stets die bereits vorhandene Instanz der MainActivity fortgesetzt werden wird.

    Wichtiger Hinweis: Das <activity> Element muss innerhalb des <application> Elements eingefügt werden. Also zwischen dem öffnenden und schließenden <application> Tags.

  • Das <intent-filter> Element – In dem <activity> Element befindet sich ein <intent-filter> Element. Über Intents werden Activities gestartet. Mit <intent-filter> Elementen wird vorgegeben auf welche Arten von Intents die Activity antworten kann. Das Android System weiß dadurch genau, wann die jeweilige Activity gestartet werden kann bzw. soll. Die <intent-filter> werden über <action>, <category> und <data> Elemente definiert.

    • Das <action> Element – Dem <action> Element weisen wir mit android.intent.action.MAIN die Konstante ACTION_MAIN zu. Somit signalisieren wir dem Android System, dass die MainActivity der Haupt-Einstiegspunkt unserer App ist.

    • Das <category> Element – Dem <category> Element weisen wir mit android.intent.category.LAUNCHER die Konstante CATEGORY_LAUNCHER zu und geben damit an, dass der Activity-Icon in den App Launcher des Android Systems platziert werden soll. Wurde für das <activity> Element kein Icon vorgegeben, wird er Icon des <application> Elements verwenden. Dies ist bei uns der Fall.

    Beide Elemente, <action> und <category>, müssen zusammen verwendet werden, damit der Activity-Icon tatsächlich in dem App Launcher von Android erscheint.

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

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

android_manifest_code

Die AndroidManifest.xml Datei mit den vorgenommenen Änderungen

In der oberen Abbildung ist die AndroidManifest.xml Datei dargestellt. Es wurde das von Android Studio generierte <application> Element durch unser selbst definiertes <application> Element ersetzt.

Das eingefügte <application> Element (Markierung A) besteht nun aus einem öffnenden und einem schließenden Tag und enthält in seinem Inneren ein <activity> Element, mit welchem die Start-Activity unserer App bekanntgegeben wird.

Die von uns erstellte Activity wurde somit im App Manifest als Start-Activity bekannt gegeben. Sie wird von un an vom Android System über den App Launcher gestartet, sobald der Icon unserer App auf dem Android Gerät gedrückt wird.

Im nächsten Abschnitt werden wir prüfen, ob alle Änderungen korrekt durchgeführt wurden. Dazu werden wir unser Android Projekt kompilieren lassen.

3. Das Android Projekt kompilieren (Make Project)

Als letzten Schritt kompilieren wir unser Projekt. Dieser Prozess wird von Android Studio im Hintergrund durchgeführt und umfasst neben dem Kompilieren des Quellcodes noch weitere Arbeitsschritte. Daher trägt der Menüeintrag in Android Studio, über welchen das Kompilieren gestartet wird, auch die Bezeichnung Make Project und nicht Compile Project.

Das Projekt wird dabei auf eine ganz bestimmte Art zusammengebaut. Wie der Zusammenbau zu erfolgen hat, wird durch mehrere kleine Gradle Tasks exakt vorgegeben. Im Moment müssen wir uns um sie aber noch keine Gedanken machen. Wir müssen nur wissen, wie der Make Project Prozess angestoßen wird.

Um unser Projekt zu kompilieren, den Make Project Prozess zu starten, klicken wir in der oberen Menüleiste auf den Eintrag Build und anschließend auf den Befehl Make Project, siehe folgende Abbildung:

make_project

Unser Android Projekt mit dem Befehl Build -> Make Project erstellen lassen

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

Bei euch sollte der Make Project Prozess unbedingt fehlerfrei abgeschlossen worden sein. Sobald das Android Build System den Zusammenbau des Projekt erfolgreich beendet hat, werdet ihr darüber in der Statusleiste von Android Studio mit der Meldung „Gradle Build finished …“ informiert.

Zusammenfassung

Wir haben nun die erste Activity für unsere Android App erstellt. Sie wird der Haupt-Einstiegspunkt in die Anwendung sein. Repräsentiert wird sie von der Java Klassendatei MainActivity.java, die wir in dem Package-Ordner unseres Projekts angelegt haben.

Damit die erstellte Activity von unserer App genutzt werden kann, muss sie dem Android System bekannt gegeben werden. Dies haben wir in dem App Manifest unseres Projekt-Moduls vorgenommen. Dazu haben wir die AndroidManifest.xml Datei überarbeitet und ein <activity> Element eingefügt. Dabei haben wir die Activity mit Hilfe eines Intent-Filters als die Start-Activity unserer App deklariert.

Abschließend haben wir den Make Project Prozess angestoßen, wodurch das Android Projekt kompiliert und neu erstellt wurde. Auf diese Weise konnten wir prüfen, ob die Änderungen am Quellcode korrekt umgesetzt wurden.

Mit den durchgeführten Änderungen ist unsere App jetzt erstmals lauffähig. In der nächsten Lektion werden wir sie im Android Emulator ausführen und testen. Dazu werden wir ein Android Virtual Device (AVD) einrichten, auf dem unsere App dann im Emulator ausgeführt werden wird.

Weiterführende Literatur




Schreibe einen Kommentar

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