Android

Einführung

• Fast alle Java-Klassen stehen zur Verfügung plus Verschlüsselung, HTTP, JSON, XML Bibliotheken
• Für die Programmierung steht in neueren Versionen Kotlin zur Verfügung.
• Keine main()-Funktion - stattdessen: lose gekoppelte Komponenten, eine oder mehrere davon als Einstiegspunkt definierbar
• Wichtigste Komponente: "Activity" - entspricht einem sichtbaren Fenster auf dem Screen (Ähnlich wie Tabs eines Browsers). Man kann etwa ein Programm mit Screen 1 (Hauptseite) aufrufen oder direkt Screen 2 (Unterseite). Der Aufruf geschieht über die App-Icons.

Entwicklungsumgebung

Zum konkreten Einrichten siehe das Buch Android Apps programmieren). Kapitel 2.1.1 Installation.

Neues Projekt

Mit dem Assistenten wird ein neues Projekt erstellt. Im Android-Buch hat es eine bebilderte Anleitung im Kapitel 3.1.1 ab Seite 62. Je nach Version kann es hier sein, dass gewisse Optionen anders heissen oder Felder neu hinzukommen oder verschwinden. Entsprechend muss man halt schauen, was es braucht oder im Internet nachschauen.
Wähle "File" → "New" → "New Project..."; im "New Project"-Dialog wähle "A new Android Project" aus dem "Android" Order.

Füll den "New Android Project"-Dialog wie folgt aus:

• Project/Application name: "Hello Workshop"
• Company domain: Beliebige domain, die man entweder besitzt oder die es nicht gibt. testprojekt.test.tt, zeit.dict.ch. Ergibt umgekehrt den package name (tt.test.testprojekt, ch.dict.zeit).
• Verwende die "default location" oder lege eine andere Location fest
• Je nach Kenntnissen und Bedürfnissen kann man auch c++ und/oder Kotlin einbinden
• Build target: API21 oder was notwendig wählen. Wenn man bestimmte Funktionen braucht, muss man halt unter "Help me choose" schauen, welche Version welches Feature eingeführt hat (Bluetooth usw.). Aktuelle Daten der Verwendung der Geräte unter: https://developer.android.com/about/dashboards
• Auswahl der gewünschten Vorlage (No Activity, Basic, usw.)
• Activity Name: "HelloWorkshopActivity" -> entspricht der Java-Klasse der Haupt-Activity und wird ohne Vorgabe entsprechend MainActivity genannt. Klassen, welche Fenster steuern, sollten als Konvention auf "Activity" enden, doch dies ist natürlich nur eine Konvention. Damit man weiss, was die Klasse tut, sollte man sie entsprechend der Projektvorgaben nennen.
• Layout Name: "activity_hello_workshop" -> Layouts sollten klein geschrieben werden und mit dem "_" aufgeteilt werden. Layouts für Activities sollten entsprechend mit "activity_" beginnen.

Klicke auf den "Finish"-Button und warte, bis das Projekt erstellt wurde.

Emulator

Gerät einrichten

Falls kein Andoid-Gerät vorhanden ist, oder das gewünschte Gerät fehlt.

Klicke auf das "Android SDK and AVD manager"-Icon in der Icon-Leiste. Klicke auf "New" Im "Create new AVD"-Dialog, gib folgendes ein:

• Name: "G1"
• Target: "Android 1.6 - API Level 4"
• SD Card Size: "1024" MiB
• Skin: Built-in: "Default (HVGA)"

Dann klicke auf "Create AVD" (kann eine Weile - bis zu einigen Minuten - dauern)

Bei der Geräteauswahl kann man auch Geräte mit Playstore anwählen, doch dann kann man bei diesen Geräten keinen Root-Zugriff machen. Man erkennt diese Möglichkeit bei der Auswahl, wenn es ein Icon in der betreffenden Spalte hat.

App auf Gerät testen

