Aufgrund der Tatsache, dass sich Android in meinem Bekanntenkreis immer weiter verbreitet und ich mich ebenfalls für dieses System interessiere, wollte ich einmal eine Android App programmieren. Dabei habe ich nicht etwa irgendetwas Stumpfsinniges zusammen programmiert, sondern wollte eine Android App programmieren, die mir persönlich täglich fehlt: Eine Auswertung der Provisionen vom Amazon PartnerNet. Es ist ja kein Geheimnis, dass man bei Amazon mit Links und Empfehlungen Geld verdienen kann. Bedauerlicherweise wollte hierfür vor mir scheinbar noch keiner eine Android App programmieren.

Wobei meine größte Motivation mit Sicherheit nicht finanzieller Natur ist, sondern ich gerne Menschen Informationen vermittle. Nun wollte ich eben eine Android App programmieren, mit welcher man sehen kann, wieviele Bestellungen man erzeugt hat und wieviel Provision dadurch entstanden ist. Ich finde, dass das auch eine interessante Idee ist, mit der man mal schnell eine Android App programmieren kann. Bevor ich aber zu sehr ins Detail einsteige, was ich defintiv weiter unten noch tun werde, möchte ich einmal ganz von Vorne anfangen.

Was man für das Programmieren einer Android App braucht

Fangen wir zunächst einmal ganz Vorne an und sprechen wir darüber, was man benötgt, um eine Android App programmieren zu können. Idealerweise bekommen wir für Android alles komplett kostenfrei. Ich habe sogar mit OpenSUSE 11.4, einer Linux Distribution, ein OpenSource Betriebssystem verwendet. Natürlich kann man auch gerne unter Windows oder Mac OSX seine Android App programmieren. Im Gegensatz zum iPhone darf hier jeder das Betriebssystem seiner Wahl verwenden. Folgende Dinge benötigen wir und ich möchte noch dazu erwähnen, dass es sich hierbei um meine Präferenzen handelt. Natürlich gibt es hier auch Alternativen - wie z.B. NetBeans als IDE anstelle von Eclipse. Das bleibt jedem selbst überlassen. Blutigen Anfängern empfehle ich aber Schritt für Schritt hier mitzugehen, da ich mich sehr an die Standardvorgaben von Google für Android Entwicklung gehalten habe.

• Einen Computer mit Linux, Mac OSX oder Windows
• Die kostenfreie Eclipse IDE for Java EE Developers
• Den essentiellen und ebenfalls kostenfreien Android SDK
• Das ADT Plugin for Eclipse für den Android SDK unter Eclipse

So grundlegende Dinge wie Internetzugang oder ein Android Gerät, auf dem man das dann mal wirklich testen kann, nehme ich jetzt nicht mit auf. Beim Android App Programmieren braucht man auch kein extremes Supergerät, es reichen auch einfache und günstige Android-Geräte als Testgeräte aus.

Um so schnell wie möglich loslegen zu können, beginnt man zunächst der Installation von Eclipse, was eigentlich nur das Entpacken ist und ggfls. die Installation der aktuellen Java Laufzeitumgebung (JRE). Anschließend installiert man noch den Android SDK, was bei mir etwas länger gedauert hat. Ich empfehle hier auf jeden Fall API 14 (Android 4), API 10 (Android 2.3.3) und API 8 (Android 2.2) zu installieren. Wer auf noch älteren Versionen eine Android App programmieren möchte, kann auch diese verwenden. Ich habe zunächst immer 2.2 verwendet, da dies z.Zt. die gängigste Version ist und diese dann auch mit neueren Versionen kompatibel ist.

Nachdem wir den SDK installiert haben, starten wir Eclipse und wählen dort den Menüpunkt "Help" und dann "Install New Software" aus. Rechts oben klickt man dann auf Add und fügt die URL hinzu: https://dl-ssl.google.com/android/eclipse/. Danach wählt man die Software und klickt entsprechend immer weiter auf Next. Wer dazu eine sehr detaillierte Anleitung braucht, findet diese in der Android Developer Dokumentation unter "ADT Plugin for Eclipse".

