Zeit- und Ortserfassung mit Android, Teil 1

Da die meisten der aktuell verkauften Smartphones und Tablet-PCs unter dem Betriebssystem Android laufen, erhalten Sie in diesem und folgenden Artikeln eine beispielorientierte Einführung in die Programmierung der Geräte anhand einer Zeiterfassungs-App.

Eine eigene App zu programmieren, ist unter Android denkbar einfach: hier genügt das Herunterladen des Android SDK und einiger anderer Komponenten ohne kostenpflichtige Registrierung, um selbst entwickelte Apps auf dem eigenen Smartphone einsetzen zu können. Grundsätzlich sollte man aber über Grundkenntnisse in der Programmiersprache Java verfügen und auch schon mal etwas von der Entwicklungsumgebung Eclipse gehört haben.

Voraussetzungen

Neben einem entsprechenden Smartphone oder Tablet-PC mit Android-Betriebssystem benötigen angehende App-Entwickler selbstverständlich zunächst einmal einen PC mit Windows-, Linux- oder Mac OS X als Betriebssystem. Darüber hinaus sollte auf dem Entwicklungsrechner die Programmiersprache Java installiert sein, und zwar nicht nur als Runtime-Umgebung (JRE) sondern als Java-Development-Kit (JDK). Besitzer eines unter Mac OS X laufenden PCs haben es hier etwas einfacher: hier ist beides normalerweise bereits werksseitig installiert. Unabhängig vom Betriebssystem sollten Sie daher zunächst auf Ihrem PC eine Eingabeaufforderung öffnen und die beiden folgenden Befehle eingeben:

java --version
javac -version

Sollte der zweite Befehl eine Fehlermeldung zurückliefern, ist das Java Development Kit (JDK) nicht korrekt installiert. Dann sollten Sie die Internetseite [2] besuchen und Java für Entwickler in der Variante Java SE herunterladen. Nach der Installation sollte der Befehl javac --version keine Fehlermeldung mehr liefern. Nun geht es darum, die etwa 180 MB große Entwicklungsumgebung Eclipse classic von der Internetseite [3] herunterzuladen und zu entpacken. Da wir aber für Android entwickeln wollen, müssen wir uns noch das etwa 30 MB große Android SDK von [4] herunterladen und installieren.

Anschließend finden Sie im Startmenü einen Eintrag mit dem Namen Android SDK Tools finden. Darunter sollte sich auch ein Startmenüeintrag SDK Manager befinden, welcher die tatsächlich benötigten Komponenten aus dem Internet herunterlädt. Da jedes Android-Smartphone oder -Tablet mit einer entsprechenden Version der Android-Plattform arbeitet, müssen Sie sich noch die entsprechende Plattform herunterladen.

Da zum Zeitpunkt der Drucklegung dieses Artikels noch viele Smartphones mit der Version 2.3.x. ausgestattet sind, ist es sinnvoll alle Plattformen ab Android 2.3 mit dem SDK Manager herunterzuladen. Auch die Installation des Google USB Drivers, welcher unter dem Punkt Extras steht, kann nicht schaden, wenn man seine Anwendung nicht nur im Simulator testen möchte. Unter Linux und Mac OS X fällt dieser Teil weg, da hier die benötigten Treiber von Haus aus integriert sind. Samsung-Nutzer benötigen eventuell noch die Software Kies, wenn der generische Treiber von Google das Gerät nicht erkennt.

Nachdem sich nun das Java Development Kit, Eclipse Standard und das Android SDK auf dem Entwicklungsrechner befinden, ist es an der Zeit die beiden letztgenannten miteinander bekannt zu machen. Dies geschieht mittels des sogenannten ADT Plugin for Eclipse, welches unter Windows folgendermaßen installiert wird:

Starten Sie Eclipse, wählen Sie dort Help | Install New Software? worauf der in Abbildung 2 gezeigte Dialog erscheint. Hier wählen Sie bitte Add und tragen anschließend im darauf folgenden Dialog Add Repository neben Name ADT Plugin und https://dl-ssl.google.com/android/eclipse/ neben Location ein.

Abschließend muss das ADT Plugin in Eclipse noch folgendermaßen konfiguriert werden: Window | Preferences | Android auswählen und die SDK Location einstellen, wie beispielsweise in Abbildung 3 gezeigt. Die Vorgehensweise unter Mac OS X und Linux ist ähnlich.

Das Beispielprojekt

Wir wollen in diesem Workshop eine kleine App schreiben, die nach dem Start das aktuelle Datum und die aktuelle aber editierbare Uhrzeit anzeigt. Zusätzlich soll es ein Textfeld geben, in welches eine Bemerkung geschrieben werden kann. Darüber hinaus soll es folgende Buttons geben:

• Speichern: Um die Eingabe in eine Datei mit Namen zeit.txt auf dem Smartphone abzuspeichern, wobei jeweils eine neue Zeile für jeden Eintrag erzeugt wird.
• Inhalt bearbeiten: Um den Inhalt der Datei zeit.txt auf dem Smartphone nachträglich bearbeiten zu können.
• Zeitdatei hochladen: Um die Datei zeit.txt über eine WLAN-, GSM- oder UMTS- Verbindung mittels des FTP-Protokolls auf einen Webserver zu übertragen.
• Zeitdatei löschen: Um die Datei zeit.txt auf dem Smartphone zu löschen