Beim Start auf das Play-Icon wird das verknüpfte Gerät gestartet und die App ausgeführt.

Hier kann es sein, dass ein Gerät gestartet wird, doch die App startet nicht und auf der Konsole kommt die Meldung: "Installation did not succeed. The application could not be installed." In diesem Fall wird zwar im AVD-Manager das korrekte Geräte angezeigt, doch unten rechts im Studio beim Design ist ein anderes Gerät angewählt. Dadurch ergibt sich keine Übereinstimmung vom Layout und vom Gerät und somit kann die App nicht starten. In diesem Fall muss das Gerät beim Designer umgestellt werden, auf das vom AVD-Manager und nach einem Neustart der App wird dies auch angezeigt, wenn es nicht noch weitere Fehler gibt.

Verwendete Dateien

Um die verwendeten Dateien zu sehen, muss man den Navigator einblenden, der auf der linken Seite zusammengeklappt werden kann. Anschliessend muss man dann oberhalb der Ansicht unterhalb vom Projektnamen die Art der Darstellung wählen. Falls man mehrere Projekte offen hat, zum gewünschten Projekt navigieren.

Bei der Ansicht Android wird das Projekt "logisch" aufgelistet und entsprechend Dateien, die zusammengehören, wie etwa die Ressourcen zusammen aufgeführt.
Will man hingegen die wirkliche Datenstruktur sehen, so wechselt man auf Project Files, welches den Baum auflistet.
Die Projekte werden standardmässig unter folgendem Pfad gespeichert:
C:\Users\<Benutzername>\AndroidStudioProjects\<Projektname>

Die folgende Tabelle gibt den Stand von Nov. 2020 mit Android Studio 4.1 wieder. Die Entwicklung ist dynamisch und daher kann es gut sein, dass Dateien immer noch verschoben werden und auch Verzeichnisse anders aufgebaut werden. Entsprechend muss man manche Dateien halt suchen, wenn sie nicht am entsprechenden Ort gefunden werden können oder man schaut im Studio, wohin referenziert wird.
Da im Projekt sehr viele Dateien involviert sind, werden "interne" Verzeichnisse und Dateien wie etwa die diversen Build- und Testverzeichnisse nicht aufgeführt. Auch Verzeichnisse, welche nur für die Versionsverwaltung oder fürs Kompilieren verwendet werden, werden nicht aufgelistet.

Datei/Ordner	Beschreibung
/app	Ordner in dem sich das aktuelle Modul befindet. Bei grösseren Projekten können mehrere Module definiert werden.
/app/src	Source-Ordner aller Klassen des Moduls
/app/src/main/AndroidManifest.xml	Linked alle wichtigen Dateien des Projekts. Dort werden auch die Berechtigungen fürs Projekt angemeldet (Datei- und Internetzugriff usw.). Dazu muss man dort Services anmelden oder wenn man ContentProvider für externe Apps bereitstellt.
/app/src/main/java/<domain>/<projektname>/MainActivity.java	Klasse der Haupt-Activity. Verweist mit setContentView(R.layout.main); auf das Layout, welches in der main.xml definiert wurde.
/app/src/main/res	Layout- Sprach- und Bilddateien.
/app/src/main/res/drawable	Bilddateien. Diese werden in den entsprechenden Unterordnern auflösungsabhängig gespeichert, damit die App auch bei unterschiedlichen Geräten in etwa gleich ausschaut.
/app/src/main/res/layout	Layouts. Da das Layout beim drehen meist etwas anders angezeigt wird, gibt es auch den Ordner layout-land, in dem das "landscape" Layout abgelegt wird.
/app/src/main/res/layout/activity_main.xml	Das Layout wird als XML-Datei erstellt. Die Ressourcen werden dort entsprechend auf die Text-Ressource-Dateien verwiesen, damit man die App nur einmal kompilieren muss und trotzdem verschiedene Sprachen anbieten kann. Wird erstellt aus dem Namen, den man beim generieren des Projekts für das Layout wählt. Ohne Anpassung wird er aus dem Projektnamen gebildet.
/app/src/main/res/menu	Falls man ein Menü in der Action-Bar anbieten will, werden die Ressourcen dafür hier angelegt. Standardmässig wird das Manü aber nicht angelegt.
/app/src/main/res/mipmap*	Icons. Diese werden in den entsprechenden Unterordnern auflösungsabhängig gespeichert, damit diese auch bei unterschiedlichen Geräten in etwa gleich ausschauen. (xxxhdpi = 192 x 192 Pixel – 640 dpi / xxhdpi = 144 x 144 Pixel – 480 dpi / xhdpi = 96 x 96 Pixel – 320 dpi / hdpi = 72 x 72 Pixel – 240 dpi / mdpi = 48 x 48 Pixel – 160 dpi / ldpi = 36 x 36 Pixel – 120 dpi)
/app/src/main/res/values(-xx)	Text-Ressource-Dateien. Diese Dateien enthalten Wertepaare für verschiedene Anwendungen wie Farben oder Strings, welche man dann in verschiedene Sprachen überstzene kann und die dann das entsprechende Länderkürzel angehängt bekommen.
/assets	Ordner für Binär-Dateien (alles, was Android nicht selbst verwaltet). Wird standardmässig nicht angelegt.
/gradle	Wird für die Versionsverwaltung eingesetzt.