Die erste Android App programmieren

Wer schon einmal mit der Programmierung von Irgendetwas angefangen hat, weiß dass alle Anleitungen mit einer sog. "Hello World" Anwendung anfangen. Also einem Programm, welchem erst einmal nur ein "Hallo Welt" ausgibt, damit man das erst einmal beschnuppern kann. Wenn man jetzt mit Eclipse unter "File", "New Project" und dann "Android Project" auswählt, dann erstellt Eclipse eine Anwendung, die schon "Hallo Welt" ausgibt. Die kann man mittels SDK und Emulator auch direkt starten. Hierzu öffnet man zunächst über das Geräte-Icon in der Menüleiste den "Android Virtual Device Manager" (kurz VDM). Mit "New" kann man entsprechend ein neues Gerät anlegen, welches sich mit "Start" auch direkt im Emulator starten lässt.

Damit man nun diese kleine Miniatur App auch starten kann, muss man zunächst eine Laufzeitkonfiguration anlegen. Dazu geht man unter Eclipse zu "Run" und dann "Run Configurations". Dort legt man mit Rechtsklick auf "Android Application" mit "New" eine neue Konfiguration an, wählt das Projekt aus und als "Target" das mit dem VDM erstellte Gerät. Sollte dies dort noch nicht auftauchen, hilft ein kurzer Neustart von Eclipse. Ich musste nach der SDK Installation auch erstmal das System neustarten. Danach kann man über "Run" die App entsprechend auf dem Emulator-Gerät starten.

Ich empfehle im Übrigen immer zuerst den Emulator über den Virtual Device Manager mit "Launch" zu starten und anschließend die App mit "Run" auszuführen. Bei mir hat Eclipse immer die Verbindung zum Emulator verloren, wenn ich diesen über "Run" gemeinsam mit der App gebootet habe.

Der Emulator bringt alle Features mit, die auch ein Android Gerät mitbringt. So hat dieser auch den Browser, Maps, Mail und alle Einstellungen an Bord. Wer also neben Apps z.B. auch mobile Websites programmieren möchte, der kann den Emulator natürlich auch für das Testen eben solcher Websites benutzen.

Bei der App Entwicklung unterstützt er auch Debugging, was aber in der Ausführungszeit bedeutend langsamer ist als normales Ausführen und ich hatte ab und an schonmal ein paar Aussetzer mit dem Ding.

Eintauchen in die Android App Programmierung

Wollen wir nach der kurzen Aufwärmrunde also nun etwas konkreter werden. Bevor wir jetzt jedoch vollständig im Code versinken, möchte ich die Gelegenheit nutzen und Einsteigern in die Programmierung noch das Buch "Java ist auch eine Insel" ans Herz legen. Es steht bei Galileo Open auch kostenfrei online zur Verfügung: http://openbook.galileocomputing.de/javainsel/. Für eine gute Programmierung ist es unerlässlig, dass man genau weiß, was man wann und wo tut.

Grundsolide Java-Kenntnisse sind ein absolutes Muss, wenn man mit der Android App Programmierung anfängt. Wer bereits Vorkenntnisse in C# oder C++ hat, dem brauche ich hier wohl nicht mehr viel erzählen.

Eine Spezifikation zur Programmierung der Android App

Das Schreiben einer Spezifikation klingt immer so nach fieser Bürokratie. Es ist aber enorm wichtig, dass man einen Plan hat, wie man zu seinem Endergebnis kommt. Man sollte sich daher entweder den Ablauf skizzieren oder entsprechend die Funktionen beschreiben. Für eine kleine nette App muss man jetzt auch nicht direkt zu UML für die Modellierung greifen. Es reicht für den Anfang ein Stück Papier - wir wollen es ja nicht übertreiben.

Die ersten Zeilen der Android App