Anwendungsszenarios könnten beispielsweise ein kleines Tagebuch oder eine Stechuhr-Funktion sein. Vertreter könnten so beispielsweise erfassen, wann sie welchen Kunden besucht haben und abends die Datei auf den Firmenserver hochladen, wo sie weiterverarbeitet wird. Abbildung 4 zeigt, wie so eine Anwendung unter Android 2.3 aussehen könnte:

Wählen Sie dazu zunächst File | New | Other? im Programm Eclipse. Nun sollten Sie nacheinander die in Abbildung 5 gezeigten Dialoge sehen:

Wichtig ist hier, dass Android Project ausgewählt wird, woraufhin Fenster erscheinen, in denen der Projektname, die zu verwendende SDK-Version sowie der Paketname angegeben werden müssen. Öffnen Sie anschließend den Package Explorer über Window | Show View, sehen Sie das Grundgerüst des Android-Projektes: Im Ordner src befinden sich die Quelltexte, während sich im Ordner res die Ressourcen-Dateien, wie Icons, Layout-Dateien und für die Internationalisierung von Apps nötigen Strings befinden. Die Datei AndroidManifest.xml ist die zentrale Beschreibungsdatei der Anwendung, welche unter anderem Informationen über deren Bestandteile, die Rechte der App (z. B. Zugriff auf Dateisystem und Netzwerk) und die mindestens erforderliche Android-Systemversion enthält.

Erstellen der App-Oberfläche

Im Ordner res/layout befindet sich eine Datei main.xml , welche die auf dem Smartphone/Tablet anzuzeigende Oberfläche der App beschreibt. Das ADT-Plugin für Eclipse enthält einen komfortablen Designer. Hier können Sie auch die Bildschirmgröße und -Ausrichtung Ihres Smartphone/Tablet auswählen, damit Sie beim Oberflächendesign ein Gefühl für die Bildschirmgröße haben. Anschließend ziehen Sie die benötigten Buttons, Labels etc. aus der Widget-Box per Drag-and-Drop auf das Formular, so dass es der Abbildung 6 ähnlich sieht.

Damit die Programmoberfläche später auf dem Smartphone/Tablet auch dann noch bedienbar bleibt, wenn das mobile Gerät im Querformat gehalten wird, empfiehlt es sich unterhalb von res noch ein Verzeichnis layout-land anzulegen und dort die Layout-Dateien für das Querformat zu hinterlegen. Damit Sie später die Quelltexterläuterungen nachvollziehen können, empfehlen wir Ihnen, die Elemente auf dem Formular wie in der Outline-Anzeige rechts in Abbildung 6 gezeigt, zu benennen. Den recht simplen Aufbau des zweiten Formulars der App, dem Formular bearbeiten.xml , entnehmen Sie dem Download-Archiv unter [5] auf der Android-User-Homepage.

Änderungen an der Projektdatei

Da die App auch auf Datei- und Netzwerkfunktionalitäten zurückgreifen soll, sind in der standardmäßig ADT-Projektassistenten erstellten Datei AndroidManifest.xml folgende Änderungen erforderlich:

• Dem XML-Knoten manifest sind die Berechtigungen android.permission.WRITE_EXTERNAL_STORAGE und android.permission.INTERNET hinzuzufügen.
• Unterhalb des XML-Knotens application ist ein weiterer Activity-Knoten mit dem Namen BearbeitenActivity hinzuzufügen, damit der Bearbeiten-Dialog mit eingebunden wird.

Die angepasste Manifest-Datei sollte also wie in Listing 1 aussehen.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="https://schemas.android.com/apk/res/android"
    package="de.cssenior.zeiterfassung"
    android:versionCode="1"
    android:versionName="1.0" >
    <uses-sdk android:minSdkVersion="8" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    <application
        android:icon="@drawable/uhr"
        android:label="@string/app_name" >
        <activity
            android:name="ZeiterfassungActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name="BearbeitenActivity"
            android:label="@string/bearbeitenbuttontext" >
        </activity>
    </application>
</manifest>

Implementierung der App-Funktionalitäten

In der vom ADT-Projektassistenten erstellten Datei ZeiterfassungActivity.java muss eine statische globale Variable zeitdatei mit dem Pfad der Zeitdatei auf dem Smartphone angelegt werden, wobei der Pfad je nach Smartphone-Modell auch anders lauten könnte. In der auszugsweise im Listing 2 gezeigten Prozedur onCreate der ZeiterfassungActivity werden die im Graphical Layout Designer erstellten Widgets, wie beispielsweise das TimePicker-Widget und Buttons wie der Speicher-Button initialisiert und mit Leben gefüllt. Die eigentliche Funktionalität zum Speichern der eingegebenen Daten offenbart Listing 3.