AndroidManifest.xml

Legt diverse Werte zum Aussehen und Verhalten des Programms fest. https://developer.android.com/guide/topics/manifest/manifest-intro

Folgende Einträge sind für die Unterstützung von unterschiedlichen Geräte möglich. Evtl. bei neueren Versionen nicht mehr notwendig.

<supports-screens android:anyDensity="true"
                  android:largeScreens="true" 
                  android:smallScreens="true" />

• anyDensity für hohe Auflösungen
• largeScreens bei grossen Displays
• smallScreens für kleine Displays

Für Berechtigungen werden Einträge in folgender Weise hinzugefügt:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.INTERNET" />

Wenn man Eclipse verwendet, kann man aus den Warnungen ableiten, wenn man etwas falsch definiert. Dazu kann man entweder die Datei direkt bearbeiten oder dies über den Tab umstellen und manches direkt grafisch anpassen.

Ein Beispiel ist im Android-Buch auf Seite 39 (Kap. 2.2.2 App-Bausteine) aufgeführt.

MainActivity.java

Enthält, wie unter Programmierung gezeigt, das Hauptprogramm. Der Name wird entsprechend bei Projekteröffnung festgelegt. Hier werden unter anderem die Elemente definiert.

private Button hiButton; private Button helloButton;

strings.xml

Legt die Werte für die Strings fest. Hier wurden zwei Srings "hello" und "app_name" definiert, welche nun in anderen Dateien verwendet werden können (Layout oder Programm). Siehe dazu den Abschnitt Texte.

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

Android-App kompilieren (Gradle)

Im Gegensatz zu einem "normalen" Programm, müssen bei einer Android-App viele verschiedene Tools zusammenarbeiten, um am Schluss eine lauffähige App bereitstellen zu können. Gradle ist ein Build Management Tool für Java, das diese Aufgaben bündelt.

1. Herunterladen von externen Abhängigkeiten (externe Bibliotheken)
2. Kompilieren der Java-Dateien in DEX
3. Kompilieren der Ressourcen (Bilder, Icons, usw.)
4. Verpacken als APK-Datei (DEX + Ressourcen)
5. Signieren der APK-Datei
6. Optimieren der App auf Speicherverbrauch

Gradle benutzt eine auf Groovy aufbauende DSL (Domain Specific Language). Wenn man weiss wie und es braucht, so kann man den Build-Prozess entsprechend anpassen. Siehe dazu den Link: https://developer.android.com/studio/build