Wenn man nach der obigen Beschreibung ein neues Android Projekt erstellt hat, dann trifft man zunächst auf eine Klasse, die von einer Basis-Klasse namens "Activity" abgeleitet ist. Für eine "Hello World" Beispielanwendung erstellt Eclipse als Android Projekt standardmäßig etwas wie den folgenden Code.

public class HelloWorld extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Dieser einfache Code erklärt sich fast von selbst. Zum einen wird der Basiskonstruktor aufgerufen und zum anderen mit "setContentView" mitgeteilt, dass das View Layout mit dem Namen "main" verwendet werden soll. Android bringt hier auch direkt einen hervorragenden GUI Designer mit. Unter "/src/res/layout/main.xml" findet man die Datei. Mit einem Doppelklick darauf sollte der folgende GUI Designer hervor kommen. Sollte dem nicht der Fall sein, dann einfach mit Rechtsklick "Open With" und dann "Android Layout Editor" auswählen. Ich hatte ein paar Mal Probleme, dass Eclipse das nur als XML Datei mit dem Standardeditor geöffnet hat.

Man sieht auf dem Bild schon die fertige App, da ich diese natürlich bereits im Vorhinein fertig entwickelt habe. Es empfiehlt sich je nach Anwendung auf jeden Fall einmal genauer das Konstrukt der Layouts durchzulesen, welches jedoch in gewisser Weise an die Java Welt angelehnt ist und auch ähnlich Gtk funktioniert. Wer also schon einmal GUIs in Java oder mit Gtk entwickelt hat, wird hiermit keine Probleme haben. Ich habe mich für meine App für ein LinearLayout und darunter ein TableLayout für die Daten entschieden.

Einen Login Dialog in der Android App anzeigen

Da meine App sich ja mit meinen Benutzerdaten bei Amazon anmelden muss, muss sie entsprechend beim Start vom Benutzer den Benutzernamen und das Passwort erfragen. Dazu habe ich mir überlegt, dass ich einen Dialog anzeige, welcher nach Benutzername und Passwort fragt und nicht wie häufig üblich eine völlig neue View im Vollbildmodus anzeige. Modale Dialoge haben den Vorteil, dass der Anwender im Hintergrund bereits erkennen kann, was Ihn erwartet.

        
        final View loginDialogView = factory.inflate(R.layout.logindialog, null);
        final EditText usernameInput = (EditText) 
                            loginDialogView.findViewById(R.id.UsernameEditText);
        final EditText passwordInput = (EditText) 
                            loginDialogView.findViewById(R.id.PasswordEditText);
        final CheckBox StoreCredentialsLocallyCheckBox 
                            = (CheckBox)loginDialogView.findViewById
                                   (R.id.StoreCredentialsLocallyCheckBox);
         AlertDialog loginDialog = new AlertDialog.Builder(AmazonPartnerNetActivity.this)
            .setTitle("Amazon PartnerNet Login")
            .setView(loginDialogView)
            .setPositiveButton("Login", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                        // onclick code for further execution
                    }
                })
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                    	AmazonPartnerNetActivity.this.finish();
                    }
                })
            .create();
         loginDialog.show();

Der Code referenziert zunächst unter Verwendung des statischen Objektes R, welches für die Ressources zuständig ist, zum einen die Layout XML Beschreibung (R.layout.logindialog) und anschließend die Steuerelemente, die sich auf dem Dialog befinden und ebenfalls in der XML Datei beschrieben sind. Als Nächstes wird mit einem AlertDialog.Builder Objekt ein Android Dialog zusammengebaut und festgelegt, dass die darin enthaltene Ansicht (engl. View) entsprechend durch die logindialog.xml definiert ist, welche ich mit dem UI Designer erstellt habe. Danach lege ich die Handler für einen Positiv-Button und einen Negativ-Button fest. Ich hätte genauso gut die Buttons in der Android Layout XML Datei einfügen können, aber die Buttons in Dialogen sehen besser aus und haben auch einen gräulichen Hintergrund.

