Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
archive:der_einstieg_in_java_fuer_android [2023/11/15 12:48] – gelöscht - Externe Bearbeitung (Unbekanntes Datum) 127.0.0.1archive:der_einstieg_in_java_fuer_android [2024/01/18 11:49] (aktuell) – ↷ Links angepasst, weil Seiten im Wiki verschoben wurden luf39862
Zeile 1: Zeile 1:
 +====== Der Einstieg in Java für Android ======
 +
 + Diese Ergänzung zum Buch "Programmieren in Java" (von Prof. Dr. Jobst) will Ihnen dabei helfen, erste Programme für Smartphones der Android–Plattform von Google zu erstellen und diese Programme ablaufen zu lassen. Diese Ergänzungen folgen dem Aufbau des Buches: in einzelnen Kapiteln zeigen wir, wie Sie Apps für Android entwickeln können.
 +
 +**Hinweise**
 +
 +Diese Ergänzung zum Buch "Programmieren in Java" erläutert nur die Besonderheiten zum Einstieg in Android. Sie benötigen ggf. das Buch von Prof. Jobst, welches hier kurz als "das Buch" bezeichnet wird. Smartphones für die Android–Plattform sind kurz als "Smartphones" bezeichnet.
 +
 +Smartphones sind batteriebetriebene Geräte. Der Stromverbrauch ist eine kritische Größe, die man nie aus dem Auge verlieren darf. Außerdem sind die Größen des RAM sowie des Hintergrundspeichers sowie die Rechenleistung im Vergleich zu PCs eng beschränkt. Diese Restriktionen erfordern in Teilen eine gegenüber dem PC erheblich aufwändigere Programmierung. Meine Empfehlung: starten Sie bei der Java-Programmierung mit dem Buch. Wenn Sie eine gewisse Sicherheit gewonnen haben, kann es viel Spaß machen, Apps für Android zu entwickeln. Dann können Sie diese Ergänzungen für Ihren persönlichen Start in die Welt der Androiden benützen.
 +
 +Sie finden alle Programme zu dieser Ergänzung in Form von Eclipse-Projekten auf der Homepage des Autors: <del>http://homepages.fh-regensburg.de/~jof39108/</del>
 +
 +===== Wie entwickelt man Apps für Android? =====
 +
 +Eine App für Android ist eine Applikation für das System Android. Eine solche App läuft im Prinzip auf einem Smartphone für Android. Wir entwickeln die App aber nicht auf dem Smartphone, sondern genauso wie die anderen Java–Programme auf dem PC mit der integrierten Entwicklungsumgebung Eclipse. Dazu benötigen wir das Android SDK sowie ein Zusatzmodul für Eclipse, das Plugin für Android. Das Android SDK enthält mit dem AVD (Android Virtual Device) einen Simulator, mit dessen Hilfe wir Apps auch auf dem PC laufen lassen können. Die **Abbildung 1.1** zeigt die prinzipiellen Abläufe. Eine App besteht nicht nur aus einem Pro-gramm, sondern enthält noch sog. Ressourcen wie Bilder, Texte oder Beschreibungen im ''%%.xml%%''–Format. Außerdem muss die App alle verlangten Zugriffe, z.B. auf die Kontakte oder auf die SD–Karte des Smartphones benennen.
 +
 +{{:wiki:and-prog-abb-1-1.png}}
 +
 +**Abbildung 1.1: Entwicklung von Apps für Android**
 +
 +Der Java–Compiler übersetzt das Java–Programm für die App wie alle anderen Java–Programme in eine ''%%.class%%''–Datei. Diese ''%%.class%%''–Datei ist nun im Gegensatz zu Plattfor-men wie der Java–Micro–Edition nicht direkt auf dem Smartphone ablauffähig, sondern wird von einem Compiler in das Dalvík Executable Format ''%%.dex%%'' umgewandelt. Dan Bornstein hat dieses Format erfunden, um besonders kurze und effiziente Programme zu erzeugen, damit das Smartphone Strom sparen kann. Dalvík ist eine kleine Stadt in Island, zu der Dan Bornstein enge Verbindungen hat. Die Entwicklungsumgebung schnürt nun aus dem Programm sowie seinen Ressourcen ein ''%%.apk%%''–Paket und versieht es mit einer Prüfsumme, der sog. digitalen Signatur. Diese Signatur kann nicht verfälscht werden. Damit kann das Smartphone als Zielsystem die Prüfsumme neu berechnen und mit dem in der App angegebenen Wert vergleichen und so überprüfen, ob die App von irgendwelchen Viren verändert wurde.
 +
 +Von diesen Abläufen merkt der Benutzer der Eclipse–Entwicklungsumgebung nichts, man bringt seine App wie ein übliches Java–Programm zum Ablauf. Dazu kann man das Smartphone über ein USB–Kabel an den PC anschließen. Dann besorgt das Entwicklungssystem alle Schritte: Übersetzen, Packen, Signieren, auf das Smartphone kopieren, dort installieren und auch gleich zum Ablauf zu bringen. Wenn man kein Smartphone für Android hat, benützt man den Simulator.
 +
 +===== Installation der Entwicklungsumgebung für Android =====
 +
 +Wie im Buch unter Abschnitt 1.3 beschrieben, benötigen Sie das Java Development Kit (JDK) sowie eine Eclipse–Variante für die Entwicklung von Java–Programmen. Zusätzlich müssen Sie das SDK für Android sowie das ADT (Android Development Tools) Plugin für Eclipse installieren. Sie finden alle Schritte unter
 +
 +  * **** http://developer.android.com/sdk/installing.html
 +
 +beschrieben. Zur Installation empfiehlt es sich, in der in **Tabelle 1.1** beschriebenen Reihenfolge vorzugehen.
 +
 +^Komponente               ^Download bzw. Beschreibung                                        ^
 +|JDK                      |http://www.oracle.com/technetwork/java/javase/downloads/index.html|
 +|Eclipse                  |http://www.eclipse.org/downloads/                                 |
 +|SDK für Android          |http://developer.android.com/sdk/index.html                       |
 +|ADT Plugin (Beschreibung)|http://developer.android.com/sdk/eclipse-adt.html                 |
 +|ADT-URL für Eclipse      |https://dl-ssl.google.com/android/eclipse/                        |
 +
 +**Tabelle 1.1: Werkzeuge zur Entwicklung von Apps für Android**
 +
 +==== Die Qual der Wahl der Versionen und Varianten der Komponenten ====
 +
 +Bei Java empfiehlt sich die jeweils aktuelle Version 1.6, bei Eclipse eine Variante wie z.B. "Eclipse IDE for Java Developers". Bei Android sind diverse Versionen im Einsatz. Besonders weit ist die Version 2.3 verbreitet, die wesentlich kompletter als die Version 2.2 ausgestattet ist. Achten Sie auf die Version von Android auf Ihrem Smartphone und wählen Sie bei der Installation des SDK für Android eine Version des API, die auf Ihrem Smartphone lauffähig ist. Nach dem SDK müssen wir das ADT Plugin von Google in Eclipse installieren. Folgen Sie dabei der in **Tabelle 1.1** angegebenen Beschreibung.
 +
 +==== Smartphone über USB anschließen und Apps laufen lassen ====
 +
 +Wir erstellen die Programme am PC und lassen sie auf dem Smartphone laufen. Zur Verbindung zwischen PC und Smartphone benützen wir ein USB–Kabel. Unter Windows benötigen Sie einen für das Smartphone geeigneten USB–Treiber. Bei Smartphones der Firma Samsung ist u. U. die Installation des Dienstprogramms "Kies" der Firma Samsung erforderlich. Bei der Installation von "Kies" werden die benötigten Treiber für USB mitinstalliert. Siehe
 +
 +  * **** http://developer.android.com/sdk/installing.html
 +
 +Die Installation von Apps auf Smartphones ist ein sicherheitskritischer Schritt und deswegen nicht ohne die ausdrückliche Erlaubnis möglich. Dies muss man unter Android 4.x unter //Einstellungen → Entwickleroptionen → USB-Debugging// explizit erlauben, unter älteren Android Versionen unter Einstellungen/...
 +
 +==== Vorbereiten von Eclipse ====
 +
 +**Abbildung 1.2** zeigt die für die Entwicklung unter Android möglichen Views, die man aus der Eclipse–Entwicklungsumgebung unter //Window → Show View → Other...// aktivieren kann. Die View //Devices// zeigt die angeschlossenen Geräte. Drückt man in dieser Ansicht das Symbol für Kamera, so erhält man Bildschirmabdrucke vom über USB angeschlossenen Smartphone. Dies ist auch unabhängig vom Programmieren nützlich. Die View //LogCat// liefert eine Ansicht auf alle Systemmeldungen. Damit kann man Ausgaben des Programms auf dem Smartphone lesen. Dieses sog. //Logging// kann bei der Suche nach Fehlern sehr hilfreich sein. Mit der View //File Explorer// haben Sie Zugriff auf einen Teil des Dateisystems des Smartphones. Sie können auf die das Dateisystem der SD-Karte zugreifen und Dateien vom PC auf das Smartphone und umgekehrt übertragen.
 +
 +{{:wiki:and-prog-abb-1-2.png}}
 +
 +**Abbildung 1.2: Neue Ansichten für Android auswählen**
 +
 +==== Entwicklungssystem für Android über Eclipse verwalten ====
 +
 +Wenn das ADT Plugin installiert ist, können Sie das Entwicklungssystem für Android unter //Window → Android SDK Manager// verwalten. Sie können Teile entfernen oder aktualisisieren. Achten Sie darauf, dass Sie zumindest diejenigen Teile installieren, die Sie für einen Ablauf auf Ihrem Smartphone benötigen.
 +
 +Unter //Window → AVD Manager// verwalten Sie die sog. //Android Virtual Devices//. Hier legt man Simulatoren für die eigenen Apps an, wenn man sie nicht auf dem Smartphone laufen lassen will bzw. kann. Der Start eines sog. AVD kann relativ lange dauern. Man braucht etwas Geduld, bis sich der Simulator zeigt. Deswegen sollte man den Simulator nicht nach jedem Programmlauf einer App beenden. Der Simulator bildet das reale Smartphone nicht vollständig ab, es fehlen diverse Sensoren, die Kamera usw., aber für den Einstieg in die Programmierung mit Android reicht der Simulator aus.
 +
 +===== Erstellung und Ablauf des ersten Programms =====
 +
 +Nach dem Start fragt Eclipse nach dem Ordner für den Arbeitsbereich zum Ablegen aller erstellten Programme. Sie können den Ordner bei den eigenen Daten oder in einem beliebigen Verzeichnis anlegen. Wenn man bei zukünftigen Starts von Eclipse Fragen nach der Lage des Arbeitsbereichs vermeiden will, kann man das Häkchen bei der //Use this as default...//–Option anklicken.
 +
 +{{:wiki:and-prog-abb-1-3.png}}
 +
 +**Abbildung 1.3: Auswahl eines Arbeitsbereichs**
 +
 +Danach meldet sich Eclipse mit seinem Willkommensbildschirm. Sie können jetzt das Eclipse-System erkunden oder gleich weiter zum Arbeitsbereich gehen, indem Sie auf das Pfeil–Symbol am rechten Rand des Bildschirms klicken. Danach sehen Sie die Arbeitsoberfläche von Eclipse aus **Abbildung 1.4**. Am linken Rand finden Sie den "Package Explorer", mit dem Sie die später die einzelnen Projekte erkunden können.
 +
 +{{:wiki:and-prog-abb-1-4.png}}
 +
 +**Abbildung 1.4: Arbeitsoberfläche von Eclipse**
 +
 +Zunächst müssen wir unter dem Menüpunkt //File → New → Android Project// ein neues Projekt für Android erzeugen. Das Projekt enthält die Java–Programme der App sowie Bilder und sonstige benötigte Ressourcen. Wir geben in **Abbildung 1.5** einen Namen für das Projekt ein und Klicken auf //Next//. Im nächsten Schritt wählen wir eine Plattform für den Ablauf aus. **Abbildung 1.6** zeigt, wie man aus den installierten Plattformen als Ziel Android 4.0.3 auswählt. Wenn Sie die Programme auf einem Smartphone ablaufen lassen wollen, müssen Sie die Version von Android auf Ihrem Handy oder eine niedrigere Version wählen.
 +
 +{{:wiki:and-prog-abb-1-5.png}}
 +
 +**Abbildung 1.5: Der erste Schritt beim Anlegen eines Projekts für Android**
 +
 +Mit //Next// erhalten wir den in **Abbildung 1.7** angegebenen Dialog, in dem wir noch den Namen des Packages sowie den Namen der Activity eingeben müssen.
 +
 +{{:wiki:and-prog-abb-1-6.png}}
 +
 +**Abbildung 1.6: Der 2. Schritt beim Anlegen eines Projekts für Android: Auswahl einer Plattform**
 +
 +Nach Drücken von //Finish// in **Abbildung 1.7** erhält man in **Abbildung 1.8** eine erste lauffähige App für Android mit einer Activity namens ''%%HelloWorldActivity%%''.
 +
 +{{:wiki:and-prog-abb-1-7.png}}
 +
 +**Abbildung 1.7: Der 3. Schritt beim Anlegen eines Projekts für Android**
 +
 +{{:wiki:and-prog-abb-1-8.png}}
 +
 +**Abbildung 1.8: Die erste App unter Android**
 +
 +Unsere erste App enthält eine Activity ''%%de.jo.myapps.HelloWorldActivity%%'' im Verzeichnis **src**. Die erste Activity benützt die Konstante ''%%R.layout.main%%''. Im Verzeichnis //gen// finden wir eine Datei ''%%de.jo.myapps.R.java%%''. Diese Datei wird vom Entwicklungssystem für Android generiert und bei jeder Änderung der sog. Ressourcen neu erzeugt. Das Verzeichnis //res// enthält die Ressourcen: Bilder in verschiedener Auflösung in den Verzeichnissen ''%%drawable?.dpi%%'' (?=l, m, h, xh), das Layout der Activity in der Datei ''%%main.xml%%'' sowie die Datei ''%%values.xml%%'' mit Definitionen von Zeichenketten.
 +
 +Eclipse übersetzt das Programm ohne besondere Aufforderung durch den Anwender. Nach einer Sicherung des Programms im Arbeitsbereich über das //File//–Menü oder mit der Tastenkombination //Strg+S// können Sie das Programm mit //Strg+F11// als "Android-Application" laufen lassen und erhalten wie in **Abbildung 1.9** die Ausgabe des ersten Programms.
 +
 +{{:wiki:and-prog-abb-1-9.png}}
 +
 +**Abbildung 1.9: Unsere erste Android-App läuft!**
 +
 +===== Aufbau einer Applikation für Android =====
 +
 +Die Applikation für Android besteht aus verschiedenen Teilen:
 +
 +  - Eine Activity: ''%%HelloWorldActivity.java%%''
 +  - Die Datei mit den generierten Konstanten: ''%%R.java%%''
 +  - Eine Datei mit der Beschreibung des Layouts: ''%%main.xml%%''
 +  - Eine Datei mit Werten: ''%%strings.xml%%''
 +  - Die Datei mit den Einstellungen für die App: ''%%AndroidManifest.xml%%''
 +
 +**Listing 1.1: Die Activity** ''%%HelloWorldActivity.java%%''
 +
 +<code java>
 +package de.jo.myapps;
 +
 +import android.app.Activity;
 +import android.os.Bundle;
 +
 +public class HelloWorldActivity extends Activity {
 +  /** Called when the activity is first created. */
 +  @Override
 +  public void onCreate(Bundle savedInstanceState) {
 +    super.onCreate(savedInstanceState);
 +    setContentView(R.layout.main);
 +  }
 +}
 +</code>
 +
 +Unsere Activity ist von der Basisklasse ''%%android.app.Activity%%'' abgeleitet. Die Methode ''%%onCreate(...)%%'' ist überschrieben. Diese Methode wird von Android aufgerufen, wenn das Exemplar der Klasse ''%%HelloWorldActivity%%'' erzeugt ist. Wir rufen zunächst die entsprechende Methode der Basisklasse auf, die dann evtl. vorhandene Komponenten der Benutzungsoberfläche wiederherstellt. Danach setzen wir die ''%%View%%'' für das Fenster der Applikation. Die ''%%View%%'' ist die Basisklasse für alle Komponenten grafischer Benutzungsoberflächen unter Android, wobei wir an die Klassen ''%%Component%%'' bzw. ''%%JComponent%%'' von Swing (vgl. Kap. 7) denken können. In **Listing 1.1** wird die ''%%View%%'' aus einer Beschreibung in einer Datei im Ressourcen-Teil der Applikation aufgebaut.
 +
 +Man bezeichnet ''%%onCreate(...)%%'' als sog. //Life Cycle Callback//. Jede Activity unter Android hat einen Lebenszyklus (siehe Kap. xx). ''%%onCreate(...)%%'' ist die Methode, die als Erste aufgerufen wird. Hier initialisieren wir unsere Variablen, die Benutzungsoberfläche usw.
 +
 +**Listing 1.2: Die generierte Datei** ''%%R.java%%''
 +
 +<code java>
 +/* AUTO-GENERATED FILE.  DO NOT MODIFY.
 + *
 + * This class was automatically generated by the
 + * aapt tool from the resource data it found.  It
 + * should not be modified by hand.
 + */
 +
 +package de.jo.myapps;
 +
 +public final class R {
 +  public static final class attr {
 +  }
 +
 +  public static final class drawable {
 +    public static final int ic_launcher = 0x7f020000;
 +  }
 +
 +  public static final class layout {
 +    public static final int main = 0x7f030000;
 +  }
 +
 +  public static final class string {
 +    public static final int app_name = 0x7f040001;
 +    public static final int hello = 0x7f040000;
 +  }
 +}
 +</code>
 +
 +Diese Datei enthält Konstanten, die wir im Programm verwenden können. Diese Konstanten werden von einem Programm der Entwicklungsumgebung automatisch aus den Ressourcen erzeugt. In der ersten Activity wird die Konstante ''%%R.layout.main%%'' benutzt. Sie sehen auch die Konstanten ''%%R.string.hello%%'' bzw. ''%%R.string.app_name%%'' für Texte. Wenn wir alle Texte in der Datei ''%%string.xml%%'' ablegen, können wir die Internationalisierung von Android erhalten, wenn wir nur die Texte in den jeweiligen Sprachen angeben. Sind die Texte dagegen im Programm "hart" eincodiert, müssen alle entsprechenden Programmteile geändert werden.
 +
 +**Listing 1.3: Das Layout:** ''%%main.xml%%''
 +
 +<code xml>
 +<?xml version="1.0" encoding="utf-8"?>
 +<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 +  android:layout_width="fill_parent"
 +  android:layout_height="fill_parent"
 +  android:orientation="vertical" >
 +
 +  <TextView
 +    android:layout_width="fill_parent"
 +    android:layout_height="wrap_content"
 +    android:text="@string/hello" />
 +
 +</LinearLayout>
 +</code>
 +
 +Das Layout ordnet alle Komponenten linear an, d. h. die Komponenten werden der Reihe nach von Oben nach Unten (''%%vertical%%'') angeordnet. Dabei füllt das Layout den Bereich seiner Eltern (''%%parent%%'') sowohl horizontal wie auch vertikal aus.
 +
 +Die ''%%TextView%%'' dient der Darstellung von Texten. Sie ist eine ''%%View%%'' und füllt den Bereich der Eltern-Komponente (hier das lineare Layout) in horizontaler Richtung aus. In vertikaler Richtung belegt diese Komponente nur den tatsächlich benötigten Platz. Siehe auch **Abbildung 1.9**. Den Text in diesem Textelement sprechen wir über ''%%@string/hello%%'' an.
 +
 +**Listing 1.4: Die Datei mit den Zeichenketten:** ''%%string.java%%''
 +
 +<code xml>
 +<?xml version="1.0" encoding="utf-8"?>
 +<resources>
 +
 +  <string name="hello">Hello World, HelloWorldActivity!</string>
 +  <string name="app_name">HelloWorld</string>
 +
 +</resources>
 +</code>
 +
 +In dieser Datei fassen wir die Texte im Programm zusammen, wenn wir uns eine einfache Internationalisierung ermöglichen wollen. Im Programm könnten wir einen Text wie folgt ausgeben:
 +
 +<code java>
 +System.out.println(getResources().getString(R.string.app_name));
 +</code>
 +
 +//LogCat// zeigt uns diesen Text für die Applikation ''%%de.jo.myapps%%'' an.
 +
 +**Listing 1.5: Die Datei mit den Einstellungen für die App:** ''%%AndroidManifest.xml%%''
 +
 +<code xml>
 +<?xml version="1.0" encoding="utf-8"?>
 +<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 +  package="de.jo.myapps"
 +  android:versionCode="1"
 +  android:versionName="1.0" >
 +
 +  <uses-sdk android:minSdkVersion="14" />
 +
 +  <application
 +    android:icon="@drawable/ic_launcher"
 +    android:label="@string/app_name" 
 +    android:theme="@android:style/Theme.Light" >
 +    <activity
 +      android:name=".HelloWorldActivity"
 +      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>
 +</code>
 +
 +Die Datei ''%%AndroidManifest.xml%%'' enthält die zentralen Einstellungen für die App. Dort legen wir das Package, die Version sowie die benötigte Version von Android fest. Als einzige Änderung gegenüber der vom Android Plugin generierten Variante sehen Sie das Android-Thema "Light": Der Hintergrund ist standardmäßig dunkel bei hellem Vordergrund. Mit der "Light"-Einstellung erscheint der Hintergrund hell und der Vordergrund dunkel. Sie können ein eigenes Icon erstellen und als Icon für die App festlegen.
 +
 +In dieser Datei führen wir alle von der App angeforderten Rechte auf. Wenn der Anwender bei der Installation der App die angeforderten Rechte wie Zugriff auf das Netzwerk usw. einräumt, dann – und nur dann – darf die App auf das Netzwerk zugreifen.
 +
 +Wir müssen jede Activity der App in dieser Datei aufführen. Mehr dazu später.
 +
 +===== Siehe auch =====
 +
 +  * Original-Dokument von Prof. Dr. Jobst: {{wiki:Jobst_Android_K01.pdf|Jobst_Android_K01.pdf}}
 +  * [[archive:android_in_den_laboren|Android in den Laboren]]
 +  * [[archive:Eclipse-Varianten|Eclipse-Varianten]]
  

Zuletzt angesehen:

Drucken/exportieren