Für die Einbindung der externen Bibliotheken wird das Maven-Repository eingebunden.

Programmierung

Zustände einer App

Grafik aus dem Androidbuch.

Zyklus einer App

Zuerst ein Beispiel, welches unten erklärt wird:

class MyActivity extends Activity {

  onCreate {
    View view = ... // erstellt den sichtbaren Teil
    setContentView(view);
    ...
  } // end Eventhandler onCreate

  onClick {
    ...
    Intent intent = ... // Zugriff auf externes Programm
    startActivity (intent);
  } // end Eventhandler onClick

} // end class MyActivity

Activity

• definiert eine "View", zur Anzeige auf dem Screen. Entspricht einem Fenster.
• behandelt "Events" (z. B. Klick auf einen Button)
• benutzt "Intents", um andere Activities zu starten

Fragment

Wurden mit Android 3.1 eingeführt und sind selbständige Teilbereiche einer Activity. Können entsprechend auf verschiedenen Activities wiederverwendet oder in einer Activity mehrfach eingesetzt werden.

View

• eine "View" ist der sichtbare Teil der Activity
• definiert in einer XML-Layout-Datei (oder im Code)

Events / Programmablauf

• werden ausgelöst, wenn etwas geschieht (z. B ein Button geklickt wird)
• ruft eine Listener-Methode auf, sofern ein Listener definiert ist

Ein Beispiel mit mehreren Events für einen Programmablauf sieht man hier: http://www.androidpit.de/de/android/wiki/view/Datei:Beginners_Workshop_Activity_LC.png
Um Datenverlust oder den Verlust des Zustands einer Activity zu vermeiden, müssen die Daten/der Zustand der Activity gesichert werden, wenn diese pausiert (nicht mehr im Vordergrund, aber noch sichtbar) oder gestoppt (nicht mehr sichtbar) wird.

onClick()

• Aufruf beim Drücken auf einen Button

EditText nameField = (EditText) findViewById(R.id.name_field);
String name = nameField.getText().toString();
if (name.length() == 0) {
    new AlertDialog.Builder(this) 
                   .setMessage(R.string.error_name_missing)
                   .setNeutralButton(R.string.error_ok, null)
                   .show();
    return;
} // end if

onCreate()

• wird einmalig beim Programmstart aufgerufen
• muss die View und die Elemente darin definieren
• springt anschliessend weiter nach onStart()
• definiert die Listener-Aufrufe

hiButton = (Button)findViewById(R.id.hi_button);
hiButton.setOnClickListener(this);
helloButton = (Button)findViewById(R.id.hello_button);
helloButton.setOnClickListener(this);

onDestroy()

• Wird nur aufgerufen, wenn das Programm explizit beendet wird

onPause()

• Geht weiter nach onResume, wenn es wieder in den Vordergrund geholt wird oder nach onStop, wenn es gar nicht mehr sichtbar ist
• Da das Programm bei Speichermangel in diesem Zustand "abgeschossen" werden kann, müssen spätestens hier die Benutzerdaten gesichert werden

onRestart()

• Falls das Programm gestoppt wurde, doch noch nicht wegen Speichermangels aus dem RAM entfernt wurde und nun wieder in den Vordergrund kommt, wird diese Methode aufgerufen
• Springt anschliessend direkt nach onStart()

onResume()

• Wird jedes Mal aufgerufen, wenn die App nach einer Pause (wieder) in den Vordergrund kommt

onStart()

• Springt weiter nach onResume()

onStop()

• Wird aufgerufen, wenn das Programm nicht mehr sichtbar ist
• Je nach weiterer Folge, geht der Programmlauf weiter mit onDestroy oder onRestart.

Intent

• startet eine andere Activity ("öffnet ein neues Fenster")
• kann Daten an die zu startende Activity übergeben
• kann Activities aus anderen Apps starten!

Layouts und Elemente