Solche Buttons sind für den Anwender gewohnter und werden in zukünftigen Android Versionen sich besser an neue Layouts anpassen. Beim Negativ-Button terminiert sich unsere Android Activity - also das Programm wird umgehend beendet und beim Positiv-Button habe ich den Code entfernt, weil der Block so groß war. Dort geht es einfach mit der Applikation weiter. Zum Schluss dann noch der Aufruf der Show-Methode und der Dialog erscheint in voller Pracht.

Standard-Dialoge in der Android App anzeigen

Mit dem Login Dialog hat man auch schon so gut wie die ganze Komplexität der Android Dialogmöglichkeiten abgefrühstückt. Die Anroid Dokumentation zu Dialogen führt den Login Dialog als Letztes und kompliziertestes auf, da es sich hierbei um einen individuellen Dialog handelt (Custom Dialog). Im nächsten Abschnitt zum Thema Multi-Tasking verwende ich z.B. noch einen sog. ProgressDialog, also einen Fortschrittsdialog. Dieser lässt sich mit einer Zeile Code sehr einfach erzeugen.

ProgressDialog progressDialog = ProgressDialog.show(AmazonPartnerNetActivity.this, 
                  "Amazon PartnerNet", "Logging in & fetching data", true);

Der Klassiker unter den Dialogen ist natürlich die unter JavaScript bekannte AlertBox und bei .NET als MessageBox bezeichnete Box, die einen einfachen Meldedialog mit Text und Ein, Zwei oder Drei Buttons darstellt. Einen solchen Dialog kann man auch unter Android relativ schnell und einfach erstellen.

    final AmazonPartnerNetActivity tActivity = this;
    // display an error message
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setMessage("Error fetching data: Server did not return expected data")
           .setCancelable(false)
           .setTitle("Data retrieval failed")
           .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
                 public void onClick(DialogInterface dialog, int id) {
                        // cancel the thread first so that
                        // the user can retry logging in
                        tActivity.client.cancel(true);
                        // show the login dialog once more
                        tActivity.showLoginDialog();
                 }
            });
     AlertDialog alert = builder.create();
     alert.show(); 

Bei diesem Beispiel erscheint ein Android Standarddialog mit einem OK Button, einer Überschrift und einem Fehlertext, dass die Daten nicht verarbeitet werden konnten. Man sollte sich nur mit Dialogen zurück halten, denn zu viele Dialoge hintereinander nerven den Benutzer auch. Das ist bei Entwicklern ein häufiger Fehler. Man sollte sich bei einer guten Mischung aus Dialogen und direkten Fehlern auf Eingabemasken halten.

Multi-Threading Android App Programmierung

Mittlerweile wird auch bei Android Geräten dazu übergegangen Dual Core Prozessoren einzusetzen. Das hat für  Entwickler und für den Anwender großartige Vorteile, da man nicht nur mehr Rechenleistung hat, sondern auch sehr gut parallelisieren kann. Als Entwickler ist man aber gefordert, hier auch dafür zu sorgen, dass das Betriebsystem - also Android selbst - die Last möglichst gut auf beide Prozessorkerne verteilen kann. Werfen wir dazu zunächst einmal einen Blick auf den Aufbau des ARM Cortex-A9 MPCore Multi Core Prozessors. Die Cortex A9 Architektur befindet sich u.A. in den OMAP4 Prozessoren von Texas Instruments, welche z.B. im Motorola Droid Razr oder im Samsung Galaxy Nexus verbaut sind.

Auf dem Diagramm sieht man die einzelnen Prozessorkerne. Der TI OMAP4 kommt in der Regel mit zwei Kernen (Dual Core) und jeder Kern besitzt neben der Fließkommaeinheit (FPU kurz für Floating Point Unit) auch den Speicher für Anweisungen (Instruction Cache) und Daten (Data Cache). Die Snoop Control Unit (kurz SCU) verteilt die eingehenden Anweisungen auf die einzelnen Prozessoren. Verwendet man z.B. zwei Programme gleichzeitig (sog. Multi-Tasking), dann kann das erste Programm den ersten Kern verwenden und das zweite entsprechend den Zweiten. Bei acht Programmen könnten sich jeweils vier Programme einen Prozessor durch abwechselnde Nutzung teilen. Es ist so gut wie unmöglich ein einzelnes Programm mit einem einzigen Thread sinnvoll so auf mehrere Prozessoren aufzuteilen, dass der Nutzer dadurch einen Geschwindigkeitsvorteil bekommt.

