Teil 3: Vorgehensweisen am Beispiel von Apps für Android und iOS

Mobile Apps aus einer Quelle
Keine Kommentare

In dieser Ausgabe wollen wir die Praxis der Cross-Platform-Entwicklung für die mobilen Systeme Android und iOS betrachten. Wie sieht eine passende Entwicklungsumgebung aus? Welchen Aufbau hat ein Projekt? Wie wird das User Interface erstellt? Fragen über Fragen. Wir haben einige Vorgehensweisen detaillierter betrachtet.

In Teil 2 der Artikelserie haben wir die folgenden Ansätze zur Entwicklung von nativen Apps für iOS und Android im Überblick vorgestellt: Xamarin, RAD Studio (FireMonkey), NativeScript, Flutter und Qt. Diese Ansätze eint das gemeinsame Ziel, aus einer einzigen Quellcodebasis simultan Apps für die Systeme Android und iOS zu erstellen. In diesem dritten Teil der Artikelserie wollen wir den Schwerpunkt der Cross-Platform-Programmierung vertiefen. Dazu besprechen wir die praktische Vorgehensweise bei der Entwicklung einer App anhand unterschiedlicher Ansätze.

Artikelserie

Testfeld

Aus dem umfassenden Angebot der Entwicklungsansätze zur mobilen und nativen App-Entwicklung für Android und iOS aus einem gemeinsamen Quellcode haben wir uns für drei recht unterschiedliche Vorgehensweisen entschieden. Es sind:

  • Xamarin: Mit Microsoft Technologien (C#, XAML) kann man in Visual Studio unter Windows oder macOS arbeiten.

  • Tabris.js: Man arbeitet mit JavaScript (TypeScript) und einem interessanten Entwicklungszyklus aus Developer-App und Online-Build.

  • RAD Studio: Apps entstehen hier als Teil einer umfassenden geräteübergreifenden Strategie.

In den folgenden Textabschnitten sehen wir uns diese alternativen Vorgehensweisen im Detail an. Beginnen wir mit Xamarin von Microsoft.

Eine App mit Xamarin Forms

Zunächst müssen wir uns hier über die Konfiguration der Entwicklungsumgebung Gedanken machen. Wir haben die Wahl zwischen Visual Studio (Microsoft Windows) mit dem entsprechenden Workload oder Visual Studio for Mac (macOS) [1]. Um Apps für iOS zu erstellen und per Simulator zu testen, ist ein installierter Xcode auf einem macOS notwendig. Mit dem Erstellen von Apps ist hier das Generieren des App-Package gemeint. Ein brauchbarer Ansatz ist es, Windows in einer virtuellen Maschine auf macOS auszuführen. Über die Projektvorlage starten wir eine neue Cross-Platform-App und wählen als Vorlage Xamarin.Forms für die gemeinsame Codebasis (Abb. 1).

Abb. 1: Vorlage Visual Studio for Mac für eine Xamarin.Forms-App

Abb. 1: Vorlage Visual Studio for Mac für eine Xamarin.Forms-App

Der Assistent fordert Sie dazu auf, die Zielplattformen und die Art der Codeteilung festzulegen. Wir aktivieren iOS und Android. Für jede Plattform (iOS, Android) wird jeweils ein eigenes und ein übergreifendes Projekt angelegt. Idealerweise gelingt es, den gesamten Code im generischen Projekt unterzubringen. Spezifischer Quellcode ist dann für die Plattformen nicht notwendig. Das User Interface wird deklarativ mit Hilfe der Beschreibungssprache XAML erstellt.

Eine Vorschaufunktion erlaubt das Abschätzen des Ergebnisses. Einen interaktiven Designer gibt es nicht. Bezüglich der Architektur setzt man bei Xamarin auf das MVVM-Pattern. Es werden also das User Interface (View), Geschäftslogik (ViewModel) und Datenschicht (Model) getrennt. Die Steuerelemente des User Interface kann man über ihre Eigenschaften und die auslösenden Ereignisse mittels Data Binding an das ViewModel binden. Damit können die Daten zwischen den Schichten ausgetauscht werden, ohne dass dafür explizit Code geschrieben werden muss. Ist die erste Version einer App fertiggestellt, kann man diese für die jeweilige Zielplattform kompilieren. Bekanntermaßen benötigt man für iOS wieder einen Mac und Xcode im lokalen Netzwerk. Die App wird direkt aus Visual Studio heraus erstellt.

Für Xamarin sind inzwischen sehr viele Komponenten und Bibliotheken verfügbar. Diese bindet man in das eigene Projekt ein. Entwickler, die mit den Technologien aus dem Microsoft-Stack vertraut sind, werden hier schnell klarkommen. Insbesondere das Erstellen des User Interface mittels XAML-Beschreibungssprache ist dem Vorgehen beim Erstellen einer WPF-(Desktop-) oder UWP-App sehr ähnlich. Zwar sind die XAML-Dialekte unterschiedlich, aber die Systematik ist gleich. Wie bereits im letzten Teil erwähnt, besteht grundsätzlich die Option, statt dem generischen Vorgehen mit Xamarin.Forms das User Interface plattformspezifisch zu erstellen. Das sollte aber nur dann gewählt werden, wenn man mit Xamarin.Forms nicht an das Ziel kommt, denn dann werden einige Vorteile der Cross-Platform-Strategie wieder aufgehoben.


Xamarin zeichnet sich durch folgende Features aus, um eine native App für Android und iOS zu erstellen:

  • User Interface: Auswahl zwischen einem generischen User Interface auf der Basis von Xamarin.Forms bzw. einem plattformspezifischen Vorgehen.

  • Xamarin.Forms: Deklarative Erstellung des User Interface mit einer einfachen Entkopplung der Anwendungsschichten auf der Basis des MVVM-Patterns (Kasten: „Das MVVM-Pattern“).

  • Entwicklungsumgebung: Einsatz einer umfassenden integrierten Entwicklungsumgebung Visual Studio bzw. Visual Studio for Mac.

  • Bibliotheken: Rückgriff auf viele Bibliotheken über den Package-Manager in Visual Studio NuGet.

Xamarin (Forms) richtet sich damit primär an Entwickler, die native Apps für iOS und Android entwickeln möchten und bereits Erfahrungen haben im Stack der Microsoft-Technologien (XAML, C#, Visual Studio).

Das MVVM-Pattern

Das Model-View-ViewModel-(MVVM-)Pattern wird bei der Anbindung der Benutzeroberfläche im Umfeld von .NET verwendet. Konkret kann es heute in folgenden Technologien angewendet werden:

  • Desktopapplikationen auf der Basis von Windows Presentation Foundation (WPF)

  • Apps auf der Basis der Universal Windows Platform (UWP)

  • Plattformübergreifende Apps für iOS, Android und UWP auf der Basis von Xamarin

  • WinUI 3.0, künftige Apps für Windows auf der Basis der neuen Grafik-Library

Allen Technologien gemeinsam ist die in Abbildung 3 gezeigte Zusammenarbeit der einzelnen Schichten. Sehen wir uns diese im Einzelnen an:

  • View: Die Benutzeroberfläche wird deklarativ erstellt. Dazu wird die Beschreibungssprache XAML verwendet.

  • Model: Hierbei handelt es sich um die Schicht zur Datenhaltung. Zwischen View und Modell soll jedoch keine direkte Verbindung bestehen. Die Verbindung zwischen View und Modell wird durch das ViewModel sichergestellt.

  • ViewModel: Dies ist das Bindeglied zwischen beiden Schichten. Die View übermittelt die Daten an das ViewModel, und das ViewModel interagiert wiederum mit dem Modell. Das ViewModel registriert, wenn sich die Daten ändern und leitet diese Änderungen an die registrierten Views weiter.

Die View wird mittels sogenanntem Data Binding an das ViewModel gebunden. Dazu wird der View grundsätzlich bekanntgegeben, in welcher Klasse sie die zugehörigen Informationen findet (DataContext). Die einzelnen Elemente werden dann an die öffentlichen Eigenschaften der Klassen des ViewModel gekoppelt. Ändern sich die Werte dieser Eigenschaften, benachrichtigt das ViewModel all seine Views über diese Datenänderung, sodass sie die aktuellen Werte erhalten. Aktionen der View, zum Beispiel das Drücken eines Buttons, werden mit Hilfe von Commands an das ViewModel weitergeleitet. Zwischen ViewModel und Modell besteht eine ähnliche Systematik zum Datenaustausch.

Letztendlich führt das MVVM-Entwurfsmuster bei korrekter Anwendung zu einer nahezu vollständigen Entkopplung der Schichten voneinander. Das Modell ist unabhängig von der View und auch vom ViewModel, d. h., das Modell kennt beide Schichten nicht. Das ViewModel kennt sein Modell, nicht aber seine Views. Diese Trennung hat den Vorteil, dass man das UI austauschen kann, ohne das Modell bzw. das ViewModel anzupassen. Es ist möglich, dass ein ViewModel über mehrere Views verfügt. Auf diese Weise können die Daten unterschiedlich repräsentiert werden (Abb. 2).

Abb. 2: Das MVVM-Entwurfsmuster bindet das UI an die Fachlogik (Quelle: Microsoft)

Abb. 2: Das MVVM-Entwurfsmuster bindet das UI an die Fachlogik (Quelle: Microsoft)

Eine App mit Tabris.js

In der Aufstellung der Cross-Platform-Ansätze des letzten Teils hatten wir Tabris.js noch nicht vorgestellt, daher holen wir das jetzt nach. Mit Tabris.js können Sie native Apps für iOS und Android aus einer einzigen Codebasis mit Hilfe der Programmiersprache JavaScript bzw. TypeScript entwickeln [2]. Tabris.js verwendet keinen WebView-Container zum Rendern der Benutzeroberfläche. Stattdessen werden native Widgets auf der mobilen Plattform aus JavaScript eingesetzt. Für die Entwicklung können vorhandene JavaScript-Bibliotheken und Cordova-Plug-ins integriert werden. Es werden viele APIs für Webanwendungen, zum Beispiel das XMLHttpRequest- oder das 2D-Canvas-API, implementiert (Abb. 3).

Abb. 3: Architektur einer Tabris.js-App [2]

Abb. 3: Architektur einer Tabris.js-App [2]

Die Entwicklung basiert auf dem direkten Herunterladen und Ausführen des JavaScript-Codes innerhalb der Tabris.js-Developer-App, die auf einem iPhone, iPad oder Android-Smartphone bzw. -Tablet läuft. Dieser Vorgang dauert nur ein paar Sekunden. Die Entwicklung beruht auf dem Zusammenspiel mehrerer Komponenten: dem Tabris.js Framework, der Developer-App und dem Online-Playground. Für die Entwicklung wird ein mobiles Gerät benötigt. Auf diesem wird Version 3 der Developer-App Tabris.js installiert. Diese App können Sie über den Google Play Store bzw. Apple App Store beziehen. Sie steht kostenfrei zur Verfügung (Abb. 4).

Abb. 4: Developer-App von Tabris.js

Abb. 4: Developer-App von Tabris.js

Die Developer-App ist der Mittelpunkt bei der Entwicklung und dem Testen. Erste Experimente starten auf dem Tabris.js Playground (Abb. 5) [3]. Im Onlineeditor kann direkt Quellcode erfasst bzw. angepasst werden, zum Beispiel ein typisches „Hello World“. Für einen Test startet man die Developer-App auf dem mobilen Gerät und scannt den Barcode vom Playground.

Abb. 5: Der Online-Playground dient für Experimente mit Tabris.js

Abb. 5: Der Online-Playground dient für Experimente mit Tabris.js

Danach wird die App auf dem mobilen Gerät, d. h. innerhalb der Developer-App, sofort gestartet. Um ein eigenes Projekt zu starten, sind folgende technische Voraussetzungen unter einem Windows-, Linux- oder Mac-System zu schaffen:

  • Node.js, inklusive npm [4].

  • TypeScript [5], Installation über npm mittels npm install typescript.

  • Editor zum Erfassen des Codes. Unmittelbar von Tabris.js wird Visual Studio Code unterstützt [6]. Es funktioniert jedoch auch mit einem anderen Editor.

  • Tabris.js [7]. Installation über npm mittels npm install -g tabris-cli.

  • Git (optional), als Versionskontrollsystem [8].

Die Entwicklung mit Tabris.js basiert auf einem Zusammenspiel aus lokalem Server und Developer-App. Daher ist es wichtig, dass sich das mobile Gerät und der Entwicklungsrechner im gleichen lokalen Netzwerk befinden.

Sind die Installationsarbeiten abgeschlossen, kann man mit der Erstellung einer App starten. Man nutzt dazu die Kommandozeile (Tabris CLI) und durchläuft die folgenden Schritte:

  1. Erstellen eines neuen Arbeitsverzeichnisses.

  2. Wechsel in das Verzeichnis auf Ebene der Kommandozeile.

  3. Erzeugen eines neuen Tabris.js-Projekts mittels des Befehls tabris init auf der Kommandozeile.

  4. Festlegen und Auswahl der initialen Eigenschaften zum Projekt, d. h. Projektname, Projektversion, Programmiersprache (JavaScript, TypeScript), App-ID, Name der App und die Konfigurationseinstellungen für die Entwicklungsumgebung, z. B.Visual Studio Code.

Danach generiert Tabris.js die grundsätzliche Projektstruktur inklusive der notwendigen Dateien (Tabelle 1). Die Bibliotheken werden im Ordner node_modules eingebunden. Sie können nunmehr die Projektdateien in Visual Studio Code als Ordner öffnen.

Datei/Ordner Beschreibung
package.json In dieser Datei wird das Projekt (App) definiert und die Abhängigkeiten von Bibliotheken werden notiert. Das Format ist JSON.
src Der JavaScript-Quellcode ist im Ordner /src abgelegt, zum Beispiel die Datei app.js.
cordova\config.xml Für den Build-Prozess ist eine Datei config.xml notwendig. Diese liegt im Unterordner /cordova. Hintergrund: Das Framework Cordova wird genutzt, um den Build der App und das Erstellen der App-Packages für die jeweilige Zielplattform durchzuführen.

Tabelle 1: Wichtige Dateien und Ordner für eine App mit Tabris.js

Im Ordner /src werden die Quellcodedateien für die App abgelegt. Hier wird u. a. auch das User Interface definiert. Für die Ausführung der App muss der Build über den lokalen Server von Node.js angestoßen werden. Das geschieht über die Kommandozeile mittels des Befehls tabris serve. Über CTRL+C können Sie den laufenden Prozess jederzeit beenden. Im lokalen Netzwerk ist der Server zum Beispiel unter der Adresse http://192.168.x.y:8080 zu erreichen. Passen Sie die Adresse gemäß Ihrem lokalen Netzwerk an. In der Developer-App öffnet man diese Adresse und startet die App.

Die Benutzeroberfläche einer Tabris.js-App besteht aus nativen Widgets, die durch JavaScript-Objekte dargestellt werden. Das sorgt dafür, dass die Oberflächen den Vorgaben von Android bzw. iOS entsprechen. Es gibt verschiedene Arten von Widgets wie eine Button-, TextView– oder ScrollView-Komponente. Jeder Widget-Typ ist ein Subtyp des Objektes Widget. Das Basisobjekt Widget stellt allgemeine Methoden zum Abrufen und Festlegen von Eigenschaften, zum Benachrichtigen von Ereignissen und zum Zuordnen an ein übergeordnetes Element bereit, das wiederum ein Objekt des Typs Widget ist. Ein Beispiel:

let button = new Button({
  left: 10,
  top: 10,
  text: 'Ein Button'
});

Damit erstellen Sie einen Button mit der Aufschrift Ein Button und den angegebenen Abständen vom Rand, d. h. von oben und von links mit jeweils 10 Pixeln. Über die Methode append können wir Kindelemente (wie zum Beispiel den Button) dem Objekt contentView hinzufügen:

import {contentView, TextView, Button} from 'tabris';
new Button({
  left: 10,
  top:10,
  text: Ein Button})
  .appendTo(contentView);

Statt das User Interface über TypeScript (JavaScript) zu erstellen, können Sie es auch in JSX (JavaScript XML) deklarieren und direkt in den Code einbetten:

import {contentView, TextView, Button, Constraint} from 'tabris';
contentView.append(
  <$>
    <Button top={10} left={10} text="Button mit JSX def."/>
  </$>
);

Auf diese Weise kann das User Interface schrittweise deklarativ erstellt werden. Das geschieht für iOS und Android in einem Arbeitsgang. Für eine maximale Geräteunabhängigkeit stehen leistungsfähige Layoutcontainer zur Verfügung.

Ein besonderes Feature von Tabris.js ist die Vorgehensweise beim Build. Tabris.js verwendet für den Build und das Erstellen der App-Packages Apache Cordova. Für diese Prozesse gibt es zwei grundsätzliche Vorgehensweisen:

  • Lokaler Build: Der Build und das Erstellen der App-Packages erfolgen mittels des Tabris.js Framework auf der lokalen Maschine.

  • Online-Build: Bei Tabris.js wird der Service angeboten, direkt aus einem GitHub Repository die App-Packages für die Plattformen zu generieren [2].

In der kostenfreien Variante von Tabris.js können Sie beliebig viele Builds aus öffentlichen GitHub Repositories ausführen bzw. ein privates GitHub Repository verarbeiten. Es ist also notwendig, dass der Quellcode auf GitHub gehostet wird. Auf der Webseite von Tabris.js loggen Sie sich mit Ihrem GitHub-Account ein. Wählen Sie den Punkt MyApps und erstellen Sie eine neue App. Danach können Sie aus Ihren GitHub Repositories das passende Repository auswählen. Im nächsten Schritt wird Ihnen direkt die Möglichkeit gegeben, den Build für die von Ihnen ausgewählten Zielplattformen anzustoßen. Über den Menüpunkt Settings können Sie entsprechende Keys für die Signierung der Packages hinterlegen. Für Android ist das nur für das Deployment über den Store notwendig. Für iOS ist es bereits zwingend, um die App grundsätzlich auf einem mobilen Gerät installieren zu können. Stoßen Sie den Build-Vorgang beispielsweise für Android an. Der Erfolg wird Ihnen direkt mit der Ausschrift Running quittiert. Das weitere Vorhaben läuft komplett ohne Ihr Zutun ab. Nach wenigen Augenblicken wurde durch Tabris.js der Build abgeschlossen und das jeweilige App-Package steht zum Download für Sie bereit. Sie können die Datei herunterladen, auf Ihr Mobilgerät übertragen und dort die App installieren und starten. Natürlich muss man nicht zwingend den Online-Build-Service nutzen. Um eine App auf Ihrem lokalen Computer zu erstellen, müssen Sie Entwicklertools wie Xcode und das Android SDK einrichten.

Tabris.js zeichnet sich durch folgende erwähnenswerte Features aus, um native App für Android und iOS zu erstellen:

  • Cordova-Plug-in-Support: Um typische Funktionen bereitzustellen, wie zum Beispiel den Zugriff auf die Hardware, nutzt Tabris.js die Plug-ins von Apache Cordova. Folgende Plug-ins sind mit Tabris.js getestet: Badge, Kamera, Device Motion, Network Information, Toast, Barcode Scanner, Google Analytics und Google Play Services. Eine erweiterte Hardwareintegration kann darüber hergestellt werden.

  • Online-Build: Die App-Packages können direkt online aus einem Repository erstellt werden. Das funktioniert auch für iOS. Dafür sind weder Xcode noch macOS notwendig. Die Einstiegshürde für das Erstellen von Apps für iOS ist niedrig.

  • Effizienter Entwicklungszyklus: bestehend aus Developer-App, Online-Playground und leistungsfähigem CLI.

  • Native Apps: Es entstehen native Apps, deren User Interface nicht in einem WebView-Container läuft.

  • Sicherheit: Zur Erhöhung der Datensicherheit sensibler Kundendaten gibt es integrierte Features, zum Beispiel bei Apps für den medizinischen Bereich oder für Finanzdienstleistungen. Hier wurde Tabris.js erfolgreich eingesetzt.

Tabris.js richtet sich damit an Entwickler, die mit Webtechnologien, insbesondere JavaScript und TypeScript vertraut sind, aber dennoch eine native App erstellen möchten. Der Entwicklungszyklus ist leichtgewichtig.

Eine App mit RAD Studio und FireMonkey

RAD Studio haben wir bereits in der letzten Ausgabe kurz vorgestellt [9]. Jetzt geht es darum, den Ablauf bei der App-Entwicklung nachzuvollziehen. Alle für die Entwicklung notwendigen Systemkomponenten kann man auf einem Gerät unterbringen, wenn man mit Virtualisierung auf einem Mac arbeitet. Auf dem Mac installieren wir zunächst eine Virtualisierungsumgebung. Apple empfiehlt hier Parallels. Die Virtualisierung ist auch mit Virtual Box möglich. Selbstverständlich können Sie auch auf einem Windows-PC arbeiten. Für iOS-Apps ist dann ein zusätzlicher Mac im lokalen Netzwerk einzubinden (Abb. 6).

Abb. 6: Systemkonfiguration (Vorschlag) zur Arbeit mit RAD Studio

Abb. 6: Systemkonfiguration (Vorschlag) zur Arbeit mit RAD Studio

Um Apps für Android zu erstellen, gibt es keine Systemeinschränkungen. Installieren Sie dann RAD Studio (Delphi) unter Windows 10. Um Apps für iOS zu bauen und diese auf dem Mac zu testen, sind noch einige wenige Schritte notwendig. Wechseln Sie zu macOS und installieren Sie den PAServer. Dazu laden Sie die aktuelle Version herunter [10]. Starten Sie die Installation. Höchstwahrscheinlich müssen Sie die Berechtigungen im Dialogfeld Sicherheit unter macOS dazu erteilen. Der PAServer läuft im Hintergrund als Konsolenapplikation. Installieren Sie ebenso XCode, sofern Sie die Entwicklungsumgebung noch nicht auf dem Rechner haben. Starten Sie nun den PAServer unter macOS. Diesen können Sie über den Finder als Konsolen-App aufrufen (Abb. 7).

Abb. 7: Der PAServer sorgt für eine Steuerung des Mac durch einen externen Rechner

Abb. 7: Der PAServer sorgt für eine Steuerung des Mac durch einen externen Rechner

Im Terminal müssen Sie den Start mit Enter bestätigen. Sie erhalten eine Information über den Erfolg. Notieren Sie sich bitte Ihre lokale IP-Adresse unter macOS. In RAD Studio startet die App-Entwicklung mit der Projektvorlage Geräteübergreifende Anwendung. Mit Hilfe des grafischen Designers gestaltet man das User Interface vollständig. Über den Eigenschafteneditor werden die Eigenschaften der Steuerelemente (Platzierung, Texte, Größen usw.) konfiguriert. Es ist nicht vorgesehen, das User Interface im Quellcode manuell nachzubearbeiten. Der Ansatz von RAD Studio und dem Framework FireMonkey basiert darauf, dass das User Interface auf der Basis von Komponenten automatisch in die jeweilige Zielumgebung während des Übersetzungsvorgangs gebracht wird (Abb. 8).

Abb. 8: Das UI wird vollständig im grafischen Designer erstellt

Abb. 8: Das UI wird vollständig im grafischen Designer erstellt

Um eine App für das Zielsystem zu erstellen, sind nur wenige Schritte notwendig:

  1. Aktivieren Sie in der Projektverwaltung unterhalb des Knotens Zielplattformen den Zweig iOS-Simulator. Sie müssen jetzt die Verbindung zum Mac herstellen. Verwenden Sie dazu den Eintrag Verbindung bearbeiten. Sie müssen den Hostnamen, d. h. Ihre IP-Adresse eingeben. Die Portnummer ist vorgegeben und sollte passen. Mit Verbindung testen  können Sie sich vom Erfolg dieser Maßnahme überzeugen.

  2. Aktualisieren Sie die Projektverwaltung und klicken Sie sich durch die Ordnerstruktur zu Zielplattformen | iOS-Simulator | Ziel (Abb. 9). Wählen Sie zum Beispiel iPhone 6s und starten Sie Ihre App von Delphi aus. Sofern das alles funktioniert, wirft Ihnen RAD Studio eine Meldung über das erfolgreiche Bereitstellen der App aus.

  3. Dann können Sie zu macOS und dem Simulator wechseln und die App nutzen.

Der Ansatz von RAD Studio basiert darauf, durch den Einsatz von Komponenten den Entwicklungsprozess möglichst effizient zu gestalten. Das betrifft gerade den sehr aufwendigen Vorgang zur Gestaltung des User Interface für die unterschiedlichsten Systeme, im Falle von mobilen Apps für Android und iOS. Die plattformspezifische Umsetzung wird automatisch vorgenommen. Am Beispiel eines Tab-Interface kann man das gut erproben (TTabControl). Unter iOS werden bekanntermaßen die Reiter für die Tabnavigation am unteren Rand und bei Android am oberen Rand des Screens angezeigt. Das wird auch so umgesetzt, sofern man die Einstellung TabControl.TabPosition auf dem Wert PlatformDefault belässt. Alternativ kann man diese Standardeinstellung umgehen, indem man explizit fordert, dass die Navigationsleiste stets unabhängig von der Plattform am oberen oder unteren Rand angezeigt wird. Das kann sinnvoll sein, wenn man das Aussehen der App für alle Geräte und Plattformen möglichst gleichmäßig gestalten möchte.

Abb. 9: Zielplattformen hinzufügen: hier iOS

Abb. 9: Zielplattformen hinzufügen: hier iOS

RAD Studio und FireMonkey sind geeignete Werkzeuge für das Erstellen von mobilen Apps, wenn man auf die folgenden Features besonderen Wert legt:

  • Native App: Es entstehen native Apps für die Systeme Android und iOS.

  • Geräte- und plattformübergreifende Entwicklung: Neben den Apps für iOS und Android sollen auch Applikationen für andere Systeme (Windows, Linux und macOS) aus einer gemeinsamen Quellcodebasis erstellt werden.

  • Drag-and-drop-UI-Erstellung: Das User Interface kann vollständig im grafischen Designer erstellt werden.

  • Komponentenbasiert: Es stehen Komponenten für typische Aufgaben der App-Entwicklung zur Verfügung, zum Beispiel für die Anbindung von Backend Services und zur Unterstützung von Sensoren wie Kamera und Bluetooth.

  • Vorlagen und Templates für typische Szenarien: Typische Aufgaben der App-Entwicklung, wie zum Beispiel die Einbindung einer Kartendarstellung oder die Interaktion mit der Kamera inklusive der Weiterverarbeitung der Bilddatei, können auf dem Wege der Konfiguration erledigt werden. Das minimiert den Aufwand zum Schreiben von Quellcode.

RAD Studio und FireMonkey richten sich insbesondere an App-Entwickler, die Erfahrungen im Erstellen von Desktopapplikationen haben und den typischen Entwicklungszyklus beibehalten möchten. Programmiert wird in den Sprachen Delphi bzw. C++.

Fazit und Ausblick

Wir haben uns drei Wege zum Erstellen nativer Apps für Android und iOS in der Praxis bzw. anhand praktischer Beispiele angesehen. Erfreulicherweise hat man als Entwicklerin oder Entwickler die Qual der Wahl (siehe auch den letzten Teil der Serie mit weiteren Ansätzen). Die Vorgehensweisen kommen sehr unterschiedlich daher. Das ist positiv, so kann man sich als Entwickler den jeweils passenden Weg heraussuchen. Alle drei Vorgehensweisen sind ausgereift und die meisten Herausforderungen wird man mit jedem der vorgestellten Ansätze bewältigen können. Probieren Sie in diesem Sinn ruhig einmal etwas Neues aus. Man muss nicht mehr zwingend in Swift, Java und Xcode bzw. Android Studio von Hand programmieren, um eine App zu erstellen. Cross-Platform-Programmierung für die mobilen Systeme funktioniert heute auf hohem Niveau und liefert produktionsreife Ergebnisse.

In der kommenden Ausgabe beschäftigen wir uns im Rahmen dieser Serie mit der Cross-Platform-Programmierung für Desktopsysteme.

Weitere Informationen zu diesen und anderen Themen der IT finden Sie unter http://larinet.com.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Hinterlasse einen Kommentar

Hinterlasse den ersten Kommentar!

avatar
400
  Subscribe  
Benachrichtige mich zu:
X
- Gib Deinen Standort ein -
- or -