Siehe im Androidbuch Kapitel 2.2.3 ab Seite 42. Wie oberhalb erwähnt, wird in /res/layout/<NameMainActivity>.xml das Layout der Hauptdatei festgelegt. Das heisst, hier werden die Elemente festgelegt. Layouts werden extra in XML-Dateien erstellt, damit man eine exakte Trennung zum Code erhält, auch wenn man natürlich das Layout auch im Java-Code erstellen kann. Alle sichtbaren Elemente leiten sich von der Basisklasse View ab, wobei die Elemente in zwei Gruppen aufgeteilt werden:

• ViewGroup
• View

Wobei jede ViewGroup Views und weitere ViewGroups enthalten kann.

ViewGroups (Layouts)

Siehe im Androidbuch ab Seite 75 Kapitel 3.3 Layout-Erstellung. Folgende ViewGroups werden standardmässig unterstützt:

• LinearLayout: Die enthaltenen Views werden unter- ober nebeneinander aufgelistet. Je nachdem, wie man die Eigenschaft orientation gesetzt hat. Die enthaltenen Views kann man mit %-Angaben aufteilen.
• RelativeLayout: Ordnet die Views im Verhältnis zu sich selbst oder anderen Elementen an. Dies kann sein: rechts von View 2, oberhalb von View 3, zentriert im Container, unterhalb vom oberen Rand, usw.
• TableLayout: Ordnet die Views als Zeilen und Spalten an. Die Breite der Spalten wird durch die Breite des Inhalts bestimmt.
• GridLayout: Ähnlich wie TableLayout, doch braucht keinen Container. Dazu können die Zellen gewichtet aufgeteilt werden (prozentual). Für Abstände kann man auf die Eigenschaft Space zurückgreifen. Views können über mehrere Zeilen/Spalten "aufgespannt" werden. Dies ermöglicht komplexe Layouts, ohne dass man dafür mehrere Layouts verschachteln müsste.
• ConstraintLayout: Verwandt mit RelativeLayout, doch flexibler. Die Elemente stehen zwar in Beziehung, doch diese Kopplung ist loser und ermöglicht präzise Positionierungen. Die Beziehungen werden durch "Spannfedern" dargestellt.
• ListView: Wird normalerweise nur verwendet, um Daten etwa aus einer Datenbank automatisch abzufüllen und als Liste darzustellen.
• GridView: Hier werden die Daten wie bei einer ListView abgefüllt, doch etwa wie die Bilderansicht im Explorer in einem Gitter dargestellt.

vertikale und horizontale Layouts

Layouts können auch geschachtelt werden. Das Hauptlayout ist meist vertikal.

Vertikales Layout mit einem Titel:

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

Der Inhalt des Strings wird in der /res/layout/strings.xml definiert

Horizontales Layout mit zwei Knöpfen.

<LinearLayout 
    android:orientation="horizontal"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
     >
    <Button 
        android:id="@+id/hi_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="@string/hi_button" 
        />
    <Button 
        android:id="@+id/hello_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="@string/hello_button" 
        />
</LinearLayout>

Views (Elemente)

Die Elemente werden wie erwähnt in den Layouts platziert und vom Benutzer verwendet, während die ViewGroup im Hintergrund "nur" den Platz aufteilt. Die Elemente werden am einfachsten in der "Designer-Ansicht" auf der Activity verteilt, da man so nicht alles im XML-Code erstellen muss, sondern nur noch die Beziehungen oder Positionen sauber setzen muss.

Button (Knopf)

Ermöglicht das entgegennehmen von Aktionen und deren Auswertung im Code.

<Button 
    android:id="@+id/hi_button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_weight="1"
    android:text="@string/hi_button" 
/>

Der Knopf braucht neben der Beschriftung, welche in der strings.xml definiert wird, noch eine id, welche wieder im Programm über ein Event ausgewertet werden kann.

EditText (Eingabefeld)