Damit man den Effekt von Multitasking auch innerhalb eines einzelnen Tasks bzw. einer einzelnen Anwendung verwenden kann, gibt es sog. Threading. Jedes Programm besitzt grundsätzlich in erst einmal einen Thread und kann bei Bedarf weitere erstellen. Ein Thread ist nicht anderes als eine Kette von Prozessoranweisungen. Unser Java Quelltext wird z.B. während der Laufzeit durch die JVM (Java Virtual Machine) in Prozessoranweisungen umgesetzt.

Werden wir einmal konkret: Meine App braucht bei guter Netzabdeckung 10 bis 20 Sekunden dafür, die Daten von Amazon zu laden. Währenddessen würde bei einem einzigen Thread die komplette Ausführung der Anwendung durch das Herunterladen blockiert. Die Benutzeroberfläche würde nicht mehr auf Eingaben reagieren und "einfrieren". Damit ich nun z.B. einen Fortschrittsbalken anzeigen kann, muss ich dieses "Einfrieren" verhindern. Das geht dadurch, dass das Herunterladen in einem anderen Thread läuft als die grafische Oberfläche mit dem "Hauptprogramm". Software-seitig ist das auch gleich bedeutend einfacher als es sich in der Hardware-Ebene anhört.

Android bringt direkt eine Klasse für das Multi-Threading mit dem Namen AsyncTask mit. Herimit hat man bereits alle notwenidgen Grundlagen, um sofort und einfach mit dem Multi-Threading zu beginnen und dem Betriebssystem, der JVM und der SCU alle notwendigen Grundlagen zu geben, um beide Prozessorkerne mit maximaler Effizienz zu betreiben.

public class amznclient extends AsyncTask {

    /* ... Code removed to reduce the size of this sample ... */

  	@Override
	protected String doInBackground(String... params) {
		String result;
		try {
			result = this.fetch();
		} catch (Exception e) {
			Log.e("AppName", e.getMessage());
			result = null;
		}

		return result;
	}
	
	@Override
	protected void onPostExecute(String result) {
                // notify the parent thread that we're finished here
		this.parentActivity.updateDataReady(result);
	}
}

Im Beispielcode sehen wir jetzt eine Klasse, die von AsyncTask abgeleitet ist und die Methoden onPostExecute sowie doInBackground implementiert. Letztere wird dann ausgeführt, wenn Jemand die "execute()" Methode aufruft, die durch AsyncTask vererbt wurde. Sobald der Thread dann durch ist, führt AsyncTask die Methode onPostExecute aus, mit welcher man dann dem ursprünglichen Thread die Information übergeben kann, dass der erstellte Thread nun fertig ist. Konkret: Die Oberfläche startet den Thread "amznclient", welcher den Login durchführt und die Berichtsdaten abfragt, während die grafische Oberfläche während der gesamten Thread-Laufzeit einen ProgressDialog anzeigt.

Daten von einem Webserver mit der Android App abrufen

Sei es meine App, Facebook, Google Mail, ein Shop, ein Preisvergleich oder eine Fluggesellschaft - das Prozedre der meistens Apps ist gleich: Sie fragen Daten auf einem entfernten Server an und bereiten diese grafisch in der App auf. Bei Facebook kann man gleich noch seine eigenen Daten an den Server übertragen. Wer solch eine App entwickelt, wird häufig dazu passend auch auf einem Webserver eine Anwendung entwickeln, die eine entsprechende XML, JSON oder SOAP Schnittstelle bereitstellt. Da ich in meiner App die Daten von Amazon als XML bekomme, habe ich den Apache HttpClient benutzt, den man definitiv der HttpURLConnection vorziehen sollte.

