Googles Android/ Ein Déjà-vu – Hello World

Zurück zu Googles Android

Nun, da wir die Entwicklungsumgebung installiert und konfiguriert haben und wissen, aus welchen Basiskomponenten eine Android-Anwendung besteht, wollen wir unsere erste eigene Anwendung erstellen. Und nichts würde sich besser dafür eignen, als eine „Hello World“-Anwendung zu schreiben.

1. Zunächst müssen wir dafür in Eclipse ein neues Android-Projekt erstellen. Wie in Abbildung 1 gezeigt, geht das mit Hilfe von 'File –> New –> Project' oder über die Schaltfläche in der Symbolleiste. Indem sich öffnenden Dialog suchen wir uns unter Android das Android-Projekt aus und klicken auf 'Next'.

1. Öffnen eines neuen Projekts unter Eclipse
2. Wählen eines Android-Projekts

3. Initialisierungsdialog eines Android-Projekts

2. Jetzt müssen wir einige Voreinstellungen für unsere Anwendung vornehmen:

Der Projektname: Naja, eigentlich selbsterklärend, aber unter diesem Namen erstellen wir unser Projekt und können es unter diesem auch in unserem Verzeichnis finden.
Das Build-Target: Hier geben wir an, unter welcher Android-Version unsere Anwendung entwickelt wird. Dies kann später in den Projekteinstellungen geändert werden.
Der Anwendungsname Der Name unserer Anwendung unter dem wir die App auch auf dem Android-Gerät finden.
Der Package-Name: Alle Java-Klassen werden in einem gemeinsamen Package zusammengefasst.
Optional besteht die Möglichkeit eine 'Start'-Activity zu erstellen, die beim Programmstart als erstes aufgerufen wird. Da wir mit interaktiven Apps arbeiten wollen, empfiehlt sich die Angabe eines Namens für die Start-Activity.
Optional: ist auch die Angabe einer minimalen SDK Version.

Damit kann angegeben werden, welche Version das Betriebssystems ein Endgerät besitzen muss, damit es die Anwendung ausführen kann. Das ist an dieser Stelle aber noch nicht von Bedeutung.

Wie in dieser Anwendung die einzelnen Felder belegt sind, sehen wir in Abbildung 3.

Mit einem Click auf 'Finish' wird das Projekt erstellt.

3. Nachdem das Projekt erstellt wurde, kann, darf und sollte ein kurzer Blick in die Verzeichnisstruktur der Anwendung riskiert werden. Wie in der Abb. 4 zu sehen ist, kann man alle aus dem Kapitel Grundlegende Komponenten einer Android-Anwendung genannten Komponenten hier finden:

Activity: StartActivity.java
Layout-Datei: main.xml
Manifest: AndroidManifest.xml

4.Packagestruktur eines Android-Projekts

Im Grunde genommen haben wir bereits jetzt eine lauffähige Anwendung vor uns liegen. Um zu zeigen, dass dem auch so ist, werden wir das Programm einmal ausführen … doch Stopp!

Um eine Android-Anwendung auszuführen, benötigen wir mindestens eins von zwei Dingen:

Wir haben entweder die Möglichkeit unser Programm direkt auf einem androidfähigen Gerät zu starten, das mindestens die Betriebssystemversion unterstützt, in der wir das Programm geschrieben haben,

Wir nutzen einen im SDK mitgelieferten als „Android Virtual Device“ (AVD) bezeichneten Emulator. Auch wenn Sie bereits ein Android-Smartphone besitzen, werden wir nun so ein AVD einrichten.

4. Dazu öffnen wir wieder den „Android SDK und AVD Manager“ (siehe Abbildung 5). Wir sollten uns bereits jetzt im Dialog für 'Virtual Devices' befinden (wenn dem nicht so ist, bitte dorthin wechseln). Mit einem Klick auf 'New' legen wir ein neues AVD an und können es konfigurieren. Momentan ist es für uns nur wichtig, dem AVD im Konfigurationsdialog einen Namen und seine Betriebssystemversion mitzuteilen. Die anderen Eigenschaften werden wir in einem späteren Kapitel behandeln. Mit einem Click auf 'Create AVD' besitzen nun unser eigenes virtuelles Entwicklungsgerät.