Dieses Feld kann Text vom Benutzer entgegen nehmen. Durch setzen der Eigenschaft inputType kann man die Eingaben einschränken etwa auf Text, URI, E-Mail, Zahlen, Passwort, Dezimalzahlen, Datum, Uhrzeit, Telefonnummer, usw. (eigene Filter sind möglich).

<EditText
    android:id="@+id/name_field"
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
/>

Hier bekommt das Feld eine id("name_field"), welche man später im Programm verwenden kann, um den Wert auszulesen.

ImageView

Ermöglicht das Darstellen von Bildern. Diese kann man aus den Ressourcen laden oder vom internen Speicher.

Spinner

Entspricht in anderen Sprachen einer Radiobox, bei der man von mehreren Einträgen nur einen auswählen kann.

Switch

Auswahl zwischen zwei Werten. Entspricht einer Checkbox.

TextView (Label)

Stellt einen nicht bearbeitbaren Text dar etwa für Beschriftungen.

<TextView
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:layout_marginTop="20dp"
    android:text="@string/enter_your_name"
/>

Hier müssten wir noch den String "enter_your_name" in der strings.xml definieren.

WebView

Darin lässt sich eine (lokale) Webseite direkt anzeigen. Kann man auch für Hilfeseiten verwenden.

Verweise

Damit man aus dem Java-Code auf die einzelnen Elemente der Oberfläche zugreifen kann, braucht es eine eindeutige ID, welche man jedem Element vergeben muss, das man im Code ansprechen möchte. Dazu dient die ID bei den Eigenschaften in der Layout-Datei.

<TextView
android:id="@+id/TextStartDateTime"

Das + vor der ID ist notwendig, damit Android weiss, dass die Ressource vor dem Zugriff evtl. noch erstellt werden muss.

Ressourcen

Damit man Texte übersetzen oder Bilder verwenden kann, muss man diese im Programm zur Verfügung stellen. Eine kurze Übersicht sieht man im Abschnitt Verwendete Dateien. Während Bilder oder Videos einfach referenziert werden, möchte man Sprachen auch übersetzen. Entsprechend verwendet man im Programm nur eine Referenz, welche dann je nach Spracheinstellung auf den richtigen Spracheintrag verweist.

Für den Zugriff auf diese Dateien, muss man die ID entsprechend als Verweis gestalten.

Texte

Standardmässig steht strings.xml zur Verfügung, doch man kann mit der entsprechenden Referenz auch auf andere Dateien verweisen, falls man etwa pro Activity eine eigene Referenzdatei möchte. Damit die Referenzdatei auch verwendet wird, muss man im Layout auch darauf verweisen. Dazu wird bei der Eigenschaft des Elements entsprechend nicht einfach ein Text hinterlegt, sondern ein Verweis auf eine Textressource. Anstatt android:text="Beschriftung" heisst es dann @string/LabelStartTime. Damit verweist man auf eine Stringressource mit Namen LabelStartTime. Nun kann in der Datei strings.xml der Eintrag zu den Ressourcen hinzugefügt werden: <string name="LabelStartTime">Start</string>.

Will man mehrere Sprachen zur Verfügung stellen, so werden entsprechend Kopien der strings.xml erstellt, doch nicht mehr im Unterordner values, sondern bei englisch etwa values-en oder französisch values-fr. In der Datei werden dann einfach die übersetzen Texte hineingeschrieben und so kann Android je nach Sprachwahl die korrekten Texte anzeigen. Wichtig ist, dass die Datei weiterhin strings.xml heisst oder wie auch immer man die Referenzdatei genannt hat.
Das Erstellen der Ordner kann man auch im Studio mittels Rechtsklick auf den Ressourcen-Ordner values -> New -> Values ressource File durchführen. Dort den Namen der Datei (strings) eingeben und unten locale wählen und danach die gewünschte Sprache (mit Lokalisierung) wählen.
Um anschliessend die Übersetzungen zu verwalten, kann man einfach die originale Datei öffnen und nachher rechts oben den Eintrag Open editor wählen, worauf man die Sprachdateien sauber nachtragen kann.