HttpGet getMethod = new HttpGet(url);
getMethod.setHeader("User-Agent", userAgent);
this.localContext.setAttribute(ClientContext.COOKIE_STORE, this.cookieStore);
this.httpClient.setCookieStore(this.cookieStore);
response = this.httpClient.execute(getMethod,this.localContext);
locationHeader = getMethod.getFirstHeader("Location");
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode == 200) {
   data = responseHandler.handleResponse(response);
}

Mit diesem Teil habe ich definitiv die meiste Zeit verbracht. Grund hierfür war, dass nirgendwo dokumentiert ist, dass der HttpClient den HttpContext und den CookieStore neu zugewiesen bekommen muss, wenn man eine neue Methode erstellt. Das und die Tatsache, dass ich Anfangs die unbrauchbare HttpUrlConnection verwendet habe, hat den allergrößten Batzen geschluckt. Die vollständige Klasse mit HTTP POST Methode findet man in der Versionkontrolle als amznclient.java. Da Amazon für den Login keine API anbietet, ist die Klasse auch direkt ein Screen Scraper.

Damit die App auch noch die Berechtigung bekommt auf das Internet zuzugreifen, muss man in der AndroidManifest.xml Datei noch einen android.permission.INTERNET Knoten hinzufügen. Wie das genau aussieht kann man in der AndroidManifest.xml Datei von meiner App sehen.

Wer sich richtigen Ärger ersparen möchte, der sollte ohne Umwege direkt zum HttpClient von Apache gehen, der bei Android übrigens standardmäßig mit an Bord ist, weil die HttpURLConnection einfach so viele Schwachstellen hat - z.B. folgt sie nicht immer Redirects, was der HttpClient aber sehr wohl tut. Zudem hat HttpURLConnection garkein Cookie Handling. Mir ist auch aufgefallen, dass die URLConnection im Vergleich zum HttpClient bedeutend langsamer ist.

Verarbeitung von XML Daten in Android Apps mit dem DOM

Wie eingangs bereits erwähnt lädt meine Beispiel-App die Daten von Amazon im XML Format herunter, was nun natürlich bedeutet, dass eben jene Daten auch mit einem Parser ausgewertet werden müssen. Dazu kann man ganz einfach und Schnell den Android DOM Parser nehmen. Ich benutze ihn auch auf anderen Plattformen sehr gerne und fand die Umsetzung auch kinderleicht.

DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(new ByteArrayInputStream(XmlData.getBytes()));
TextView ShipmentTotalUnitsTextView = (TextView)this.findViewById
                                 (R.id.ShipmentTotalUnitsTextView);
			
NodeList shipmentTotalXml = doc.getElementsByTagName("ShipmentTotals");
NodeList shipmentTotalList = shipmentTotalXml.item(0).getChildNodes();
for(int n=0; n shipmentTotalList.getLength(); n++){
	if(shipmentTotalList.item(n).getNodeName().equals("Units")){
		String shippedUnitsValue = shipmentTotalList.item(n)
		            .getChildNodes().item(0).getNodeValue();
		ShipmentTotalUnitsTextView.setText(shippedUnitsValue);
	}
}

Der kurze und knappe Code zeigt einfach einmal, wie man einzelne Knoten aus einem XML String ausliest. Die dazugehörige XML Datei hat im Prinzip einfach drei Ebenen. Einen Root-Knoten, dann einen ShopmentTotals Knoten und zum Schluss einne Units-Knoten, der dann als Wert entsprechend die versendeten Einheiten hat. Schlussendlich wird der Wert dann in ein TextView geschrieben. Mehr gibt es zu XML unter Android auch nicht mehr zu sagen.

Einstellungen und Benutzerdaten für die Android App speichern

Für das Speichern von Benutzereinstellungen, persönlichen Daten und anderen Dingen bietet Android direkt eine Klasse namens "SharedPreferences", welche auf Schlüsselbasis Daten für eine Anwendung speichern kann. Das ganze ist so einfach, dass man mit folgendem Zweizeiler schon Daten gespeichert hat.

