12. Feb 2018
Lesedauer 13 Min.
Die Java-App für Android
Eine App – viele Technologien, Teil 3
Die Beispiel-App wird als native App für Android umgesetzt.
https://developer.android.com
Dieses ist der dritte Teil des umfassenden Experiments, die unterschiedlichen technologischen Ansätze zum Bau einer einfachen App für Mobilgeräte im Detail zu analysieren. Das geplante Spektrum reicht dabei von nativen Ansätzen bis hin zur plattformübergreifenden Programmierung. Diesmal geht es darum, die Beispiel-App, eine einfache Einkaufsliste, in Java für Android zu schreiben. Auskunft darüber, welche Teile der Serie bereits erschienen sind und welche in den kommenden Heften noch folgen, gibt der Kasten Eine App – viele Technologien.Das Experiment soll Fragen beantworten wie: Wann ist welcher Ansatz sinnvoll und effizient? Kann man in bestimmten Situationen die plattformübergreifende Programmierung wagen oder ist es trotz des Mehraufwands besser, auf die native Entwicklung zu setzen? Bis dahin ist es jedoch noch ein weiter Weg.Das Ziel ist es, eine App gemäß den in den ersten beiden Teilen der Serie ([1] und [2]) genannten Anforderungen umzusetzen, beziehungsweise deren Umsetzung zumindest weitgehend zu skizzieren. Als Beispiel dient ein digitaler Einkaufszettel. Die Aufgabe ist simpel, aber wir möchten dabei hinter die Kulissen blicken. Los geht’s also mit dem Entwickeln einer nativen App für Android.
Die Plattform
Android ist ein Betriebssystem auf Basis des Linux-Kernels und zugleich auch eine Plattform, zu der eine Reihe von Standardanwendungen gehören. Android-Apps installiert man im Regelfall über Google Play. Die Systemarchitektur sehen Sie in Bild 1. Dazu sind ein paar Begriffserklärungen und Erläuterungen angebracht [3]:- Der Linux-Kern ist das Fundament von Android. Er kümmert sich um Prozesssteuerung, Speicherverwaltung, Netzwerkkommunikation und die Sicherheit des gesamten Systems. Die Sensoren und Systeme, wie etwa Audio, Kamera et cetera, sind über Kerneltreiber angebunden.
- Das Akronym HAL steht für die Hardware-Abstraktionsschicht. Diese ruft der Android-Systemdienst beim Zugriff auf die Gerätetreiberschicht auf.
- Systemdienste fungieren als Zwischenschicht zwischen Framework und Hardware.
- Binder IPC Proxies verwendet die Framework-Schicht, um mit den Systemdiensten zu kommunizieren.
- Anwendungen kommunizieren ausschließlich über das Application Framework mit dem System.
- Views sind für die Benutzeroberfläche verantwortlich.
- Der Content Provider regelt den Zugriff auf die Daten anderer Programme und stellt die eigenen Programmdaten zur Verfügung.
- Der Resource Manager vermittelt den Zugriff auf Zeichenketten, Grafiken und Layout-Dateien.
- Der Notification Manager dient der Anzeige von Pop-up-Nachrichten an den Nutzer.
- Der Activity Manager steuert den Lebenszyklus einer Android-App.
Entwicklungsumgebung einrichten
Nach diesem kompakten Überblick geht es darum, die Entwicklungsumgebung vorzubereiten. Beim Entwickeln von Android-Apps haben Sie die freie Wahl, ob Sie unter Windows, einer Linux-Distribution oder unter macOS arbeiten möchten. Android Studio [4] steht für alle drei Systeme zur Verfügung.Laden Sie Android Studio 3.0 für Ihr Betriebssystem herunter und führen Sie die Installation wie gewohnt durch. Nach dem Start von Android Studio beziehungsweise beim Anlegen eines Projekts kann es durchaus sein, dass noch einige Dateien zum verwendeten SDK nachgeladen werden.Eine App – viele Technologien
Teil 1: Die Möglichkeiten einer App [1]
Hat alles so weit funktioniert, dann sehen Sie den Startbildschirm von Android Studio. Damit können Sie ein neues Projekt starten, existierende Projekte öffnen, eine lokale Kopie eines Projektverzeichnisses aus einem Online-Repository anfertigen und so weiter. Wichtig ist der Configure-Button. Darüber gelangen Sie zum SDK Manager beziehungsweise zur automatischen Installation der Updates.Über den SDK Manager (Bild 2) können Sie die gewünschte SDK-Version jederzeit nachinstallieren. Dazu gehören auch die für die Entwicklung erforderlichen Tools, wie etwa Emulatoren oder USB-Treiber für angeschlossene Geräte. Eine Zuordnung der Android- zur SDK-Version und ein paar Highlights der jeweiligen Version finden Sie im Download zu diesem Artikel in der Tabelle „Android-Versionen, API-Level und wichtige Features“.
Beim Erstellen eines neuen Projekts müssen Sie überlegen, welche SDK-Version noch mindestens unterstützt werden soll. Aktuell ist Version 8.0 (Oreo) mit dem zugehörigen API-Level 26. Hier ist jedoch der Verbreitungsgrad noch sehr gering (Bild 3).
Verbreitungsgradder Android-Versionen(Bild 3)
https://developer.android.com
Wollen Sie mehr als 99 Prozent aller Android-Geräte adressieren, müssen Sie auf API-Level 14/Android 4.0 zurückgehen. Die meisten aktuellen Apps gehen nur noch bis zur Version 5.1 (API-Level 22) zurück und erreichen damit derzeit 71 Prozent aller Android-Geräte. Mit API-Level 19 (Android 4.4) werden 92,2 Prozent aller Geräte adressiert.Möchten Sie Features einer neueren Version unter einem älteren Android SDK verwenden, müssen Sie die zugehörige Support-Library einbinden. Dies klappt über das Build-System, indem Sie die Ziel-SDK-Version auf die gewünschte Versionsnummer anpassen.
Projekt anlegen
Jetzt kann’s losgehen. Mit dem in Android Studio integrierten Assistenten erzeugen Sie ein neues Projekt. Die zu erfassenden Angaben – siehe Bild 4 und Bild 5 – sind selbsterklärend. Nachdem Sie alle Schnitte abgearbeitet und auf Finish geklickt haben, wird das Projekt-Skelett der App automatisch angelegt. Einen ersten Eindruck bekommen Sie beim Betrachten von Bild 6. Dazu sind die folgenden Erläuterungen angebracht:- Ordner App: Darin sind alle Dateien der App abgelegt. Die Projekteinstellungen befinden sich unterhalb des Ordners manifest, die Quellcode-Dateien unterhalb des Ordners java, und die Ressourcen-Dateien liegen im Ordner res – das sind unter anderem die Activities, also die Formulare.
- Ordner Gradle Scripts: Android Studio nutzt für den Bau von Projekten, also das Übersetzen und das Zusammenfügen der Pakete zu einem installationsfähigen Paket (APK), das Build-Tool Gradle. Die zugehörigen Skripte zur Steuerung werden unterhalb dieses Ordners abgelegt. Insbesondere sind die Dateien build.gradle auf Ebene der App beziehungsweise Ebene des Projekts von Interesse. Sie steuern den Build-Prozess. Listing 1 zeigt den Inhalt von build.gradle auf App-Ebene. Im oberen Abschnitt sehen Sie die SDK-Versionen (Minimal- und Ziel-SDK) und im unteren Abschnitt die Projektabhängigkeiten (dependencies).
Listing 1: Datei build.gradle (App)
apply plugin: 'com.android.application' <br/>android <br/>{ <br/> compileSdkVersion 26 <br/> defaultConfig <br/> { <br/> applicationId "com.larinet.myshoppinglist" <br/> minSdkVersion 15 <br/> targetSdkVersion 26 <br/> versionCode 1 <br/> versionName "1.0" <br/> testInstrumentationRunner "android.support <br/> .test.runner.AndroidJUnitRunner" <br/> }<br/> buildTypes <br/> { <br/> release { <br/> minifyEnabled false <br/> proguardFiles getDefaultProguardFile( <br/> 'proguard-android.txt'), <br/> 'proguard-rules.pro' <br/> } <br/> } <br/>} <br/>dependencies <br/>{ <br/> implementation fileTree(dir: 'libs', <br/> include: ['*.jar']) <br/> implementation <br/> ‚com.android.support:appcompat-v7:26.1.0‘ <br/> implementation 'com.android.support <br/> .constraint:constraint-layout:1.0.2' <br/> testImplementation 'junit:junit:4.12' <br/> androidTestImplementation <br/> 'com.android.support.test:runner:1.0.1' <br/> androidTestImplementation <br/> 'com.android.support.test <br/> .espresso:espresso-core:3.0.1' <br/><br/> compile 'commons-io:commons-io:2.6'
Bereits jetzt könnten Sie die App erstellen (Menüpunkt Build). Gegebenenfalls werden Sie von Gradle aufgefordert, noch fehlende Bibliotheken zu installieren. Im Fehlertext erscheint dazu in der Regel auch ein Link, mit dem sich das vollautomatisch erledigen lässt.
Von Emulatoren und richtigen Geräten
Während und auch nach der Entwicklung muss man eine App immer wieder testen. Zur Auswahl stehen der Test auf einem Emulator oder auf einem echten Smartphone oder Tablet. Mit dem Emulator ist das zwar bequem, aber Aussagen über die Performance kann man dann kaum treffen.Der Standard-Emulator ist auf vielen PCs und Notebooks so quälend langsam, dass sich damit kaum vernünftig arbeiten lässt. Sofern die von Ihnen verwendete Hardware explizit Virtualisierungstechniken unterstützt, geht es mit dem Intel x86 Emulator Accelerator (HAXM) deutlich schneller. Dieser kann über den eingangs erwähnten SDK Manager installiert werden. Holen Sie dies gegebenenfalls noch nach, es lohnt sich!Letztendlich müssen Sie die Apps aber immer auch auf echter Hardware testen. Schließen Sie dazu ein Smartphone oder Tablet via USB an den Entwicklungsrechner an. Es empfiehlt sich ein halbwegs aktuelles Gerät, zum Beispiel mit Android 6.0. Damit decken Sie eine breite Masse der Nutzer ab.Versionskontrolle
Um das Beispielprojekt direkt professionell zu starten, wird es von Anfang an an ein Versionskontrollsystem angebunden. Android Studio gibt sich hier erfreulich offen, das heißt, Sie können aus unterschiedlichen Systemen wählen.Mit Blick auf das Gesamtvorhaben – eine App, unterschiedliche Plattformen und Systeme – fällt die Entscheidung auf Git, auch weil Git von den meisten cloudbasierten Repositories unterstützt wird. Ist Git noch nicht auf Ihrem Entwicklungsrechner vorhanden, so installieren Sie es nun unabhängig von Android Studio. Die erforderlichen Dateien finden Sie unter [5].Kotlin: Sprache und Insel
Zunächst ist Kotlin eine russische Ostsee-Insel im finnischen Meerbusen, 30 Kilometer westlich von Sankt Petersburg. Außerdem steht der Name für eine Programmiersprache von JetBrains für die Java Virtual Machine. Der Name ist also eine Anspielung auf die Doppeldeutigkeit des Wortes Java.
Danach aktivieren Sie Git auch gleich für das Beispielprojekt. Das klappt über den Menüpunkt: VCS | Enable Version Control Integration. Nach der Auswahl von Git und der Bestätigung durch OK scheint nichts zu passieren. Das täuscht aber, denn im Hintergrund wurde die lokale Versionskontrolle für das Projekt eingerichtet.Jetzt müssen Sie die Projektdateien noch zum Repository hinzufügen. Auch das ist nicht wirklich kompliziert. Dazu klicken Sie mit der rechten Maustaste auf den Projektnamen und wählen dann den Menüpunkt Git | Add. Auch hier werden Sie keine Reaktion des Systems bemerken. Die relevanten Projektdateien werden jedoch nun versioniert. Damit sind Sie bereit für ein erstes Commit. Das erfolgt nach einem Rechtsklick auf den Projektnamen und der Auswahl des Menüpunkts Git | Commit Directory. Daraufhin sehen Sie das Dialogfeld aus Bild 7, das eine Zusammenfassung der anstehenden Versionierung zeigt, und haben die Möglichkeit, den Commit mit einem Hinweistext zu versehen. Davon sollten Sie immer Gebrauch machen, damit Sie später noch wissen, welches Commit zu welchen Quellcode-Anpassungen geführt hat.
Nach diesem Schritt werden die letzten Änderungen am Quellcode in das lokale Repository übertragen. Gelegentlich erscheint noch eine Warnung, dass eine automatisch angestoßene Quellcode-Analyse zu Hinweisen geführt hat. In diesem Fall müssen Sie explizit bestätigen, dass Sie die Quellecode-Anpassungen trotz dieser Hinweise unverändert übernehmen wollen. Alternativ können Sie die Analyse-Funktion deaktivieren.Noch passiert alles lokal auf dem Entwicklungsrechner. Quellcode-Verwaltung im Team ist freilich nur sinnvoll, wenn der Code auf einem zentralen Repository liegt.
Ab in die Cloud
Android Studio macht es einfach, den Zugriff auf ein Git-basiertes Online-Repository einzurichten. Als Hosting-Ort wird für das Beispiel Visual Studio Online gewählt. Legen Sie also online ein neues Repository an und achten Sie darauf, Git als Versionskontrollsystem zu wählen (Bild 8). Nach der Bestätigung mit Create kopieren Sie den Link, um die Quellcode-Verwaltung später aus Android Studio zu erreichen.
Achtung: Um mit Android Studio auf Visual Studio Online zuzugreifen, benötigen Sie ein Plug-in. In Android Studio wählen Sie dazu File | Settings und dann die Registerkarte Plugins. Hier suchen Sie nach Visual Studio Team Service, siehe Bild 9.
Ist dieses Plug-in installiert, können Sie den Quellcode in das Online-Repository übertragen. Dazu klicken Sie mit der rechten Maustaste auf den Eintrag App und wählen über das Kontextmenü Git | Repository | Push. Beim ersten Aufruf ist noch der Pfad zum Repository aus Visual Studio Online einzutragen. Mit diesen Schritten sind alle Vorbereitungen getroffen, um mit der eigentlichen Entwicklungsarbeit in Android Studio zu starten.
Eine App in Android
Grundlage für die Programmierung einer Android-App ist deren Lebenszyklus. Sie finden diesen in Bild 10. Das Diagramm zeigt die einzelnen Zustände einer Android-App. Gerade wenn Sie Apps mit mehreren Activities erstellen, beziehungsweise die App auch im Hintergrund läuft, ist das Verständnis des Lebenszyklus wichtig.
Um eine App in Android zu programmieren, müssen Sie die folgenden Schritte durchlaufen: Anlegen des Projekts und des Projekt-Skeletts inklusive einer Architektur zum Strukturieren des Quellcodes. Erstellen der Activities, das heißt, gestalten der Benutzeroberfläche. Dies erfolgt im Zusammenspiel aus direktem Erfassen des XML-Codes und der Arbeit mit dem grafischen Designer.Implementieren der Business-Logik in Java. Einrichten einer lokalen Datenhaltung beziehungsweise Verbindung zu einem Backend in der Cloud (sofern notwendig). Verknüpfen von Benutzeroberfläche und Business-Logik über Listener sowie weitere App-Spezifika, zum Beispiel Icons und andere grafische Ressourcen, um die App fit für den Google Play Store zu machen.Im Detail folgen nun die Punkte Erstellen der Benutzeroberfläche und Implementieren der Business-Logik. Eine Verbindung zu einer Datenhaltungsschicht beziehungsweise Cloud erfordert die Beispiel-App in der ersten Version nicht. Es geht lediglich darum, den Entwicklungszyklus für eine Android-App zu studieren.
Die Benutzeroberfläche
Nicht mit XAML. Aber ein bisschen ähnlich! Das User Interface (UI) wird mithilfe von XML definiert. Einen grafischen Designer gibt es auch. Dabei gilt:- Die Controls werden ineinandergeschachtelt, für die oberste Ebene stehen verschiedene Layout-Container zur Verfügung.
- Zu jeder Activity ist eine Java-Datei erforderlich, diese ist mit den Code-behind-Dateien aus der Universal Windows Platform vergleichbar. Neben Deklarationen und Initialisierungen enthält diese Datei auch die Methoden, mit denen die App auf Benutzerinteraktionen reagiert, etwa wenn der Benutzer auf einen Button gedrückt hat. Statt zur Entwurfszeit kann eine Activity alternativ auch zur Laufzeit in Java generiert werden.
- Android Studio bietet die Möglichkeit, das UI mithilfe des grafischen Designers zu gestalten und die Eigenschaften der Controls im Property-Editor festzulegen beziehungsweise zu ändern. Letztendlich wird immer XML-Code generiert, der ebenso direkt erfasst und angepasst werden kann. Erfahrene Entwickler werden das UI in XML definieren und das Ergebnis in der grafischen Vorschau betrachten. Das geht im Regelfall auch schneller.
- RelativeLayout: Ordnet die eingebetteten Elemente relativ zueinander beziehungsweise relativ zu seinen Rändern aus. Dieser Layout-Typ ist sehr flexibel und erlaubt eine einfache Umsetzung komplexer UIs.
- TableLayout: Die Elemente werden in Zeilen und Spalten angeordnet. Der Aufbau ähnelt dem Erstellen von Tabellen in HTML.
- GridLayout: Es wird ein Gitter erzeugt. Die Elemente werden in den Gitterelementen zugeordnet. Ein Element kann auch über mehrere Zeilen/Spalten reichen
- GridView: Ordnet die UI-Elemente in einer Galerie an. Die Zahl der Spalten wird definiert, die Zahl der Zeilen ergibt sich automatisch.
- FrameLayout: Es handelt sich um einen Platzhalter für View-Elemente, die zur Laufzeit ein- oder ausgeblendet werden.
- AbsoluteLayout: Es erfolgt eine freie Positionierung der eingebetteten Elemente über die Angabe der Koordinaten. Grundsätzlich gilt für auch für Android-Apps, dass man in der Regel auf relative Layouts setzt. Unterschiedlichste Bildschirmgrößen und Auflösungen verbieten eine absolute Positionierung.
Listing 2: Layout der Start Activity
&lt;?xml version="1.0" encoding="utf-8"?&gt; <br/>&lt;RelativeLayout xmlns:android=<br/> "http://schemas.android.com/apk/res/android" <br/> xmlns:tools="http://schemas.android.com/tools" <br/> android:layout_width="match_parent" <br/> android:layout_height="match_parent" <br/> android:descendantFocusability="beforeDescendants" <br/> android:focusableInTouchMode="true" <br/> tools:context=".MainActivity"&gt; <br/> &lt;ListView <br/> android:layout_width="wrap_content" <br/> android:layout_height="wrap_content" <br/> android:id="@+id/lvItems" <br/> android:layout_alignParentTop="true" <br/> android:layout_alignParentLeft="true" <br/> android:layout_alignParentStart="true" <br/> android:layout_above="@+id/btnAddItem" /&gt; <br/> &lt;EditText <br/> android:layout_width="wrap_content" <br/> android:layout_height="wrap_content" <br/> android:id="@+id/etNewItem" <br/> android:layout_alignTop="@+id/btnAddItem" <br/> android:hint="@string/enter_a_new_item" <br/> android:layout_alignParentLeft="true" <br/> android:layout_alignParentStart="true" <br/> android:layout_toLeftOf="@+id/btnAddItem" <br/> android:layout_toStartOf="@+id/btnAddItem" <br/> android:layout_alignParentBottom="true" /&gt; <br/><br/> &lt;Button <br/> android:layout_width="wrap_content" <br/> android:layout_height="wrap_content" <br/> android:text="@string/add_item" <br/> android:id="@+id/btnAddItem" <br/> android:layout_alignParentBottom="true" <br/> android:layout_alignParentRight="true" <br/> android:layout_marginRight="10pt" <br/> android:onClick="onAddItem" <br/> android:layout_alignParentEnd="true" /&gt; <br/>&lt;/RelativeLayout&gt; Unter der Haube
Die Programmierung der nativen Android-App erfolgt mithilfe von Java. Seit Kurzem gibt es mit der Programmiersprache Kotlin eine Alternative zu Java (siehe Kasten Kotlin: Sprache und Insel). Der Java-Code für die Shopping-List wird in der Datei MainActivity.java zusammengefasst. Bei einem größeren Projekt müsste die Business-Logik aufgeteilt werden. Für die App sind folgende Funktionen erforderlich:- Hinzufügen eines Eintrags zu einer Liste.
- Löschen eines Eintrags aus der Liste.
- Speichern der Liste in einer Datei, beim Hinzufügen eines Eintrags.
- Laden der Liste aus einer Datei, beim Start der App.
Listing 3: Code der Datei MainActivity.java
package com.larinet.myshoppinglist; <br/>import android.support.v7.app.AppCompatActivity; <br/>import android.os.Bundle; <br/>import android.view.View; <br/>import android.widget.AdapterView; <br/>import android.widget.ArrayAdapter; <br/>import android.widget.EditText; <br/>import android.widget.ListView; <br/>import org.apache.commons.io.FileUtils; <br/>import java.io.File; <br/>import java.io.IOException; <br/>import java.util.ArrayList; <br/><br/>public class MainActivity extends AppCompatActivity { <br/> private ArrayList&lt;String&gt; items; <br/> private ArrayAdapter&lt;String&gt; itemsAdapter; <br/> private ListView lvItems; <br/><br/> @Override <br/> protected void onCreate(Bundle savedInstanceState) { <br/> super.onCreate(savedInstanceState); <br/> setContentView(R.layout.activity_main); <br/> readItems(); <br/> lvItems = (ListView) findViewById(R.id.lvItems); <br/> itemsAdapter = new ArrayAdapter&lt;String&gt;(this, <br/> android.R.layout.simple_list_item_1, items); <br/> lvItems.setAdapter(itemsAdapter); <br/> setupListViewListener(); <br/> } <br/><br/> // Delete Item <br/> private void setupListViewListener() { <br/> lvItems.setOnItemLongClickListener( <br/> new AdapterView.OnItemLongClickListener() { <br/> @Override <br/> public boolean onItemLongClick( <br/> AdapterView&lt;?&gt; adapter, <br/> View item, int pos, long id) { <br/> // Remove the item within array at <br/> position items.remove(pos); <br/> // Refresh the adapter <br/> itemsAdapter.notifyDataSetChanged(); <br/> // Return true consumes the long click <br/> // event (marks it handled) <br/> // <br/> writeItems(); <br/> return true; <br/> } <br/> }); <br/> } <br/><br/> // Add Item <br/> public void onAddItem(View view) { <br/> EditText etNewItem = <br/> (EditText) findViewById(R.id.etNewItem); <br/> String itemText = <br/> etNewItem.getText().toString(); <br/> itemsAdapter.add(itemText); <br/> etNewItem.setText(""); <br/> writeItems(); <br/> } <br/><br/> // Read Items from file <br/> private void readItems() { <br/> File filesDir = getFilesDir(); <br/> File shoppingFile = new File(filesDir, <br/> "shopping.txt"); <br/><br/> try { <br/> items = new ArrayList&lt;String&gt;( <br/> FileUtils.readLines(shoppingFile,"UTF-8")); <br/> } catch (IOException e) { <br/> items = new ArrayList&lt;String&gt;(); <br/> } <br/> } <br/><br/> // write items on file <br/> private void writeItems() { <br/> File filesDir = getFilesDir(); <br/> File shoppingFile = new File(filesDir, <br/> "shopping.txt"); <br/> try { <br/> FileUtils.writeLines(shoppingFile, items); <br/> } catch (IOException e) { <br/> e.printStackTrace(); <br/> } <br/> } <br/>}
Sehr angenehm: Android Studio hilft bei der Implementierung, indem es das Skelett des Codes bei Bedarf eigenständig anlegt. Bild 12 zeigt die fertige App im Emulator.
Größere Projekte
Mit der Mini-App konnten Sie sich einen Überblick über den Entwicklungsprozess einer nativen Android-App verschaffen: beginnend mit dem Einrichten der Entwicklungsumgebung und dem Anbinden einer Versionsverwaltung über das Erstellen der Benutzeroberfläche bis zum Schreiben des Java-Codes. Sobald allerdings größere Projekte geplant sind, kommen noch einer oder mehrere der folgenden Punkte hinzu:- Externe Bibliotheken: Hier sind Sie mit Android stets auf der sicheren Seite. Wenn Cloud-Dienste spezifische SDKs zur Integration in die App anbieten, können Sie davon ausgehen, dass Android unterstützt wird. Das gilt auch für Microsoft Azure, das heißt, dass Microsofts Cloud-Dienste für mobile Apps direkt aus Java und Android Studio angesprochen werden können.
- Sensoren: Es zeigen sich alle Vorzüge einer nativen Entwicklung. Alle erdenklichen Sensoren eines Smartphones oder Tablets werden direkt per API unterstützt. Es gibt keine Einschränkungen.
- Architektur: Durch den Assistenten wird eine gewisse Struktur der App vorgeben. Dennoch erscheint die direkte Verknüpfung von Anwendungslogik und UI und Datenschicht nur bei kleineren Apps angebracht. Eine direkte Unterstützung beispielsweise des MVC-Musters, wie wir es für Apps der UWP, Xamarin oder WPF-Anwendungen kennen, gibt es in Android nicht. Im Bedarfsfall muss daher eine Eigenimplementierung her. Ideen, wie das umgesetzt werden kann, finden Sie beispielsweise unter [6].
- Mehrsprachigkeit: Apps für Android werden üblicherweise im weltweit erreichbaren Google Play Store bereitgestellt. Mehrsprachigkeit ist also wichtig. Android Studio meckert von Anfang an, wenn Sie mit hart kodierten Strings arbeiten. Zeichenketten werden gleichwohl in eine Ressourcendatei ausgelagert. Die Sprachanpassung lässt sich damit einfach bewerkstelligen.
- Community: Eine breite Unterstützung der Entwickler-Community ist Ihnen sicher. Unzählige Entwickler weltweit programmieren Apps für Android. Wissen, Best Practices und Tutorials finden sich daher zu allen Belangen.
Fazit
Entwickler aus dem Microsoft-Universum haben mit diesem dritten Teil der Serie Neuland betreten. Nicht C# und XAML, sondern Java und XML waren angesagt. Statt Visual Studio kam Android Studio zum Einsatz.Wenn man sich ein wenig eingefuchst hat, dann geht die Arbeit an nativen Android-Apps gut von der Hand. Die neue Version von Android Studio 3.0 macht einen ausgereiften und auch stabilen Eindruck. Damit zu arbeiten macht wirklich Spaß!Wichtig sind die Erfahrungen, die Sie bei der Entwicklung einer nativen Android-App sammeln. Selbst wenn Sie sich für ein kommendes Projekt für einen hybriden oder plattformübergreifenden Ansatz entscheiden, werden Sie immer wieder über plattformspezifische Besonderheiten stolpern. Spätestens dann ist es äußert hilfreich, den grundsätzlichen Aufbau eines Android-Projekts und dessen Build-Prozess zu kennen.Fussnoten
- Veikko Krypczyk, Eine App – viele Technologien, Teil 1, Das Experiment, dotnetpro 2/2018, Seite 120 ff., http://www.dotnetpro.de/A1802AppOverview
- Olena Bochkor, Eine App – viele Technologien, Teil 2, In wenigen Schritten zum Erfolg, dotnetpro 2/2018, Seite 124 ff., http://www.dotnetpro.de/A1802AppKonzeption
- T. Künneth, Android 7. Das Praxisbuch für Entwickler, Rheinwerk Computing, ISBN 978-3-8362-4200-4,
- Android Studio, http://www.dotnetpro.de/SL1803AppAndroid1
- Git, https://git-scm.com
- Eric Maxwell, MVC versus MVP versus MVVM on Android, http://www.dotnetpro.de/SL1803AppAndroid2