Leider weiss ich noch nicht, wo man die Referenz setzt, wenn man etwa einen anderen Namen oder mehrere Dateien möchte. Der Verweis kann entweder manuell in den Dateien erstellt werden oder über einen Rechtsklick auf den Eintrag in der layout.xml Datei mit dem Menü "Extract string ressource". Es ist auch direkt im Designer mittels Doppelklick aufs Element möglich. Dort bei den Eigenschaften verweist man dann mit "Add New Ressource -> new string value" auf den String. Siehe Im Androidbuch Kapitel 3.3.2 Ressourcen für die Texte ab Seite 83.

Abstände

Siehe im Androidbuch ab Seite 92 das Kapitel Innenabstand als Ressource.
Damit man Abstände nicht manuell anpassen muss, kann man diese genauso wie Texte als Ressource auslagern und darauf verweisen. So muss man anschliessend die Anpassungen nur noch in der Ressourcendatei vornehmen und kann dort auf mehrere Orte verweisen. Normalerweise wird dafür die Datei dimens.xml verwendet.

Die Abstände können in folgenden Masseinheiten angegeben werden:

• dp oder dip: Auflösungsunabhängiges Pixel, welches je nach Auflösung grösser dargestellt wird, damit es immer gleich gross aussieht.
• sp: Ähnlich dp, doch kann es skaliert werden. Wird meist für Texte verwendet.
• pt: 1/72 Zoll fix
• px: Reales Pixel. Entsprechend wäschst oder schrumpft eine solche Angabe je nach Auflösung
• mm: Milimeter
• in: Zoll (inch)

Services

Laufen im Hintergrund. Werden verwendet, um Operationen aufzuführen, welche länger dauern und daher ausgelagert werden, wie etwa das herunterladen einer Datei von einem Server.

Content Provider

Sind die Schnittstellen nach aussen. So kann man mit der entsprechenden Berechtigung etwa die Kontaktdaten abfragen oder einen Telefonanruf starten, ohne selber eine Telefon-Activity programmieren zu müssen. Damit nicht jede App einfach auf ein anderes Programm zugreifen kann, muss man den Zugriff in der AndroidManifest.xml anmelden und der Benutzer muss beim ersten Zugriff dies erlauben.

Broadcast Receiver

Sind Benachrichtigungen, welche vom Betriebssystem und zum Teil auch von Apps versandt werden und auf die man entsprechend reagieren kann. Dies kann etwa "Power connected" oder Airplane Mode" sein. Eine Liste enthält dieser Link: https://developer.android.com/guide/components/broadcasts

Programmierbeispiel komplett

Wenn man ein Android-Projekt unter Eclipse erstellt, so generiert Eclipse mehrere Dateien. Hier werden nun alphabetisch alle Dateien aufgeführt, welche im Beispielprojekt manuell angepasst wurden.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.helloworkshop"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="16" />
    
    <supports-screens 
        android:anyDensity="true"
        android:largeScreens="true" 
        android:smallScreens="true" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.helloworkshop.HelloWorkshopActivity"
            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>

HelloWorkshopActivity.java

package com.example.helloworkshop;

import android.app.Activity;
import android.app.AlertDialog;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;


public class HelloWorkshopActivity extends Activity implements OnClickListener {

	private Button hiButton;
	private Button helloButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        hiButton = (Button)findViewById(R.id.hi_button);
        hiButton.setOnClickListener(this);
        