zeit = (TimePicker) findViewById(R.id.timePicker1);
zeit.setIs24HourView(true);
zeit.setCurrentHour(new java.util.Date().getHours()); //Workaround falsche 24-Std.-Darstellung
Statuslabel = (TextView) findViewById(R.id.textViewStatus);
bemerkung = (EditText) findViewById(R.id.editText1);
Button btnSpeichern = (Button) findViewById(R.id.btnSpeichern);
btnSpeichern.setOnClickListener(new OnClickListener() {
       @Override
        public void onClick(View v) {
                speichern();
        }
});

public void speichern() {
        System.out.println("Speichern wurde angeklickt");
        meldung=String.format("%02d.%02d.%04d %02d:%02d %s
",
              datum.getDayOfMonth(),datum.getMonth()+1,datum.getYear(),
              zeit.getCurrentHour(),zeit.getCurrentMinute(),bemerkung.getText().toString());
        FileWriter fw;
        try {
                fw = new FileWriter(zeitdatei,true);
                fw.write(meldung);
                fw.close();
                finish();
        } catch (IOException el) {
                el.printStackTrace();
                meldung="Fehler beim Schreiben der Datei.";
                System.out.println(meldung);
                new AlertDialog.Builder(this)
                        .setTitle(R.string.app_name)
                        .setMessage(meldung)
                        .setPositiveButton(android.R.string.ok,null).show();
        }
}

Damit es möglich ist, die erfasste Zeitdatei auf einen Webserver zu übertragen, muss noch die commons.net-Bibliothek des Apache-Projekts, welche auch FTP-Funktionen enthält, unter der Internetadresse [6] heruntergeladen und auf dem PC installiert werden. In den Projekteigenschaften wird die commons.net-Bibliothek unter Java Build Path | Libraries eingebunden und in der ZeiterfassungActivity mittels

import org.apache.commons.net.ftp.*;

importiert. Listing 4 zeigt die Prozedur zum Hochladen der Zeitdatei auf den Server, wobei Sie allerdings noch Ihre eigenen FTP-Server-Angaben an den gekennzeichneten Stellen eintragen müssen:

public void hochladen() {
   meldung="Hochladen wurde angeklickt";
   System.out.println(meldung);
   mFTPClient = new FTPClient();
   begzeit = new SimpleDateFormat("HH:mm:ss").format(new Date()) + " : ";
   boolean erg=ftpConnect("www.server.de","user","kennwort",21); // Hier eigene Server-Angaben eintragen!
   if (erg) {
        meldung="ftpConnect erfolgreich";
        System.out.println(meldung);
        Statuslabel.setText(begzeit + meldung);
        erg=ftpUpload(zeitdatei,"zeit.txt","/subdir"); // Hier eigenes Unterverzeichnis eintragen!
        begzeit = new SimpleDateFormat("HH:mm:ss").format(new Date()) + " : ";
        if (erg) {
                meldung="hochladen erfolgreich";
        } else {
                meldung="hochladen nicht erfolgreich";
        }
        Statuslabel.setText(begzeit + meldung);
        erg=ftpDisconnect();
        if (erg) Toast.makeText(this, "ftpDisconnect erfolgreich", Toast.LENGTH_SHORT).show();
   } else {
        meldung="ftpConnect nicht erfolgreich";
        System.out.println(meldung);
        Statuslabel.setText(begzeit + meldung);
   }
}

Eine auf diese Weise erstellte App lässt sich nun entweder im Emulator des Android SDK oder auf einem per USB verbundenen Smartphone oder Tablet testen. Um die App im Emulator zu testen, müssen Sie zunächst aus Eclipse mittels Window | AVD Manager ein Android Virtual Device erstellen und aus dem gleichen Dialogfenster auch starten. Für den Test auf einem echten Smartphone müssen Sie auf dem Smartphone unbedingt unter Einstellungen |Anwendungen | Entwicklung | USB-Debugging einen Haken setzen, damit es zwecks Test der App per USB an den PC angeschlossen werden kann. Der eigentliche Starten der App wird mittels Run | Run As | Android Application aus Eclipse heraus veranlasst. Im Dialog Android Device Chooser können Sie sehen, welche gestarteten Emulationsumgebungen und/oder per USB angeschlossenen Geräte zum Testen zur Verfügung stehen und sich das jeweils passende (virtuelle) Gerät aussuchen. Das Beenden einer laufenden App erfolgt auf dem Emulator oder dem Smartphone/Tablet in der Regel durch (teilweise mehrfaches) Betätigen der entsprechenden [Zurück]-Taste.

Fazit und Ausblick

Wie Sie sehen, ist es mit relativ wenig Aufwand möglich, eine eigene App für Android-Smartphones zu schreiben. Eine gute Programm-Idee vorausgesetzt steht nach ausgiebigen Tests Ihrer Eigenentwicklungen einer Vermarktung bei Google Play nun nicht mehr viel entgegen. Sie müssen Ihre App nur noch als Signed Application Package mittels der Android Tools exportieren und verteilen. In der kommenden Ausgabe von Android User erfahren Sie, wie Sie für den Endanwender veränderbare Einstellungen (zum Beispiel den Servernamen) integrieren und mittels der GPS und der Google Geocoding API die Position und falls verfügbar auch die Adresse ermitteln.