Mal sehen, wie das so geht

Android-Entwicklung für Windows-Entwickler – eine Einführung
Keine Kommentare

Im mobilen Bereich kann man Android nicht ignorieren. Viele Entwickler sind in der Windows-Welt zu Hause und fragen sich, wie leicht oder schwer der Einstieg in die Entwicklung von Apps für Android-Geräte ist. Eine Einführung für Windows-Entwickler.

Keine Frage, es gibt bereits einige gute Bücher, welche den schnellen und unkomplizierten Einstieg in die Programmentwicklung von Apps für Android versprechen. Ob ein Tutorial gut oder weniger gut gelungen ist, ist u. a. auch stark von der jeweiligen Perspektive der Betrachtung abhängig. Idealerweise findet man ein Dokument, welches den Lerninteressierten genau an jener Stelle abholt, wo sich dieser befindet.

Vor einigen Jahren spielte die Entwicklung von Apps für mobile Endgeräte noch keine große Rolle. Klassische Anwendersoftware wurde primär für den Desktop entwickelt. Eine eindeutige Dominanz haben hier die verschiedenen Versionen der Windows-Betriebssysteme von Microsoft. In diesem „Ökosystem“ ist eine Vielzahl von Programmierern seit vielen Jahren zu Hause: Sie kennen das System vom Aufbau, die Art und Weise der Anwendungsentwicklung, die eingesetzten Frameworks und Bibliotheken (zum Beispiel .NET) und die etablierten Programmiersprachen (zum Beispiel C#, C++ und Java). Will man jetzt Apps für mobile Endgeräte entwickeln, kann man natürlich auch Windows Phone in den Versionen 7 und 8 wählen. Die Benutzeroberflächen können dann mit XAML (Silverlight) erstellt werden, das .NET Framework ist in einer „abgespeckten“ Version verfügbar. Im mobilen Bereich ist jedoch eine andere Vorbereitung der Betriebssysteme zu verzeichnen. Windows Phone rangiert gemäß aktuellen Statistiken nach Android und iOS. Stellt man Applikationen zur Nutzung auf Smartphones und/oder Tablets zur Verfügung, so ist man aus heutiger Sicht quasi gezwungen, auch das Android-System zu unterstützen. Der Entwickler ist also angehalten, sich im Detail mit der Programmentwicklung des – auf einen Linux-Kern basierenden – Android-Systems auseinanderzusetzen. Die entscheidende Frage wird dabei lauten: Wie viel Wissen aus meiner bisherigen Systemumgebung kann ich nutzen und erfolgreich einbringen?

Diese zweiteilige Artikelserie gibt eine kompakte Einführung in die Entwicklung von Apps für Android und nimmt dabei die Perspektive des etablierten Windows-Entwicklers ein. Somit werden zwei Punkte insbesondere betrachtet:

    1. Welche Gemeinsamkeiten gibt es zwischen beiden Systemen, d. h. wie kann man das bekannte Wissen in die neue Systemumgebung transferieren und dort nutzen?
    2. Besonders muss man auf die Unterschiede hinweisen. Gelegentlich erwartet man als „eingefuchster“ Windows-Entwickler etwas ganz anderes, bzw. man würde die Lösung eines Problems vollständig abweichend angehen. In diesem Fall ist Vorwissen sogar schädlich, da es einen aktiven Prozess des Umlernens erfordert.

Android für Windows-Entwickler – Ein Einstieg in drei Teilen

In dieser Artikelserie präsentieren wir einen kompakten Einstieg in die Entwicklung von Apps für mobile Endgeräte mit Android-System.

Allgemeines

Android ist ein Betriebssystem (basierend auf dem Linux-Kernel 2.6) und eine Plattform gleichzeitig. Dazu gehören eine Reihe von Standardanwendungen (beispielsweise Kontaktdatenbank, Uhr, Browser, …). Der Bezug der Anwendungen wird im Regelfall über Google Play erledigt. Bestandteil von Android ist ebenfalls die virtuelle Maschine Dalvik (entwickelt von Dan Bornstein, benannt nach einem kleinen Fischerort auf Island). Die Anwendungen (Apps) werden nicht direkt durch den Prozessor des mobilen Endgeräts ausgeführt, sondern in Instanzen dieser virtuellen Maschine. Dieses Vorgehen führt zu einer erhöhten Sicherheit und insgesamt besseren Stabilität der Plattform. Dalvik wurde im Hinblick auf einen minimalen Speicherverbrauch optimiert. Die virtuelle Maschine und die so gennannten Core Libraries bilden zusammen die Android Runtime. Zu den Core Libraries gehören u. a. die aus Java bekannten Pakete wie java. Lang, java.io, java.math etc. Eine Schicht über den Libraries und der Android Runtime ist das Application Framework angeordnet. Dieses ermöglicht das Erstellen benutzerfreundlicher Apps mit geringem Aufwand. Bestandteile des Application Frameworks sind:

  • Views: Umfasst Standardbedienelemente wie Textfelder, Schaltflächen etc.
  • Content Provider: Regelt den Zugriff auf die Daten anderer Programme.
  • Ressource Manager: Stellt Zeichenketten, Grafiken und Layoutdaten bereit.
  • Notification Manager: Gewährleistung des Zugriffs auf die Statuszeile.
  • Activity Manager: Darüber wird der Lebenszyklus einer App abgewickelt.

Der Lebenszyklus einer App im Android-System unterscheidet sich von demjenigen einer Desktopanwendung. Man kann diesen wie in Abbildung 1 darstellen. Abbildung 2 zeigt dagegen den Aufbau der gesamten Android-Plattform.

Abb. 1: Lebenszyklus einer Android-App

Abb. 1: Lebenszyklus einer Android-App

Abb. 2: Aufbau der Android-Plattform

Abb. 2: Aufbau der Android-Plattform

Systemumgebung einrichten

Der erste und wichtigste Schritt ist es, die Systemumgebung einzurichten. Dazu müssen die Voraussetzungen geschaffen werden, um Apps zu programmieren, zu testen und auf ein mobiles Zielgerät zu installieren. Hierzu sind einige Schritte notwendig, welche wir im Folgenden exemplarisch für die Implementierung einer ersten Testanwendung für ein Android-Tablet beschreiben. Gemäß unserem Ansatz gehen wir davon aus, dass die Entwicklung auf einem Rechner mit Microsoft-Windows-7- oder -8-Betriebssystem durchgeführt wird. Die Schritte umfassen im Einzelnen:

  1. Update des Betriebssystems und Sammeln von Informationen: Jetzt ist die beste Möglichkeit, den Entwicklungsrechner seitens des Betriebssystems auf den neuesten Stand zu bringen. Dazu sollte die Windows-Update-Funktion aufgerufen und alle wichtigen Updates installiert werden. Auch ein Blick in die optional angebotenen Updates ist sinnvoll. Gleichwohl sollte man die korrekte Version des Betriebssystems in Erfahrung bringen, also zum Beispiel Windows 7, 64 Bit. Und das aus einem guten Grund: Gelegentlich werden von Herstellern der mobilen Endgeräte die notwendigen Treiber systemspezifisch angeboten. Auch andere Software muss zur Betriebssystemversion passen.
  2. Vollständige Installation von Java: Die Entwicklung von Apps für Android basiert auf der Programmiersprache Java. Hierzu benötigen wir nicht nur die aktuelle Laufzeitumgebung (Runtime), sondern auch das Java Development Kit (JDK) in der aktuellen Version. Dieses kann hier heruntergeladen werden. Die Installation erfolgt in bewährter Weise über ein Setup-Programm. Ergänzende Einstellungen sind nicht notwendig.
  3. Systempfade prüfen und aktualisieren: Die Eintragungen im Systempfad dienen dazu, dass man die gelegentlich benötigen Hilfsprogramme (meist zu starten über die Konsole) systemweit erleichtert aufrufen kann. Dazu geht man über die Systemsteuerung zu „System und Sicherheit“ und ruft dort das Dialogfeld „Erweiterte Systemeinstellungen“ (Abb. 3) auf. Mit der Schaltfläche „Umgebungsvariablen“ gelangt man zum Dialogfeld. Dort ist die „Systemvariable“ um den Eintrag des bin-Verzeichnisses der aktuellen JDK-Installation zu ergänzen (Hinweis: Die Einträge werden durch Semikolon getrennt; man fügt dann beispielsweise den Eintrag C:\Program Files (x86)\Java\jre7\bin hinzu, wie in Abbildung 4 gezeigt). Über die Kommandozeile kann man sehr schnell in Erfahrung bringen, ob die Installation von Java und das Update der Umgebungsvariablen geklappt haben. Dazu gibt man in einem Konsolenfenster (Start | Ausführen | cmd) den Befehl javac -version ein. Das Ergebnis ist die Anzeige der installierten Version von Java. Wie gesagt, dieses sollte aus jedem Verzeichnis über die Konsole funktionieren. Ebenfalls muss das Java-Home-Verzeichnis bekannt gemacht sein. Dieses wird ebenfalls im Dialogfeld der „Umgebungsvariablen“ (oberer Bereich) angelegt. Dazu wird eine Variable JAVA_Home definiert, welche auf das Java-Wurzelverzeichnis verweist.
Abb. 3: Dialogfeld „Erweiterte Systemeinstellungen“ unter Windows

Abb. 3: Dialogfeld „Erweiterte Systemeinstellungen“ unter Windows

Abb. 4: Ergänzen der Pfadangaben zum „Java/bin“-Verzeichnis in die Umgebungsvariable

Abb. 4: Ergänzen der Pfadangaben zum „Java/bin“-Verzeichnis in die Umgebungsvariable

  1. Anbindung der Hardware: Um Apps erfolgreich zu entwickeln, ist es zwingend erforderlich, diese auf realer Hardware zu testen. Das Entwicklungs-Kit von Android (Android-SDK) bringt zwar auch einen Emulator mit, dieser ist jedoch relativ langsam und kann einen Test auf echter Hardware niemals ersetzen. Nun ist die mögliche Hardware mit Android-Systemen mehr als heterogen – dazu gehören Smartphones und Tablets der unterschiedlichsten Kategorien. Die Hinweise haben daher eher beispielhaften Charakter. Das mobile Gerät wird im Regelfall per USB mit dem Entwicklungsrechner gekoppelt. Um Apps darauf zu installieren, ist ein spezieller Treiber (USB-ADB-Treiber) erforderlich. Diesen bekommt meist auf den Supportseiten des Herstellers. Im Regelfall wird das Endgerät automatisch als Wechseldatenträger erkannt. Dieses genügt jedoch nicht für ein Installieren von Apps, dazu ist der erwähnte Spezialtreiber zuständig. Dieser kann über den Gerätemanager installiert werden. Der Autor hat dieses für ein Tablet der Marke Medion (P9516) getan. Nach erfolgreicher Installation wird das Tablet als „Android Phone | Android Composite ADB Interface“ ausgewiesen (Abb. 5). Nach der Treiberinstallation steht ein Neubooten des Systems an. Hinweise zur Installation unter Windows 8 können dem Textkasten „Installationshinweise des Android-Debug-Bridge-(ADB-)Treibers unter Windows 8“ entnommen werden.
Abb. 5: Erfolgreiche Installation des Gerätetreibers für das mobile Endgerät

Abb. 5: Erfolgreiche Installation des Gerätetreibers für das mobile Endgerät

  1. Software zur Programmentwicklung: Als Entwicklungsumgebung wird Eclipse gewählt. Es gibt zwar zwischenzeitlich auch Alternativen (zum Beispiel Android Studio, in einer frühen Beta-Version), etabliert ist jedoch der Einsatz von Eclipse. Für die Entwicklung der Apps wird ein eigenes Software-Development-Kit – das Android-SDK – benötigt. Dieses stellt die Schnittstellen zum (API) für die Programmentwicklung bereit. Erschwerend kommt hinzu, dass mehrere Plattformen von Android (im Sinne von Versionen) mit den zugehörigen APIs existieren. Für welche Plattform man entwickelt, sollte man sich später genau überlegen. Nur auf das neueste API zu setzen, hat das Problem, dass man zu viele noch auf den Markt befindliche Geräte ausgrenzt. Wählt man dagegen eine zu alte Version (aus Gründen der Kompatibilität), muss auf viele Vorzüge verzichtet werden. Ein guter Kompromiss (für die allgemeine App) oder eine sorgfältige Auswahl (bei eindeutiger Zielgruppe mit bekannten Endgeräten) ist also gefragt. In Abbildung 6 ist die Android-Versionsverteilung (Stand Anfang 2014) zu sehen. Hier finden sich weitere interessante Statistiken über die genutzte Hardware, beispielsweise zu vorhandenen Displayauflösungen der genutzten Geräte. Dieses ist eine wichtige Aussage für die Entwicklung der Benutzeroberfläche (User Interface).
Abb. 6: Android-Versionsverteilung zum Jahresanfang 2014

Abb. 6: Android-Versionsverteilung zum Jahresanfang 2014

Installationshinweise des Android-Debug-Bridge-(ADB-)Treibers unter Windows 8

Windows 8 verlangt aufgrund der strengeren Sicherheitsregeln ein etwas anderes Vorgehen für die Installation des Gerätetreibers, sofern dieser nicht digital signiert ist:

  1. Windows-Taste + i gleichzeitig drücken
  2. Shift-Taste gedrückt halten und neu starten
  3. Problembehandlung auswählen
  4. Erweiterte Optionen auswählen
  5. Starteinstellungen auswählen
  6. Neu starten auswählen, F7 oder 7 drücken
  7. Shift-Taste gedrückt halten und neu starten

Die Verbindung zwischen Eclipse und Android-SDK wird durch ein Plug-in für die Entwicklungsumgebung hergestellt. SDK-Version und Plug-in müssen dabei zueinander passen. Statt Eclipse, Android-SDK und Plug-in separat zu installieren, steht ein Komplettpaket zur Verfügung. Diese – als Android-Developer-Tools (ADT) bezeichnete – Softwaresammlung enthält noch weitere Werkzeuge für die App-Programmierung. Die aktuelle Version der ADT kann man hier herunterladen. Auch hier wird erneut zwischen 32 und 64 Bit differenziert. Die ADT umfassen gepackt ca. 480 MB. Nach dem Download ist dieses zu entpacken (>1 GB); es kann daher etwas dauern. Danach finden wir zwei Ordner (\eclipse\ enthält die Dateien zur Entwicklungsumgebung und \sdk\ enthält die Dateien zum Software-Development-Kit, u. a. die Daten zu den ausgewählten Plattformen). Weiterhin ist der so genannte SDK-Manager im Root-Verzeichnis enthalten. Diesen gilt es als Nächstes zu starten (Abb. 7).

Abb. 7: Der Android-SDK-Manager dient der Auswahl der zu installierenden Plattformen (APIs)

Abb. 7: Der Android-SDK-Manager dient der Auswahl der zu installierenden Plattformen (APIs)

Nunmehr sind die Plattformen auszuwählen, für welche eine Entwicklung erfolgen soll. Auch Updates werden über dieses Tool gemanagt. Der Autor hat zunächst die Plattform „Android 4.0.3“ (entspricht der API-Version 15) ausgewählt, da das vorliegende Tablet diese Betriebssystemversion verwendet – an dieser Stelle sollte man also die Android-Version seines Zielgeräts überprüfen. Nach der Auswahl kann der Download bzw. das Update gestartet werden, ggf. sind noch Lizenzbestimmungen zu bestätigen. Die Installation erfolgt in den Ordner \sdk\platforms\.

Das Starten der Entwicklungsumgebung (Eclipse) ist einfach. Dazu wechselt man in das Verzeichnis \eclipse und startet die ausführbare Datei eclipse.exe. Eine separate Installation der IDE ist nicht erforderlich. Damit kann man das gesamte Entwicklungsverzeichnis (inklusive Eclipse und SDKs) innerhalb des Systems auch verschieben. Nach dem Start von Eclipse wird man zunächst aufgefordert, den Workspace – also das zentrale Arbeitsverzeichnis – zu definierten. Danach gelangt man zur Startseite der IDE, welche bereits auf eine Entwicklung von Android-Apps ausgerichtet ist. An dieser Stelle ist der „Installationsmarathon“ abgeschlossen. Die technischen Voraussetzungen für unsere erste App sind nun geschaffen.

Auf der MobileTech Conference 2015 in Berlin gibt es vom 31. August bis 3. September jede Menge interessanter Sessions für Mobile-Entwickler.

In diesen MobileTech-Con-Sessions erfahren Sie mehr über die Entwicklung für Android, iOS & Co.:

 

Eine erste App

Die wollen wir auch gleich an dieser Stelle umsetzen. Es geht also darum, eine erste lauffähige Anwendung zu erzeugen, die ein rudimentäres UI aufweist und bereits gestartet werden kann („Hallo World“). Wie in modernen integrierten Entwicklungsumgebungen üblich, hilft dabei ein Assistent, um die Grundstruktur anzulegen und den Rahmencode zu generieren. Zu ergänzen ist danach die spezifische Funktionalität. Eine App ist für Eclipse (ähnlich wie bei Visual Studio) ein Projekt. Ein neues Projekt wird über File | New | Project gestartet (Abb. 8).

Abb. 8: Ein neues Android-Projekt starten

Abb. 8: Ein neues Android-Projekt starten

Es folgt ein Wizard, welcher grundlegende Einstellungen zum geplanten Projekt abfragt. Dies sind im ersten Dialogfeld:

  • Application Name: Unter diesen Namen wird die App später auf dem Endgerät und im Store registriert. In der App-Liste wird die Bezeichnung der Start-Activity (Startformular) eingetragen.
  • Projekt Name: Bezeichnung des Projekts im IDE und der Name des Unterverzeichnisses im Workspace.
  • Package Name: Packages sind Elemente der Sprache Java (vergleichbar mit den Namespaces von .NET). Übliche Bezeichnung in Orientierung der Webseite, also zum Beispiel: itfachartikel.testapp. Wichtig ist die Schreibweise: klein!
  • SDK-Versionen: Minimum, Target, Compile – Angabe der SDK-Versionen für den jeweiligen Zweck; im Zweifelsfall bei allen Eintragungen die gleiche Version wählen.
  • Theme: Auswahl des Basisthemas (Farbschema) der App.

Die Angaben im zweiten Dialogfeld (Create Custom Launcher Icon, Create Activity, Create Project in Workspace) lässt man unverändert. Im dritten Dialogfeld des Assistenten wird man zur Auswahl der Icons aufgefordert. Für diese erste Test-App bleibt zunächst alles bei den Voreinstellungen. Nach dem Klick auf „Next“ erfolgen in den beiden folgenden Dialogfeldern die Auswahl der Start-Activity und deren Name. Nach diesen Schritten sind alle Angaben vom Wizard eingeholt und Eclipse ist bereit, das Grundgerüst der ersten App zu bauen. Seien Sie gespannt!

Die Projektstruktur einer App wird im Package-Explorer in Abbildung 9 deutlich.

Abb. 9: Der Package-Explorer zur Verdeutlichung der Projektstruktur

Abb. 9: Der Package-Explorer zur Verdeutlichung der Projektstruktur

Zu Beginn genügt es, die wichtigsten Elemente zu identifizieren:

  • src: In diesem Ordner liegen die Quellcodedateien.
  • gen: Automatisch generierte Java-Dateien; die manuelle Bearbeitung ist nicht vorgesehen.
  • libs: Bibliotheken, in Abhängigkeit der Zielplattform.
  • res: Ordner für Ressourcen (Bild und Textelemente).
  • res\layout: Die Daten zu den Formularen der App, definiert in XML.

Beispielhaft klicken wir im Ordner \res\layout die Datei activity_main.xml an. Eclipse stellt daraufhin im eigenen Designer das Aussehen der Activity dar (Abb. 10). Der geübte Entwickler findet am rechten Bildschirmrand vertraute Elemente. Beispielsweise wird die Struktur des UI aus den Elementen angezeigt (outline) und die Werte der einzelnen Eigenschaften der Steuerelemente der Oberfläche können im Properties-Editor konfiguriert werden. Vergleichbar zur Gestaltung der Benutzeroberflächen für Windows Presentation Foundation erzeugt der Designer XML-Code (unter WPF: XAML-Code, eine „Spielart“ von XML). Die Formulargestaltung ist somit auch für Android-Apps eine Kombination aus Designerbedienung (Mausinteraktion), Anpassung von Eigenschaften (Properties-Editor) und letztendlicher Nachbearbeitung des XML-Codes.

Abb. 10: Eclipse enthält einen Designer für das Gestalten des UI der App

Abb. 10: Eclipse enthält einen Designer für das Gestalten des UI der App

Bevor wir zum ersten Start der App kommen, noch ein Blick auf den initialen Sourcecode der App. Dieser ist unter \src\de.itfachartikel.testapp\ für das Beispiel zu finden. Ein Klick auf die Datei MainActivity.java führt zur Anzeige des Quellcodes (Listing 1). In oberster Zeile steht der Name des Packages. Es folgen import-Anweisungen (in C# usings) zur Einbindung der benötigten Bibliotheken. Es wird eine Klasse MainActivity definiert, diese erbt (extends) wichtige Merkmale der Basisklasse Activity. Beim Starten der Anwendung wird die Methode onCreate(…) aufgerufen. In dieser wird das Layout der App über setContentView(…) definiert.

Listing 1
package de.itfachartikel.testapp;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
...
}

Emulator und echte Hardware

Jetzt geht es darum, die Früchte dieser Mühen zu ernten. Die App wird erstellt und gestartet. Wir wollen die App sowohl im Emulator also auch auf richtiger Hardware testen. Zunächst ist der automatische Build auszuschalten (Project | Build Automatically). Danach gilt es, das gesamte Projekt zu speichern (File | Save all). Verarbeitet werden die Änderungen nur dann, wenn diese auch vor einem neuen Build gespeichert wurden. Manuell erstellen Sie das Projekt über Project | Biuld Project. Eventuelle Fehler im Quellcode würden farblich gekennzeichnet. Um die App im Emulator zu testen, muss man ein virtuelles Android-Gerät anlegen und mit den gewünschten Merkmalen konfigurieren. Ein Android Virtual Device (AVD) erzeugt man wie folgt:

  1. Start des Android-AVD-Managers (direkt aus Eclipse über Window | Android Virtual Device Manager).
  2. Über „New“ wird ein neues Gerät angelegt (11).
Abb. 11: Konfiguration eines neuen virtuellen Geräts im AVD-Manager

Abb. 11: Konfiguration eines neuen virtuellen Geräts im AVD-Manager

Nun wird die App im Emulator gestartet. Über Window | Show View | Console können dazu die laufenden Meldungen über ein separates Fenster verfolgt werden. Zum endgültigen Start der App aktiviert man den Root-Knoten (TestApp) im Package-Explorer. Danach ruft man Run | Run As | 1 Android Application auf. Der Start des Emulators ist alles andere als schnell, deshalb sollte dieser nach dem Testen der App auch nicht sofort wieder geschlossen werden. Es genügt, ihn zu minimieren. Für den nächsten Testlauf wird dann die überarbeitete App lediglich auf dem virtuellen Gerät neu installiert und gestartet. Nach einer „gefühlten“ Ewigkeit wird tatsächlich das virtuelle Gerät im Emulator inklusive unserer App angezeigt (Abb. 12). Herzlichen Glückwunsch!

Abb. 12: Die gestartete App im Emulator

Abb. 12: Die gestartete App im Emulator

Deutlich flüssiger ist die Arbeit mit realer Hardware. Dazu ist sicherzustellen, dass diese über USB angeschlossen und der Debug-Treiber korrekt installiert ist (s. o.). Man ruft den Menüpunkt Run | Run Configurations auf.

Man wählt die Option „Always Prompt To Pick Device“. Die Bestätigung erfolgt mit „Apply“. Danach wird das Dialogfeld geschlossen. Und siehe da – nach wirklich wenigen Augenblicken erscheint unsere erste App auf dem echten Tablet überhaupt nicht virtuell.

Ausblick und Fazit

In diesem einführenden Beitrag haben wir uns aus der Perspektive eines klassischen „Windows-Entwicklers“ in das Abenteuer App-Entwicklung für Android-Geräte gewagt. Einen Großteil der Ausführungen waren dem recht großen Installations- und Einrichtungsaufwand gewidmet. Auch die Entwicklungsumgebung Eclipse fühlt sich (noch) ungewohnt an. Ähnliche Funktionen wie in unserem geliebten Visual Studio sind zwar vorhanden, aber vieles funktioniert eben jedoch anders. Die Zeit während der Installation der notwendigen Software kann man sinnvoll nutzen und sich nebenher in das „Ökosystem“ Android einlesen. Im kommenden zweiten Teil werden wir uns mit den Möglichkeiten zur Gestaltung des User Interface für die Apps beschäftigen. Auch hier gibt es gegenüber Windows Forms und Windows Presentation Foundation (WPF), um erneut die Windows-Welt zu bemühen, das Eine oder Andere umzulernen. Ein abschließender Hinweis: Der Quellcode zu diesem Testprojekt für die Plattform 4.0.3 und die IDE Eclipse ist per Download verfügbar.

Lesen Sie hier weiter: Android-Entwicklung für Windows-Entwickler – eine Einführung [Teil 2]

Mobile Technology

Mobile TechnologyDieser Artikel ist im Mobile Technology erschienen. Mobile Technology ist der Wegbegleiter für alle, die sich professionell mit der Entwicklung für mobile Devices und den Möglichkeiten, die der Markt des Mobile Business und Marketing bereithält, beschäftigen.

Natürlich können Sie das Mobile Technology über den entwickler.kiosk auch digital im Browser oder auf Ihren Android- und iOS-Devices lesen. In unserem Shop ist das Mobile Technology ferner im Abonnement oder als Einzelheft erhältlich.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Abonnieren
Benachrichtige mich bei
guest
0 Comments
Inline Feedbacks
View all comments
X
- Gib Deinen Standort ein -
- or -