// MODE_PRIVATE defines that
// no other app can access the data
SharedPreferences settings = this.getSharedPreferences
                       ("MyAppNamePrefs", MODE_PRIVATE);
// save data in the shared preferences
SharedPreferences.Editor editor = settings.edit();
editor.putString("Username", "Hans Wurst");
editor.putBoolean("IsMaleUser", true);
editor.commit();
// remove the setting again
editor.remove("Username");
editor.commit();

Dazu kann man dann auch nicht mehr allzu viel sagen außer: Speichern, Auslesen, Bearbeiten, Löschen, Fertig. Mehr gibt es damit auch nicht zu tun. Ich finde das super positiv, da man nicht mehr aufwendig Konfiugrationsdateien speichern muss, wie unter Windows. Ansonsten gibt es wohl noch SQLite Treiber für Leute, die keine Luste auf sowas haben oder eine Datenbank brauchen.

Android App auf einem Gerät installieren

Wenn man jetzt schon die App programmiert hat, dann möchte man natürlich auch einmal sehen, wie diese auf einem Android Gerät funktioniert. Vielleicht will man sie auch garnicht in den Android Market stellen, weil man sie nur für sich und ein paar Freunde programmiert hat. Ich habe mich selbst noch garnicht mit dem Market ausseinander gesetzt, werde es aber bestimmt noch tun.

Mit jedem Build-Vorgang hat uns Eclipse bereits im Ordner "bin" eine sog. APK-Datei erstellt, welche wir direkt auf Android Geräten installieren können. Um die App ohne Market zu installieren, installiert man auf dem Gerät zunächst die App APKatcher und sendet sich die APK Datei per E-Mail an das Google-Konto, welches auf dem Gerät konfiguriert ist. Ist die E-Mail auf dem Gerät angekommen, wählt man die APK Datei aus dem Anhang aus und öffnet diese dann mit dem APKatcher.

Anschließend ist die App auf dem Gerät installiert und kann dort auch verwendet werden. Man sollte nur vorher sicherstellen, dass das Gerät auch mind. die Android Version hat, für die man entwickelt hat.

Fazit zur Android App Programmierung

Es hat den Anschein, dass mit dem Aufkommen der Smartphone-Welle immer mehr Menschen Interesse an der Programmierung finden - mit Teils skurrilen Endergebnissen. So teilen viele erfahrene Entwickler mit mir die Meinung, dass die Anzahl der Copy&Paste-Entwickler deutlich gestiegen ist. Des Weiteren erfreut sich aufgrund des iPhones eine längst ausgestorbene Programmiersprachenfamilien an neuem Interesse: SmallTalk in Gestalt von Objective C auf einem System mit wahlweise verwaltetem oder nicht-verwaltetem Speicher. Android dagegen setzt auf Massentauglichkeit und hat mit Java als Programmiersprache nichts anbrennen lassen. Der SDK kann sich absolut sehen lassen und bei der Entwicklung muss man auf nichts verzichten.

Es gilt aber immer noch die goldene Regel: Wer eine gute Anwendung entwickeln möchte, muss auch ein guter Anwendungsentwickler sein. Themen wie Mutli-Threading, Codequalität, Software-Security, Netzwerkprotokolle etc. gehören nach wie vor zum täglichen Aufgabengebiet. Natürlich sollen so viele Menschen wie möglich Apps programmieren, aber man darf nicht vergessen, dass man dafür auch eine gehörige Portion Know-How braucht. Der Unterscheid zur Entwicklung von Anwendungen auf dem Palm III ist nur insofern gegeben, dass es für Android bedeutend einfacher ist, leistungsfähigere Geräte zur Verfügung stehen und sich mehr Menschen dafür interessieren. Grundlegend hat sich in der Entwicklung für mobile Geräte gar nicht so viel geändert.

Bücher zum Thema „Android Programmierung“