        helloButton = (Button)findViewById(R.id.hello_button);
        helloButton.setOnClickListener(this);
    } // end onCreate

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

    public void onClick(View v) {
        EditText nameField = (EditText) findViewById(R.id.name_field);

        String name = nameField.getText().toString();

        if (name.length() == 0) {
            new AlertDialog.Builder(this).setMessage(
                    R.string.error_name_missing).setNeutralButton(
                    R.string.error_ok,
                    null).show();
            return;
        }

        if (v == hiButton || v == helloButton) {
            int resourceId = v == hiButton ? R.string.hi_greeting
                    : R.string.hello_greeting;

            String greeting = getResources().getString(resourceId, name);
            Toast.makeText(this, greeting, Toast.LENGTH_LONG).show();

            TextView greetingField = (TextView) findViewById(R.id.greeting_field);
            greetingField.setText(greeting);
        }
    } // end onClick
    
} // end class HelloWorkshopActivity

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:id="@+id/greeting_field"
	    android:layout_width="fill_parent" 
	    android:layout_height="wrap_content" 
	    android:text="@string/hello"
	/>

	<TextView 
	    android:layout_width="fill_parent" 
	    android:layout_height="wrap_content" 
	    android:layout_marginTop="20dp"
	    android:text="@string/enter_your_name"
    />
	
	<EditText
	    android:id="@+id/name_field"
	    android:layout_width="fill_parent" 
	    android:layout_height="wrap_content" 
	>
	</EditText>
	
	<LinearLayout 
	    android:orientation="horizontal"
	    android:layout_width="fill_parent"
	    android:layout_height="wrap_content"
     >
	    <Button 
	        android:id="@+id/hi_button"
	        android:layout_width="wrap_content"
	        android:layout_height="wrap_content"
	        android:layout_weight="1"
	        android:text="@string/hi_button" 
	    />
	    <Button 
	        android:id="@+id/hello_button"
	        android:layout_width="wrap_content"
	        android:layout_height="wrap_content"
	        android:layout_weight="1"
	        android:text="@string/hello_button" 
	    />
	</LinearLayout>

</LinearLayout>

strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="action_settings">Settings</string>
    <string name="app_name">Hello Workshop</string>
    <string name="enter_your_name">Gib bitte Deinen Namen ein:</string>
    <string name="error_name_missing">Please enter your name.</string>
    <string name="error_ok">OK</string>
    <string name="hello">Hallo Welt Workshop!</string>
    <string name="hello_button">Say Hello!</string>
    <string name="hello_greeting">Hello %s!</string>
    <string name="hi_button">Say Hi!</string>
    <string name="hi_greeting">Hi %s!</string>
</resources>

Programm auf Gerät verschieben

Mittels Google-Konto

1. Im Ordner bin/res befindet sich die Datei "Projektname.apk". Diese ist die notwendige Datei.
2. Die Datei als Anhnag ans Google-Konto senden
3. Den Anhang im Gerät anwählen und danach installieren. Will das Gerät dies nicht, kann evtl. das Programm AKPatcher verwendet werden (hat bei mir aber immer nur den Info-Screen angezeigt)
4. Anschliessend kann die App übers App-Menü gestartet werden

Mittels USB-Verbindung

Folgende Bildergalerie verwenden: http://www.chip.de/bildergalerie/So-geht-s-APKs-via-USB-installieren-Galerie_56637615.html

1. Einstellung: Unbekannte Quellen zulassen
2. Verbinden im Massenspeicher Modus
3. APK-Datei auf das Gerät in den gewünschten Ordner kopieren
4. Mit dem Dateimanager ins obige Verzeichnis navigieren und die Datei anwählen und installieren

Links

Link	Beschreibung	Niveau
Java	Java-Wiki	Anfänger
http://www.vogella.com/articles/Android/article.html	Android-Einführungstutorial englisch	Anfänger-Fortgeschrittene
http://www.makeuseof.com/tag/write-google-android-application/	Android erste Applikation von Google englisch	Anfänger
http://www.kammerath.net/android-app-programmieren.html	Android app programmieren deutsch	Anfänger
http://www.vogella.com/articles/AndroidIntent/article.html	Android Intents englisch	Fortgeschrittene