5. AVD Manager
6. Initialisierungsdialog für neue AVDs

5. Wir haben unsere Anwendung und unser AVD. Also bringen wir den Stein ins Rollen: Mit Rechtsklick auf das Projekt –> Run As –> Android Application (siehe Abb. 7) wird das Programm gestartet. Da wir zurzeit nur ein virtuelles Device nutzen, wird die Anwendung automatisch auf diesem ausgeführt. An dieser Stelle sei gesagt, dass, egal wie schnell ihr Computer ist, das Hochfahren eines AVD immer eine gefühlte Ewigkeit dauert! (In dieser Zeit können Sie sich ruhig einen Kaffee holen :) ). Irgendwann sollte ein Fenster erscheinen, das wie in Abbildung 8 aussieht.

Sobald das Device hochgefahren ist, erscheint in den meisten Fällen zugleich auch die von uns gestartete Anwendung, wie es auch in Abb. 9 der Fall ist. Wie zu sehen ist, steht auf dem Bildschirm schon ein kleiner Satz, der sich aus dem Projektnamen und dem Namen unserer Start-Activity zusammensetzt. Jede „Start“-Activity, die wir beim Erstellen eines neuen Android-Projektes mit erstellen lassen ist so aufgebaut. Sicherlich (und auch hoffentlich), stellt sich Ihnen jetzt die Frage wie dieser kleine Satz auf den Bildschirm kommt. Da bietet es sich an, einmal den Zusammenhang und die Zusammenarbeit zwischen Activity, Layouts und Ressourcen zu betrachten.

7. Start des Android-Projekts
8. Homescreen eines Android-Emulators
9. „Hello World“ im Android-Emulator

StartActivity.java:

package com.jami.hw;
 
import android.app.Activity;
import android.os.Bundle;
 
public class StartActivity extends Activity {
     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
     }
}

Die Activity in diesem Beispiel macht zwar noch nicht viel her, die wichtigsten Funktionen sind dennoch zu sehen. In jeder Activity kommt die Methode onCreate vor, die jedes Mal dann aufgerufen wird, wenn eine Activity neu „erschaffen“ wird. Es gibt häufig auch die Situation, dass eine bereits bestehende Activity neu aufgerufen wird. In diesem Fall wird nicht die onCreate- sondern die onRestart- bzw. onStart-Methode genutzt. Aber zum Lifecycle einer Activity und aller damit einhergehenden Methoden kommen wir noch im Kapitel Activities zu sprechen. Wie gesagt wird onCreate nur beim Initialisieren der Activity genutzt. Dabei sollte hier die Zuweisung eines Layouts, sprich der UI der Activity, erfolgen. Dies wird durch die Methode setContentView erreicht, der als Parameter eine Layout-Ressource mitgegeben wird. In unserem Beispiel ist dies die Ressourcen-Datei main.xml, die sich im Ordner res/layout befindet. Da unsere Anwendung nur einen einfachen Text ausgeben soll, wird passiert in dieser Activity nichts weiter.

main.xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

<TextView  
    android:layout_width="fill_parent"
      android:layout_height="wrap_content"
    android:text="@string/hello"/>
 
</LinearLayout>

Diese XML-Datei beschreibt, wie die Oberfläche einer Activity aufgebaut ist. Als „Rahmen“ benötigt man dazu als erstes ein Grundlayout. Wir fangen mit dem einfachen linearen Layout an. Welche weiteren Typen es gibt und worin sich diese Layouts unterscheiden, wird in einem späteren Kapitel behandelt. In diese Layouts werden dann, je nachdem was man darstellen möchte, weitere View-Elemente eingefügt. In unserem Fall möchten wir einen Text darstellen, also verwenden wir hier eine View vom Typ TextView. Es gibt auch noch weitere Elemente, die zum Beispiel zur Darstellung von Buttons, Eingabefeldern oder Bildern genutzt werden. Aber auch diese werden explizit in einem eigenen Kapitel behandelt. Um den Text zu setzen, der später auf dem Bildschirm angezeigt werden soll, muss die TextView auch wissen, welchen Text er anzuzeigen hat. Dafür gibt es zwei Möglichkeiten:

Man kann dem Attribut android:text der TextView den anzuzeigenden Text direkt übergeben oder
Man kann ihm eine Referenz auf einen Eintrag in einer Ressourcen-Datei mitgeben.

In diesem Beispiel erhält die TextView eine Referenz auf den String namens 'hello', wie er in der Datei strings.xml definiert wurde. Wenn man den String direkt übergeben will, setzt man das text-Attribut in der Layout-Defintion wie folgt:

android:text="Hello World, StartActivity!"

strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World, StartActivity!</string>
    <string name="app_name">HelloWorld</string>
</resources>

Im Grunde genommen ist die Datei strings.xml nichts weiter als eine Ansammlung von Strings, die durch diese Ressourcen-Datei überall in der Anwendung verfügbar sind.

Ich gratuliere Ihnen! Sie haben Ihr erstes Android-Programm geschrieben, auch wenn Sie an dieser Stelle nicht wirklich etwas programmiert haben … aber das werden wir schon bald ändern.

Ich (nicht der Autor) habe gerade mal (23. 8. 2023) versucht, das Beispiel mit einem aktuellen Android zum Laufen zu bekommen - es hat geklappt. Wenn man mit Eclipse arbeitet, muss man wahrscheinlich gar nichts ändern. Ich bevorzuge aber die Nutzung von Befehlen in der Konsole. Da geht es wie folgt:

Die benötigten Dateien sind:

./AndroidManifest.xml ./res/layout/main.xml ./res/values/strings.xml ./src/com/jami/hw/StartActivity.java

Außer der ersten sind diese oben abgebildet. Die erste lautet wie folgt:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.jami.hw">
    <uses-sdk android:targetSdkVersion="33" />
    <application android:label="HelloWorld">
        <activity android:name=".StartActivity"
                  android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Hier muss man evtl. die sdk-Version anpassen.

Mit folgenden Befehlen wird das ganze dann kompiliert (der Pfad zu android.jar muss ggfs. angepasst werden):

Datei R.java erzeugen:

aapt package -M AndroidManifest.xml -I ~/.android_sdk/platforms/android-33/android.jar -S res/ -v -m -J src/

Java-Dateien kompilieren:

javac -source 9 -target 9 -d obj/ -cp ~/.android_sdk/platforms/android-33/android.jar -sourcepath src/ src/com/jami/hw/*.java

Class-Dateien in dex-Format umwandeln (früher ging das mit dx, jetzt mit d8):

d8 --lib ~/.android_sdk/platforms/android-33/android.jar --output bin/ obj/com/jami/hw/*.class

In apk-Datei packen. Diese ist noch nicht signiert.

aapt package -M AndroidManifest.xml -I ~/.android_sdk/platforms/android-33/android.jar -S res/ -v -F bin/HelloWorld.unsigned.apk bin

Die Daten in der Datei müssen auf 4 Bytes aligniert werden:

zipalign -f -p -v 4 bin/HelloWorld.unsigned.apk bin/HelloWorld.aligned.apk

Dann muss das ganze signiert werden, dafür ist ein keystore notwendig, siehe unten.

apksigner sign -verbose -ks HelloWorld.keystore --out bin/HelloWorld.signed.apk bin/HelloWorld.aligned.apk

Und zuletzt wird die App auf dem Smartphone installiert. (Dafür muss sich das Smartphone im Debug-Modus befinden. Wie das geht ist für jedes Smartphone anders -> Im Netz suchen...)

adb install bin/HelloWorld.signed.apk

Das war's (wenn alle Schritte geklappt haben...)

Zum Signieren wird ein keystore benötigt. Denn kann man mit folgendem Befehl erstellen:

keytool -genkey -validity 10000 -dname "CN=AndroidDebug, O=Android, C=US" -keystore HelloWorld.keystore -storepass android -keypass android -alias androiddebugkey -keyalg RSA -keysize 2048

Beim Signieren wird man nach dem Passwort gefragt. Das lautet "android". Kann man aber natürlich auch was anderes wählen...