Author: Dr. Veikko Krypczyk; Olena Bochkor
Date: 2018-07-11T23:00:00+00:00
Keywords: RAD Studio; Delphi; C++; Cross-Platform; Plattformübergreifende Entwicklung; Geräteübergreifende Entwicklung; App-Entwicklung; Android; ios
Description: Olena Bochkor und Dr. Veikko Krypczyk stellen die geräteübergreifende Entwicklung mit RAD Studio vor. Nach einer Einführung in die Thematik und die Entwicklungsumgebung werden verschiedene Anwendungsfälle mit einfachen Beispielen erläutert.
Publisher: entwickler.press
Rights: © 2018 entwickler.press. Alle Rechte, auch für Übersetzungen, sind vorbehalten. Reproduktion jeglicher Art (Fotokopie, Nachdruck, Mikrofilm, Erfassung auf elektronischen Datenträgern oder andere Verfahren) nur mit schriftlicher Genehmigung des Verlags. Jegliche Haftung für die Richtigkeit des gesamten Werks, kann, trotz sorgfältiger Prüfung durch Autor und Verlag, nicht übernommen werden. Die im Buch genannten Produkte, Warenzeichen und Firmennamen sind in der Regel durch deren Inhaber geschützt.

Olena Bochkor, Dr. Veikko Krypczyk

Geräteübergreifende Entwicklung mit RAD Studio

ISBN: 978-3-86802-843-0

© 2018 entwickler.press

Ein Imprint der Software & Support Media GmbH

1 Einleitung

Getrieben durch die intensive Nutzung mobiler Computertechnologie wie Smartphones und Tablets haben wir es heute mit einer großen Vielfalt an Geräten und Plattformen zu tun. Im Bereich von Desktopapplikationen wird nach wie vor meist Microsoft Windows eingesetzt. Dabei findet man nicht nur Windows 10 auf den Geräten, sondern oft werden noch die Vorversionen Windows 7 und Windows 8 verwendet. Für spezielle Aufgaben wie zum Beispiel Grafik- und Bildbearbeitung setzen viele Anwender dagegen macOS ein. Im Bereich Mobile Computing teilen sich Android und iOS die Marktanteile. Auch hier haben wir es mit unterschiedlichen Versionen der beiden Betriebssysteme zu tun, bei Android darüber hinaus mit einer unüberschaubaren Anzahl von Geräten.

1.1 Kundenanforderungen

Diese Geräte- und Systemvielfalt ermöglicht es Anwendern, auf der Hard- und Softwareplattform ihrer Wahl zu arbeiten. Briefe werden auf dem Desktop-PC unter Windows geschrieben, die E-Mail wird auf einem Smartphone unter Android beantwortet und die letzten Urlaubsfotos werden auf einem iPad betrachtet.

Aus Sicht der Softwareentwicklung stellt diese Vielfalt an Geräten und Systemen jedoch eine erhebliche Herausforderung dar. Webapplikationen können einen Ausweg bieten. Voraussetzung: Die damit bestehenden Möglichkeiten genügen, um beispielsweise auf die Hardware des jeweiligen Geräts zuzugreifen und es werden keine großen Ansprüche an die Performance gestellt. Um jedoch native Applikationen zu erstellen, muss man sich intensiv mit der Vorgehensweise für jede einzelne Systemumgebung auseinandersetzen. Programmiersprachen, Entwicklungsumgebungen, Vorgehensweisen und Bibliotheken unterscheiden sich erheblich von System zu System. Für den einzelnen Entwickler ist es kaum möglich, auf allen Systemen gleichermaßen fit zu sein. Weiterhin ist es sehr aufwendig, ein Programm für unterschiedliche Systeme umzusetzen. Das würde bedeuten, dass man es für jede Systemumgebung nahezu komplett implementieren muss. Das ist zeit- und kostenintensiv!

Einen Ausweg stellt die geräte- bzw. plattformübergreifende Programmierung dar. Dabei spricht man von einer geräteübergreifenden Programmentwicklung, wenn man Hardware aus unterschiedlichen Geräteklassen adressiert, d. h. zum Beispiel einen Desktoprechner und ein Smartphone. Mit Plattformen sind heterogene Systemumgebungen wie etwa Android und iOS auf mobilen Geräten oder Windows und macOS auf dem Desktop gemeint.

Nach einer kurzen Einführung in die geräte- und plattformübergreifende Programmierung geht es um die Entwicklung derartiger Anwendungen mithilfe von RAD Studio.

1.2 Geräte- und plattformübergreifende Anwendungen

In diesem Abschnitt betrachten wir beispielhaft einige Möglichkeiten, um geräte- bzw. plattformübergreifende Anwendungen zu erstellen. Das Ziel ist dabei immer gleich: Aus einer einheitlichen Codebasis sollen Anwendungen für alle Zielplattformen entstehen. Mit anderen Worten: „Write once, run anywhere“.

Ebenso wichtig ist es, dass sich die Applikationen möglichst gut in die Zielsysteme integrieren. Die Anwendungen dürfen dabei nicht wie Fremdkörper wirken. Wie kann es dazu kommen? Die Ursachen liegen i. d. R. im unterschiedlichen Aufbau der Benutzeroberflächen. Die Betriebssysteme unterscheiden sich hier in vielen Punkten, u. a. im Design und der Art und Weise der Bedienung. Die Anwendungen sehen zwar auf allen Systemen vergleichbar aus, passen aber nicht zu den Vorgaben der Zielplattform. Die Nutzer haben dann möglicherweise Probleme, die App zu bedienen, bzw. das Design der Anwendung gefällt ihnen nicht, da sie etwas anderes erwartet haben. Moderne Ansätze müssen also die Besonderheiten der jeweiligen Systemumgebung berücksichtigen.

Es gibt unterschiedliche Vorgehensweisen, um Applikationen zu erstellen, die auf mehreren Systemen laufen, u. a.:

- Java als Laufzeitumgebung

- User Interface für Cross-Plattform-Umgebungen mit Qt

- Webapplikationen auf Basis von HTML5, CSS3 und JavaScript

- Hybride Apps für mobile Geräte

- Native Apps für mobile Geräte mit Xamarin

- Native Applikationen für Desktop- und mobile Geräte mit RAD Studio

Beachten Sie, dass diese Aufzählung nicht vollständig ist. Gerade im Bereich der Webapplikationen finden im Moment sehr vielfältige Innovationen statt. Sie sehen, die technischen Ansätze sind sehr unterschiedlich. Ein wichtiges Unterscheidungsmerkmal besteht u. a. darin, ob eine native Applikation entsteht oder ob der Code erst zur Laufzeit auf der jeweiligen Plattform übersetzt wird. Native Anwendungen sind performanter und können die Stärken der Zielplattform besser ausnutzen. Das User Interface entspricht dabei i. d. R. auch den Vorgaben des jeweiligen Zielsystems.

Dieses E-Book stellt Möglichkeiten vor, mit der integrierten Entwicklungsumgebung Embarcadero RAD Studio geräteübergreifende Anwendungen für alle wichtigen Zielsysteme zu erstellen. Das folgende Kapitel gibt zunächst einen kompakten Überblick über RAD Studio und durchleuchtet den damit verbundenen Entwicklungsprozess.

2 RAD Studio

RAD Studio ist nicht neu. Die Entwicklungsumgebung hat Tradition und ist wohl besser unter den Namen Delphi bzw. C++Builder bekannt. Eine grafische Visualisierung der Versionshistorie sehen Sie in Abbildung 2.1. Aktuell ist im Moment die Version RAD Studio 10.2.3 mit der Bezeichnung Tokyo.

Abbildung 2.1: Versionshistorie von RAD Studio (Delphi)

RAD Studio umfasst die Produkte Delphi und C++Builder. Die Entwicklungsumgebung und die Möglichkeiten der beider Hauptprodukte sind nahezu identisch, lediglich die Programmiersprachen unterscheiden sich. In Delphi arbeiten Sie mit der gleichnamigen Programmiersprache, die eine erweiterte Version von Object Pascal ist. Im C++Builder wird mit der Sprache C++ programmiert. RAD steht dabei als Abkürzung für Rapid Application Development, das Ziel ist also eine beschleunigte Anwendungsentwicklung. Der Applikationsrahmen wird dabei aus visuellen und nichtvisuellen Komponenten mithilfe eines grafischen Designers zusammengesetzt. Visuelle Komponenten sind beispielsweise die typischen Elemente der Benutzeroberfläche wie Buttons, Labels, Textfelder usw. Nichtvisuelle Elemente unterstützen den Entwickler bei alltäglichen Programmieraufgaben, zum Beispiel bei Komponenten für Datei- oder Datenbankzugriffe.

Mit RAD Studio können Sie Applikationen für die unterschiedlichsten Systeme erstellen (Abb. 2.2), konkret sind das:

Abbildung 2.2: Zielsysteme von RAD Studio

- Microsoft Windows: Anwendungen für den Desktop und den Server. Wichtig: Es entstehen native Windows 32-/64-Bit-Anwendungen, die keine weiteren Abhängigkeiten zu externen Bibliotheken wie dem .NET Framework aufweisen. Damit sind diese Anwendungen auch auf älteren Windows-Versionen lauffähig. Es entstehen Desktopanwendungen, keine Apps für die Universal Windows Platform. RAD Studio bietet jedoch ein integriertes Tool, um APPX-Packages zu erstellen, damit man diese Anwendungen über den Microsoft Store verteilen kann.

- macOS/iOS: Apps für den Desktop und mobile Geräte, d. h. iPhone und iPad. Folgende macOS-Versionen werden aktuell unterstützt: OS X 10.10 Yosemite, OS X 10.11 El Capitan, macOS 10.12 Sierra und macOS 10.13 High Sierra. Für iPhone und iPad sind es iOS 9, iOS 10 und iOS 11.

- Android: Apps für die mobilen Geräte wie Smartphones und Tablets. Beachten Sie hierzu die Einschränkung zu den geeigneten Android-Geräten (Kasten: „Geeignete Android-Geräte“).

- Linux: Es entstehen Serverapplikationen, d. h. Anwendungen ohne ein grafisches User Interface. Mit einer externen Erweiterung sind auch Linux-Anwendungen für den Desktop möglich, wir kommen später noch einmal darauf zurück.

Geeignete Android-Geräte

Um mit RAD Studio erstellte Apps auf Android-Geräten auszuführen, müssen die Geräte besondere technische Voraussetzung erfüllen. RAD Studio kompiliert nur Maschinencode für Geräte mit folgenden Hardwarevoraussetzungen:[1] CPU der ARM-Cortex-A-Serie, ARMv7-Anweisungen, NEON-Technologie und GPU. Die NEON-Technologie dient zum Beschleunigen von Multimediaanwendungen, insbesondere von Grafik. Wie stellt man fest, ob ein betreffendes Gerät diese Voraussetzungen erfüllt? Man installiert die kostenfreie App SysCheck (Abb. 2.3) aus dem Play Store. Nach deren Start werden u. a. der Prozessortyp und das Vorhandensein der NEON-Technologie angezeigt. Ein Trost: Aktuelle Android-Geräte erfüllen diese Voraussetzungen nahezu alle. Dennoch ist beim Deployment für die Kunden auf diese Voraussetzung unbedingt hinzuweisen, um keine unnötigen Reklamationen zu erhalten.

Abbildung 2.3: Voraussetzungen unter Android prüfen mit der App SysCheck

Bitte beachten Sie bereits jetzt, dass Sie für die Programmierung von Apps für macOS und iOS zwingend einen Mac brauchen. Wir kommen bei der Einrichtung des Systems für die geräteübergreifende Programmierung nochmals darauf zurück.

2.1 Installation

Um RAD Studio zu testen, laden Sie sich am einfachsten die Testversion der Architect Edition von der Webseite des Herstellers[2] herunter. Ebenso werden im Versionsumfang eingeschränkte, dauerhaft kostenfreie Editionen angeboten. Dazu muss man die aktuellen Angebote prüfen. Nach dem Download erfolgt die Installation, der Assistent bietet dazu einige Optionen. Sie können zwischen den Programmiersprachen Delphi und C++ wählen. Für Windows haben Sie zusätzlich die Auswahl zwischen der 32- und der 64-Bit-Variante. Für die plattformübergreifende Programmierung sind ergänzend – je nach Wunsch – Installationsdateien für OS X, iOS und Android auszuwählen (Abb. 2.4).

Abbildung 2.4: Auswahl der Zielplattformen bei der Installation von RAD Studio

Entwickler, die bereits Apps für Android programmiert haben, wissen, dass man dafür noch weitere Systembibliotheken und Tools, wie zum Beispiel einen Emulator, benötigt. Im nächsten Dialogfeld können Sie die aktuellen Versionen des Android SDK und das Java Development Kit (JDK) installieren (Abb. 2.5).

Abbildung 2.5: Ebenso sollten das Android SDK und das JDK installiert werden

Es empfiehlt sich auch, die Beispielprojekte (Samples) zu installieren. Nach der Bestätigung startet die Installation, die je nach Geschwindigkeit der Internetverbindung eine Weile dauert. Zeit für einen Kaffee!

2.2 RAD Studio in der Übersicht

Nach der Installation kann man RAD Studio starten. Die Entwicklungsumgebung präsentiert sich im üblichen Stil (Abb. 2.6), d. h. mit einer Vielzahl von konfigurierbaren, platzierbaren Fenstern.

Abbildung 2.6: Die integrierte Entwicklungsumgebung RAD Studio

Wir sehen eine Tool-Palette für die visuellen und nichtvisuellen Komponenten, die Projektverwaltung und den Objektinspektor zum Festlegen der einzelnen Eigenschaften und Ereignisse der Komponenten. Der mittlere Bereich dient dazu, den Quellcode zu erfassen und zu editieren. Ist man mit der Arbeitsweise anderer Entwicklungsumgebungen vertraut, wird man sich hier nach etwas Gewöhnungszeit schnell zurechtfinden. Anpassungen sind über den Menüpunkt Ansicht möglich. Welche Fenster sinnvoll sind, ergibt sich während der laufenden Arbeit. RAD Studio erlaubt es, mehrere Layouts zu verwalten – voreingestellt sind beispielsweise die Layouts Standard und Debug.

Ein besonderes Merkmal von RAD Studio besteht in der leichten Anbindung von Datenbanken. Dazu stehen leistungsfähige Datenbankprovider zur Verfügung. In diesem E-Book wird darauf nicht explizit eingegangen, da der Schwerpunkt auf dem Erstellen von Applikationen für unterschiedliche Plattformen liegt.

Mit der grundsätzlichen Arbeitsweise macht man sich am besten mithilfe eines kleineren Beispiels vertraut. Dieses werden wir im kommenden Abschnitt angehen.

2.3 Ein erster Test

In diesem Abschnitt werden wir uns mit der Arbeitsweise von RAD Studio vertraut machen. Dabei geht es darum, die folgenden Schritte nachzuvollziehen:

1. Anlegen eines neuen Projekts
2. Verstehen der Projektstruktur
3. Gestaltung der Benutzeroberfläche
4. Programmierung der Geschäftslogik

5. Debuggen und Start in der Entwicklungsumgebung

2.3.1 Anlegen eines neuen Projekts

Über den Assistenten starten wir die Arbeit an einem neuen Projekt. Dieser wird über den Menüpunkt Datei | Neu aufgerufen. Einige Projekttypen (VCL-Formularanwendung, Geräteübergreifende Anwendung) werden Ihnen direkt im Menü angezeigt (Abb. 2.7).

Abbildung 2.7: Anlegen eines neuen Projektes über „Datei | Neu“

Erweiterte Optionen bieten sich, wenn wir den Eintrag Weitere… aus dem Menü Datei | Neu wählen. Hier haben Sie die Auswahl zwischen allen möglichen Projekttypen, die mit der installierten RAD-Studio-Version möglich sind (Abb. 2.8).

Abbildung 2.8: Dialogfeld zur Auswahl eines Projekttyps

Unter dem Eintrag Delphi-Projekte werden uns in diesem E-Book besonders Geräteübergreifende Projekte interessieren.

2.3.2 Verstehen der Projektstruktur

RAD Studio arbeitet mit einer hierarchischen Projektstruktur. Dabei ist es möglich, dass mehrere Projekte zu einer Projektgruppe zusammengefasst werden. Über die Projektverwaltung (Ansicht | Tool-Fenster | Projektverwaltung) können Sie sich jederzeit die Struktur Ihres Projekts ansehen (Abb. 2.9).

Abbildung 2.9: Projektverwaltung in RAD Studio

Betrachten wir das am konkreten Beispiel: Die Projektgruppe (ProjectGroup1) enthält zwei Projekte (Project1 und Project2); beide sind in diesem Fall geräteübergreifende Projekte. Unterhalb eines Projektknotens haben wir nach dem Anlegen eines Projekts die Einträge Build-Konfiguration, Zielplattformen und zum Beispiel Unit1.pas. Unter Build-Konfigurationen können wir zwischen Debug und Release umschalten und über das Kontextmenü entsprechende Einstellungen vornehmen bzw. ein Kompilieren der Anwendung veranlassen. Die aktive Konfiguration (hier Debug) ist fett dargestellt.

Unterhalb des Knotens Zielplattformen findet wir alle Zielplattformen, für die die laufende Anwendung (Projekt) erstellt werden kann. Im Beispiel sind das zunächst nur 32- und 64-Bit-Windows. Weitere Plattformen (Android, iOS) können wir hier ergänzen, sofern wir diese bei der Installation von RAD Studio mit eingerichtet haben. Die aktive Plattform wird erneut mit Fettdruck gekennzeichnet.

Der Programmcode (Delphi) wird in Units organisiert. Der Projektassistent hat bereits für jedes Projekt eine (Unit1.pas, Unit2.pas) angelegt. Für Formulare wird einer Unit noch zusätzlich eine *.fmx-Datei zugeordnet. Diese enthält die Einträge des Designers zum betreffenden Formular und ist i. d. R. nicht manuell zu editieren. Weiterer Programmcode wird über neue Units hinzugefügt. Dabei ist es natürlich möglich und üblich, die Units in Ordnerstrukturen zu organisieren.

2.3.3 Gestaltung der Benutzeroberfläche

Ein besonderes Leistungsmerkmal von RAD Studio besteht darin, dass man die Benutzeroberfläche vollständig im integrierten grafischen Designer erstellen kann. Es ist daher nicht vorgesehen, dass der Entwickler die von RAD Studio generierten Dateien zur Beschreibung der Formulare manuell editiert. Dadurch wird die Entwicklung beschleunigt. Der Designer kommt auch zum Einsatz, wenn man geräteübergreifende Anwendungen erstellt. Die Benutzeroberfläche wird dabei aus visuellen Steuerelementen, auch als Controls bezeichnet, zusammengesetzt. Diese Controls kapseln die typischen Elemente der Oberfläche, wie zum Beispiel Buttons, Textfelder, Menüelemente, Listen, Radio-Buttons oder Auswahlfelder.

RAD Studio bringt bereits eine umfassende Auswahl an Controls mit, die nach Kategorien sortiert in der Tool-Palette angeordnet sind (Abb. 2.10).

Abbildung 2.10: Controls für die Gestaltung der grafischen Benutzeroberfläche, hier die Registerkarten „Standard“ und „Zusätzlich“

Die Auswahl an Komponenten können Sie durch externe Bibliotheken erweitern. Im Internet finden sich dazu entsprechende Sammlungen (Packages) von visuellen und nichtvisuellen Steuerelementen von Drittanbietern, die kostenfrei oder kostenpflichtig angeboten werden. Direkt aus RAD Studio kann man dazu den GetIt-Package-Manager aufrufen.

Über diesen können u. a. Erweiterungen zu RAD Studio und auch Sammlungen von Bibliotheken gesucht, installiert und verwaltet werden. Den GetIt-Package-Manager rufen Sie über den Menüpunkt Tools | GetIt-Package-Manager… auf. Im Dialogfeld (Abb. 2.11) kann man nach Kategorien und Lizenzarten (kostenfrei, kommerziell) filtern.

Abbildung 2.11: Der GetIt-Package-Manager ist ein Marktplatz für Controls und Erweiterungen von RAD Studio

Grundsätzlich bietet RAD Studio zwei alternative Bibliotheken für das Erstellen des User Interface von Applikationen:

- Visual Component Library (VCL): Hierbei handelt es sich um die seit den Anfängen von Delphi integrierte Bibliothek zum Erstellen von Anwendungen mit grafischer Benutzeroberfläche. Achtung: Programme auf Basis der VCL laufen standardmäßig zunächst nur unter Microsoft Windows[3]. Sofern Sie vorhaben, lediglich eine Desktopanwendung zu erstellen, können Sie ein neues Projekt auf Basis der VCL anlegen. Ältere, in früheren Versionen von Delphi erstellte Anwendungen basieren grundsätzlich auf der VCL. Die VCL wird jedoch weiterhin von Embarcadero gepflegt, sodass sich auch damit Anwendungen mit einer modernen und benutzerfreundlichen Oberfläche erstellen lassen. Dazu dienen besonders die Steuerelemente aus der Registerkarte Windows 10 (Abb. 2.12). Hier stehen Elemente zur Verfügung, die im Design den typischen neuen Elementen von Apps für die Universal Windows Platform (UWP) unter Windows 10 nachempfunden wurden. Damit können klassische Desktopapplikationen mit dem Look and Feel einer Windows-10-App ausgestattet werden.

Hinweis: Mit RAD Studio werden keine Apps für die UWP erstellt, sondern Windows-Anwendungen für den Desktop generiert.

Abbildung 2.12: Die Elemente aus der Registerkarte Windows 10 sorgen für ein App-Feeling in klassischen Windows-Anwendungen

- FireMonkey: Hierbei handelt es sich um die eine Grafikbibliothek zum Erstellen von plattformübergreifenden Anwendungen. Sie agiert als Zwischenschicht zwischen dem Programmcode (Delphi bzw. C++) und rendert native Applikationen für die jeweiligen Zielsysteme. Dabei werden die o. g. Betriebssysteme, d. h. Microsoft Windows, macOS, iOS und Android, direkt aus RAD Studio unterstützt. Es existiert auch eine Umsetzung für Linux[4], somit kann man mit RAD Studio alle wesentlichen Plattformen für den Desktop und die mobile Nutzung erreichen. Unsere plattformübergreifenden Applikationen werden wir also stets auf der Basis von FireMonkey erstellen.

Gleichgültig, welche Grafikbibliothek Sie zur Erstellung der Benutzeroberfläche verwenden, die Vorgehensweisen ähneln sich. Nach dem Platzieren der Controls auf der Oberfläche und deren Anordnung (Layout), passt man für jedes Control im Objektinspektor die Eigenschaften (Abb. 2.13) an.

Abbildung 2.13: Im Objektinspektor werden die Eigenschaften für die Steuerelemente eingestellt

Für den Button im Beispiel sind zum Beispiel insbesondere die folgenden Eigenschaften von Relevanz:

- Caption: Beschriftung
- Height: Höhe in Pixel (absolut)
- Width: Breite in Pixel (absolut)

- Style: Darstellung des Buttons: klassisch, Split-Button, Link

- Visible: Sichtbarkeit

Im Objektinspektor kann man ebenso die Registerkarte Ereignisse (Abb. 2.14) aufrufen.

Abbildung 2.14: Die Objekte der Oberfläche verfügen über bestimmte Ereignisse

Ereignisse binden die Elemente der Oberfläche an den Programmcode. Dabei wird ein Ereignis unter bestimmten Voraussetzungen aufgerufen. Das am häufigsten genutzte Ergebnis eines Buttons dürfte das OnClick-Ereignis sein. Es wird ausgelöst, wenn der Nutzer den Button drückt. Typische Ereignisse eines Formulars sind beispielsweise OnCreate (beim Erstellen), OnActivate (beim Aktivieren) oder OnClose (beim Schließen). Darüber kann man festlegen, welcher Programmcode beim Aufrufen oder Schließen des Formulars ausgeführt werden soll. Einen Teil der Benutzerinteraktion steuern Sie damit über Ereignisse.

Eine gute Programmarchitektur entkoppelt möglichst weitgehend die einzelnen Programmschichten voneinander. In diesem Fall die View (Benutzeroberfläche) und die Implementierung der Logik (Model). Um das zu erreichen, kann man die einzelnen Controls der Benutzeroberfläche an die Datenobjekte binden. Ebenso kommt es häufig vor, dass man Controls untereinander über bestimmte Eigenschaften miteinander verbinden möchte. Für diese Szenarien kennt RAD Studio das Konzept der LiveBindings. Der Entwickler kann visuell die Eigenschaften eines Controls binden, ohne Quellcode schreiben zu müssen.

Das sehen wir uns direkt an einem einfachen Beispiel an. Dazu entwerfen wir ein einfaches Formular, um eine Rechnungsadresse und ggf. zusätzlich eine Lieferadresse abfragen zu können (Abb. 2.15).

Abbildung 2.15: Ein Formular zur Adresseingabe

Im Formular kann man im oberen Teil die Rechnungsadresse erfassen. Über die CheckBox kann man angeben, ob man optional eine abweichende Lieferanschrift angeben möchte. Ist das der Fall, dann benötigt man weitere Datenfelder für die Erfassung einer zweiten Adresse. Diese Eingabefelder sollen also nur durch das Programm eingeblendet werden, wenn der Haken in der CheckBox gesetzt ist. Wir wollen das durch die Nutzung eines LiveBindings umsetzen. Selektieren Sie die CheckBox und das Panel mit den Angaben zur Lieferanschrift und wählen Sie über das Kontextmenü den Eintrag Visuell binden… (Abb. 2.16).

Abbildung 2.16: Zwei Steuerelemente können über Eigenschaften gebunden werden

Es wird der LiveBindings-Designer innerhalb von RAD Studio eingeblendet. Beide Steuerelemente erscheinen mit einem Symbol. Mit der Maus können wir nun die Eigenschaft Checked des Elements CheckBox an die Eigenschaft Visible des Panels binden. Fertig!

Im Formular wird ein neues, nichtvisuelles Steuerelement vom Typ BindingList hinzugefügt (Abb. 2.17).

Abbildung 2.17: Über das Steuerelement „BindingList“ können die Bindings verwaltet werden

Hier können Sie die Bindings verwalten, konfigurieren und neue Bindings hinzufügen. Uns genügt dieses eine Binding. Probieren wir es aus. Starten Sie die Anwendung. Sie können nun das Panel inklusive der untergeordneten Steuerelemente mittels der Aktivierung bzw. Deaktivierung der CheckBox ein- und ausblenden, wie ein Blick in Abbildung 2.18 zeigt.

Abbildung 2.18: LiveBinding steuert hier Vorgänge im UI – ohne Code

Mit LiveBindings ist noch mehr möglich, zum Beispiel können Sie auch Eigenschaften von Steuerelementen an Datenquellen binden. Damit können umfassende Aufgaben des Datenaustauschs zwischen Elementen der Benutzeroberfläche und der Datenschicht schneller und ohne Code umgesetzt werden.

2.3.4 Programmierung der Geschäftslogik

Wir hatten bereits zu Beginn dieses E-Books darauf hingewiesen, dass Sie in RAD Studio zwischen den Programmiersprachen Delphi, einer erweiterten Version von Object Pascal, und C++ wählen können. Entwickler, die sich auf eine Programmiersprache festlegen möchten, können direkt zu Delphi oder C++Builder in der jeweilig gewünschten Edition greifen. Kommen wir kurz zum C++Builder: Der C++-Compiler von RAD Studio basiert neben dem klassischen C++-Compiler von Borland auf dem Open-Source-Clang-Compiler, der als Frontend für das LLVM-Compiler-Backend dient. Ausführliche Informationen zu den unterstützen Sprachfeatures findet man im Rad Studio Wiki.[5] Während C++ in einer Vielzahl von Entwicklungswerkzeugen verwendet wird, ist Delphi eine Eigenentwicklung des Herstellers. Einen knappen Überblick über diese Programmiersprache finden Sie im Textkasten „Delphi im Überblick“. Auch gibt es bei Embarcardero online eine vollständige Übersicht über alle Sprachmerkmale.[6]

Delphi im Überblick

Die wichtigsten Merkmale von Delphi sind:

- Spracheinordnung: Delphi ist eine höhere, prozedurale und objektorientierte Programmiersprache. Befehle werden durch Semikolon (;) getrennt. Es findet keine Unterscheidung zwischen Groß- und Kleinschreibung statt. Delphi ist stark typisiert.

- Programmaufbau: Anwendungen werden in Delphi zu Projekten zusammengefasst. Diese bestehen aus dem Hauptprogramm und ggf. weiteren Units.

- Datentypen/Variablen: Wichtige Datentypen sind Integer, Real, String, Char und Boolean. Die Deklaration erfolgt mit Hilfe von var, also zum Beispiel var zahl1:integer. Die Zuweisung erfolgt durch :=, also zum Beispiel zahl1:=3. Für die Typumwandlung steht eine Reihe von Konvertierungsfunktionen zur Verfügung, zum Beispiel IntToStr. Datentypen für Arrays und Mengen sind vorhanden.

- Schleifen: Es gibt die for-Schleife, die while-Schleife und die repeat-until-Schleife. Schleifen können mithilfe von break und continue abgebrochen werden.

- Verzweigungen: Es sind if…then…else-Konstruktionen darstellbar. Ebenso haben wir eine case-Anweisung für die Auswahl aus mehreren Optionen.

- Prozeduren/Funktionen: Pascal ist eine strukturierte Sprache. Jede Prozedur besteht aus dem Schlüsselwort procedure, gefolgt von einem Namen und evtl. einer Parameterliste in runden Klammern. Sind keine Parameter vorhanden, können die Klammern weggelassen werden. Einen Rückgabewert gibt es nicht. Eine Funktion unterscheidet sich nur geringfügig von einer Prozedur. Sie besitzt einen Rückgabewert und wird mit dem Schlüsselwort function deklariert.

- Klassen/Objekte: Die Deklaration einer Klasse erfolgt mit den Schlüsselwörtern type und class, also zum Beispiel: type TMyClass = class…..end. Das übliche Spektrum der objektorientierten Sprachelemente wie Methoden, Felder, Eigenschaften usw. steht zur Verfügung. Ebenso ist eine Vererbung zwischen Klassen möglich.

Grundsätzlich gilt Delphi als nicht komplizierte Sprache. Sie ist dafür bekannt, dass man sie leicht erlernen kann.

Die Geschäfts- bzw. Programmlogik wird in einzelnen Units abgelegt. Sehen wir uns den Aufbau einer Unit in Delphi am Beispiel eines einfachen Formulars mit einem Ereignis, das auf das Drücken des Buttons hin ausgelöst wird, an (Listing 2.1).

unit Unit1;

interface

uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants, FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs;

type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);

private
{ Private-Deklarationen }

public
{ Public-Deklarationen }

end;

var
Form1: TForm1;

implementation

{$R *.fmx}

procedure TForm1.Button1Click(Sender: TObject);
begin
// hier folgt der Code, der beim Drücken
// des Buttons ausgeführt werden soll
end;
end.

Listing 2.1: Aufbau einer Unit

Dazu einige Bemerkungen: Bei Units unterscheidet man einen öffentlichen und einen nichtöffentlichen Programmteil. Eine Unit wird mithilfe des Schlüsselwortes unit eingeleitet. Danach notiert man den Namen der Unit, in diesem Fall Unit1. Es folgt der öffentliche Teil der Unit, der mit dem Schlüsselwort interface beginnt. In diesem Abschnitt erfolgen alle Deklarationen, auf die von anderen Programmteilen aus zugegriffen werden soll. Wichtig: Eine Prozedur wird hier nicht vollständig implementiert, sondern es wird lediglich der Prozedurkopf notiert. Die Implementierung erfolgt im Abschnitt implementation. Dieses ist der nichtöffentliche Teil einer Unit. Variablen, Typen usw., die hier deklariert werden, sind nur innerhalb der Unit sichtbar. Der Abschnitt implementation wird mit dem Schlüsselwort end (und einem Punkt) abgeschlossen. Damit endet auch die gesamte Unit.

Im dargestellten Listing 2.1 gibt es im interface-Teil eine uses-Klausel. Darüber werden die Bibliotheken (andere Units) eingebunden, welche für das Kompilieren der aktuellen Unit notwendig sind. Da es sich hier um ein Formular handelt, sind das neben Basisbibliotheken auch Bibliotheken für die grafische Benutzerschnittstelle. Mit type TForm1 =class (…) wird eine Klasse vom Typ TForm, also einem Formular, deklariert. Von der Prozedur Button1Click(Sender: TObject) wird hier nur der Rumpf notiert. Was genau beim Klicken auf den Button passieren soll, muss man im Abschnitt implementation festlegen. Im Beispiel ist es nur durch einen Kommentar angedeutet.

Und welche Bedeutung hat die Zeile {$R *.fmx}? Damit wird angezeigt, dass zur Unit eine Ressourcendatei gehört, die hier eingebunden wird. Diese Ressourcendatei beinhaltet das Formular, das vollständig im Designer erstellt wird.

Die Logik eines Programms wird in Units aufteilt. Technisch ist es dabei kein Problem, mehrere Klassen in eine Unit zu packen. Aus Gründen der Übersichtlichkeit sollte man jedoch pro Unit i. d. R. nur eine Klasse implementieren.

2.3.5 Programm aus der IDE starten und debuggen

RAD Studio verfügt über einen schnell arbeitenden Compiler. Damit können Programme schnell gestartet und erprobt werden. Mittels des integrierten Debuggers kann man aktiv den Programmablauf überwachen und nach möglichen Laufzeitfehlern suchen. Starten können Sie eine Anwendung mit und ohne aktives Debugging über das Menü Start (Abb. 2.19).

Abbildung 2.19: Der Start der Anwendung erfolgt direkt aus der Entwicklungsumgebung

Im Quellcode haben Sie die Möglichkeit, einen Breakpoint zu setzen (Abb. 2.20). Der Debugger hält dann das laufende Programm an dieser Stelle an und Sie haben beispielsweise die Möglichkeit, den Wert von Variablen bzw. Objekten auszuwerten.

Abbildung 2.20: Breakpoint im Quellcode, um den Debugger an der Stelle zum Halten zu zwingen

1 http://docwiki.embarcadero.com/RADStudio/Tokyo/de/Für_die_Anwendungsentwicklung_unterstützte_Android-Geräte

2 https://www.embarcadero.com/de/products

3 Eine Umsetzung der VCL für macOS und Linux findet man unter https://www.crossvcl.com/

4 https://fmxlinux.com/

5 http://docwiki.embarcadero.com/RADStudio/Tokyo/de/C%2B%2B-Referenz

6 http://docwiki.embarcadero.com/RADStudio/Tokyo/de/Delphi-Sprachreferenz

3 Geräteübergreifende Apps

RAD Studio bietet die Möglichkeit, geräteübergreifende Anwendungen zu erstellen. Solche Anwendungen beschränken sich hier nicht nur auf die mobilen Plattformen Android und iOS, sondern umfassen auch die Betriebssysteme Windows, macOS und Linux (Server). In diesem Kapitel durchlaufen wir dazu alle notwendigen Schritte von der Einrichtung der Systemumgebung über das Anlegen des Projekts, der Gestaltung der Benutzeroberfläche, der Erstellung der Programmlogik, dem Hinzufügen weiterer Plattformen und dem Debuggen der App bis hin zum letztendlichen Starten. Beginnen wir mit der Systemeinrichtung.

3.1 Systemumgebung einrichten

Die Entwicklungsumgebung RAD Studio läuft unter Microsoft Windows. Möchten Sie Anwendungen für weitere Systemumgebungen erstellen, müssen Sie sich über die Konfiguration einige Gedanken machen (Abb. 3.1).

Abbildung 3.1: Systemumgebung für das Erstellen geräteübergreifender Apps

Dazu sind ein paar Erläuterungen angebracht: Im Zentrum steht der Entwicklungsrechner mit Microsoft Windows als Betriebssystem. Dabei kann es sich ggf. auch um eine virtuelle Umgebung auf einem Mac handeln. Einen solchen benötigen Sie auf jeden Fall, wenn Sie Apps für iOS bzw. macOS erstellen möchten. Bei einer Virtualisierung wird RAD Studio in einer virtuellen Maschine ausgeführt, üblicherweise in Parallels unter macOS. Die Entwicklung und das Testen der Apps für Android und iOS erfolgt alternativ mithilfe eines Emulators oder auf einem physischen Gerät. Für Android muss man entscheiden, ob die Ausführungsgeschwindigkeit eines Emulators ausreichend ist. Auch ist zu beachten, dass die Geräte auf denen die Apps laufen sollen, die mit RAD Studio für Android erstellt werden, bestimmte Hardwarevoraussetzungen erfüllen müssen (siehe den Kasten „Geeignete Android-Geräte“ in Kapitel 2) – das gilt natürlich auch für einen Emulator. Android-Emulatoren, die das hardwareunterstützte Virtualisierungsmodul HAXM nutzen und auf einem Android-x86-Emulator-Image basieren, können Sie hier nicht nutzen. Aus diesem Grund wird man also höchstwahrscheinlich zu einem physischen Smartphone bzw. Tablet greifen. Dieses schließen Sie direkt über den USB-Anschluss an den Windows-Entwicklungsrechner an (bzw. bei Nutzung einer virtuellen Maschine an den Mac).

Um Apps für macOS bzw. iOS zu erstellen, müssen Sie vom Entwicklungsrechner über das Netzwerk auf einen Mac zugreifen. Dabei kann es sich um einen Rechner im lokalen Netzwerk oder um einen remoten Rechner handeln, der zum Beispiel über einen Cloud-Dienst[1] bereitgestellt wird. Auf dem Mac muss man die aktuelle Version von Apples integrierter Entwicklungsumgebung Xcode installieren. Xcode benötigen Sie für die Paketierung der Apps. Man kann Xcode aus dem App Store kostenfrei herunterladen. Die Verbindung zwischen Entwicklungsrechner und Mac erfolgt über den sogenannten PAServer (Platform Assistant-Server). Auf dem Mac selbst läuft dann zum Beispiel ein iOS-Simulator, um die erstellten Apps zu testen. Ein iPhone bzw. iPad kann ebenso an den Mac angeschlossen werden, um die Apps auf einem echten mobilen Gerät auszuprobieren.

Nach diesen vorbereitenden Arbeiten an der Systemumgebung können Sie bereits damit beginnen, das erste Projekt zu erstellen. Eine konkrete Konfiguration der Entwicklungsumgebung beschreiben wir im Kasten „Beispielkonfiguration“.

Beispielkonfiguration

Verwenden Sie einen Mac mit ausreichender Leistung.

- Installieren Sie unter macOS eine Virtualisierungsumgebung, zum Beispiel Parallels oder Virtual Box.

- Richten Sie Windows 10 als Gast-OS mit ausreichenden Ressourcen ein. In Virtual Box sind noch die Gasterweiterungen für eine angepasste Darstellung zu installieren.

- Installieren Sie RAD Studio in der virtuellen Maschine auf Windows 10.

- Wechseln Sie zu macOS und installieren Sie den PAServer.[2] Dazu müssen Sie im Dialogfeld Sicherheit unter macOS die Berechtigungen erteilen. Der PAServer läuft im Hintergrund.

- Installieren Sie Xcode. RAD Studio 10.2.3 unterstützt im Moment keinen Simulator des SDK 11.3. Wir müssen daher einen älteren Simulator nachrüsten. Das geht in Xcode über Menü Preferences | Components. Installieren Sie den Simulator aus dem Knoten iOS 10.3.1.

- Starten Sie den PAServer. Diesen können Sie über den Finder als Konsolen-App aufrufen. Im Terminal müssen Sie den Start mit ENTER bestätigen.

- Notieren Sie sich Ihre lokale IP unter macOS.

- Für einen Test erstellen Sie eine Geräteübergreifende Anwendung. Ein leeres Fenster genügt. Aktivieren Sie in der Projektverwaltung unterhalb des Knotens Zielplattformen den Zweig iOS-Simulator. Sie müssen jetzt die Verbindung zum Mac herstellen (Verbindung bearbeiten). Geben Sie die IP-Adresse ein, die Portnummer ist vorgegeben. Mit Verbindung testen… können Sie sich vom Erfolg dieser Maßnahme überzeugen.

- Aktualisieren Sie die Projektverwaltung und klicken Sie sich durch die Ordnerstruktur zu Zielplattformen | iOS-Simulator | Ziel. Wählen Sie zum Beispiel iPhone 6s (iOS 10.3) und starten Sie Ihre App aus Delphi.

Sofern das alles funktioniert, wirft Ihnen RAD Studio eine Meldung über das erfolgreiche Bereitstellen aus. Sie können dann die App im Simulator testen.

3.2 Projektskelett erstellen

Jetzt geht es darum, sich mit der grundsätzlichen Vorgehensweise zum Erstellen einer geräteübergreifenden Anwendung vertraut zu machen. Wir erstellen ein neues Projekt (Datei | Neues Projekt…) und wählen Geräteübergreifende Anwendung (Abb. 3.2).

Abbildung 3.2: Anlegen eines Projekts für eine geräteübergreifende App

Jetzt haben wir die Auswahl aus verschiedenen Projekttypen, u. a. eine Leere Anwendung, Registerkarten und Haupt/Detail. Wir entscheiden uns für einen Projekttyp, zum Beispiel Leere Anwendung, und schließen das Dialogfenster mit OK. Daraufhin fordert RAD Studio uns auf, einen Speicherort auszuwählen und erstellt das Projektskelett für unsere App. Nach wenigen Augenblicken bekommen wir bereits den Designer zu Gesicht (Abb. 3.3).

Abbildung 3.3: Der Projektassistent erstellt den Rahmen für eine geräteübergreifende App

Bereits in Kapitel 2.3.3 haben wir grundsätzlich gezeigt, wie die Benutzeroberfläche in RAD Studio mithilfe des Designers gestaltet wird. Auf einige Besonderheiten für geräteübergreifende Apps gehen wir im kommenden Unterkapitel ein.

Wenn Sie sich jetzt die Projektstruktur ansehen, werden Sie feststellen, dass es den Ordner Zielplattformen gibt. Unterhalb des Ordners werden alle verfügbaren Zielplattformen anzeigt und man kann eine Plattform als aktive Zielplattform auswählen.

3.3 Geräteübergreifende UI-Gestaltung

Kommen wir noch einmal auf die Oberflächengestaltung zurück. Über die Tool-Palette können wir die (visuellen) Steuerelemente zur Platzierung auf den Formularen auswählen. Als Hinweise bekommen wir vor der endgültigen Auswahl angezeigt, ob ein Steuerelement auf der gewünschten Zielplattform zur Verfügung steht (Abb. 3.4).

Abbildung 3.4: Unterstützte Plattformen werden in der Tool-Palette angezeigt

Dazu zwei Beispiele: Einen Button gibt es auf allen Plattformen, dagegen gibt es ein Menu-Control nur auf den Desktopsystemen. Auf mobilen Geräten würde es keinen Sinn ergeben.

RAD Studio bietet ein weiteres Feature, um die Gerätevielfalt besser zu meistern. Unterschiedliche Geräte (Android, iOS) und Geräteklassen (Smartphone, Tablet, Desktop) weisen verschiedene Bildschirmgrößen und Auflösungen auf. Ebenso gibt es bei den mobilen Geräten keine Tastatur oder Maus für umfassende Eingaben. Im Designer gibt es Ansichten für die unterschiedlichen Geräte. Innerhalb dieser Ansichten kann man die Oberflächen spezifisch an die gewählte Gerätekategorie anpassen, beispielsweise, indem man bestimmte Steuerelemente ein- oder ausblendet. Zu Beginn sollte man in der sogenannten Master-Ansicht für die gewählte Plattform beginnen. Auch das sehen wir uns wieder an einem kleinen Beispiel an. Voraussetzung ist, dass Sie eine geräteübergreifende Anwendung erstellt haben. Wir gestalten in der Master-Ansicht abermals die Minimalform einer Dateneingabe für eine Adresse (Abb. 3.5).

Abbildung 3.5: Master-Ansicht zur Gestaltung des UI

Wie sieht das Formular jedoch konkret auf den unterschiedlichen Geräten aus? Beispielsweise auf einem Desktoprechner mit Windows oder auf einem Surface? Dazu können wir von der Master-Ansicht auf Windows Desktop (Abb. 3.6) oder Surface-Pro (Abb. 3.7) wechseln und bekommen einen genaueren Eindruck vom späteren Aussehen des Dialogfelds auf dem konkreten Zielgerät.

Abbildung 3.6: Konkrete Ansicht des Formulars für den Windows-Desktop

Beispielsweise sieht man bei der Darstellung für den Desktop die Titelzeile des Fensters und das Kreuz für das Schließen des Dialogfelds.

Abbildung 3.7: Das gleiche Formular auf einem Surface Pro in der Vorschau

Die Ansicht für das Surface Pro macht schnell deutlich, dass aufgrund der sehr hohen Auflösung des Geräts das Formular eher kleinteilig wirkt.

Man könnte dieses Problem lösen, indem man die Steuerelemente der Oberfläche relativ positioniert und damit eine dynamische Anpassung der Oberfläche zur Laufzeit stattfindet. FireMonkey bietet dazu unterschiedliche Layoutcontainer:

- TLayout: Ein einfacher Container, der zur Laufzeit nicht sichtbar ist. Er kann zur Gruppierung anderer Steuerelemente verwendet werden, die dann gemeinsam geändert werden können. Sie können beispielsweise die Sichtbarkeit einer Gruppe von Steuerelementen gleichzeitig festlegen, indem Sie nur die Eigenschaft Visible des Layouts setzen. TLayout legt keine Eigenschaften der untergeordneten Steuerelemente automatisch fest.

- TScaledLayout: Ein skaliertes Layout ist ein Container, der die Möglichkeit bietet, eine Gruppe von grafischen Objekten gemäß den physischen Abmessungen des Layouts zu skalieren. Die untergeordneten Steuerelemente werden bei Größenänderungen des Layouts ebenfalls vergrößert bzw. verkleinert.

- TScrollBox: Hierbei handelt es sich um ein Layout, das einen Bildlauf ermöglicht.

- TFlowLayout: Die untergeordneten Steuerelemente werden in der Reihenfolge angeordnet und angezeigt, in der sie dem Layout hinzugefügt wurden. Fügen Sie eine TFlowLayoutBreak-Komponente hinzu, damit das nächste Steuerelement in einer neuen Zeile angezeigt werden.

- TGridLayout: Dieser Container ordnet untergeordnete Steuerelemente in einem Gitter mit gleich großen Zellen an.

- TGridPanelLayout: Hiermit werden untergeordnete Steuerelemente ebenfalls in einem Gitter angeordnet. Im Gegensatz zu TGridLayout können Sie in Zellen von TGridPanelLayout platzierte Steuerelemente manuell ausrichten und ihre Größe ändern. Ebenso können sich Steuerelemente über mehrere Zellen erstrecken.

Mit der Funktion Ansicht | Tool-Fenster | Geräteübergreifende Vorschau) bekommen Sie alle Ansichten in einer gemeinsamen Vorschau präsentiert (Abb. 3.8).

Abbildung 3.8: „Geräteübergreifende Vorschau“

3.4 Plattformen hinzufügen

Sofern man bei der Installation von RAD Studio noch nicht die benötigten Zielplattformen (Windows, Linux, macOS, iOS, Android) in Form der notwendigen Systembibliotheken zur Entwicklungsumgebung hinzugefügt hat, kann man das jederzeit unter dem Menüpunkt Tools | Plattformen verwalten… nachholen (Abb. 3.9).

Abbildung 3.9: Weitere mögliche Plattformen kann man über „Tools | Plattformen verwalten …“ hinzufügen

Die möglichen Zielplattformen stehen dann in geräteübergreifenden Projekten zur Auswahl.

1 Vgl. zum Beispiel: https://www.macincloud.com/

2 http://altd.embarcadero.com/releases/studio/19.0/PAServer/Release3/PAServer19.0.pkg

4 App-Besonderheiten

Apps für die mobilen Systeme müssen neben einer ansprechenden Benutzeroberfläche i. d. R. auch auf die unterschiedlichsten Gerätefunktionen und eingebaute Sensoren zurückgreifen. Gerade bei der Programmierung für unterschiedliche Systeme können hier Schwierigkeiten auftreten, denn diese Besonderheiten funktionieren auf jedem System zwar ähnlich, aber im Detail dann doch komplett unterschiedlich. Wie löst man mit RAD Studio diese Herausforderungen? In der Tool-Palette steht dazu eine Auswahl an visuellen und nichtvisuellen Controls zur Verfügung. Diese kann man mittels Drag and Drop in ein Anwendungsformular ziehen. Mittels dieser Komponenten werden die Schnittstellen zu den unterschiedlichen Systemen gekapselt. Man muss dann nur gegen eine systemunabhängige Komponente programmieren, d. h. die Komplexität reduziert sich. In diesem Kapitel gehen wir beispielhaft auf einige dieser Möglichkeiten genauer ein.

4.1 Geoservices

Ein typisches Feature ist die Integration von Geoservices, d. h. das Ermitteln der Positionsdaten und die Darstellung auf einer Karte. Hier gibt es unzählige Anwendungen. Durchlaufen wir beispielhaft die wichtigsten Schritte, um eine geografische Position auf einer Karte abzubilden. Dazu beginnt man am besten wieder mit einem neuen Projekt (Geräteübergreifende Anwendung). Aus den angebotenen Möglichkeiten wählen wir zum Beispiel die Ansicht mit Registerkarten.

Damit wird ein tabbasiertes UI aufgebaut. Daran können wir gleich probieren, wie RAD Studio das umsetzt. Bekanntermaßen werden die Registerkarten (Reiter) bei Apps für iOS am unteren und bei Android am oberen Rand des jeweiligen Screens angezeigt. Als Control wird das TTabControl aus der Tool-Palette verwendet. In einer Registerkarte wollen wir die Karte einblenden. Auch dieses Vorgehen unterscheidet sich zwischen den Systemen iOS und Android. Eine Karte wird durch die TMapView-Komponente gekapselt. Intern wird dabei bei beiden Plattformen auf den jeweiligen hauseigenen Kartendienst (Android: Google Maps, iOS: Apple Maps) zurückgegriffen. Die Android-App muss beim erstmaligen Start die Berechtigung vom Nutzer einholen, um den Kartendienst nutzen zu dürfen. Das kann man in den Projektoptionen (unter Android | Debug) komfortabel konfigurieren (Abb. 4.1).

Abbildung 4.1: Konfiguration der App-Berechtigungen für Android

Ebenso ist für die Nutzung der Google-Maps-Karten ein eigener, App-spezifischer Key erforderlich. Dazu muss man sich in der Google-Developer-Konsole[1] registrieren und den Key generieren. Den Key hinterlegt man ebenso in den Projektoptionen (Abb. 4.2).

Abbildung 4.2: Google-Maps-Key für die Nutzung der Kartendienste speichern

Im Gegensatz dazu ist für iOS ein solcher Key nicht notwendig, d. h. die Karte sollte direkt angezeigt werden. Aktivieren Sie iOS (iOS-Simulator) als Zielplattform und wählen Sie einen Simulator mit einer SDK-Version von 10.3 (vgl. Kasten „Beispielkonfiguration“ in Kapitel 3.1). Erstellen Sie das Projekt neu und starten Sie aus RAD Studio heraus die App auf dem Simulator, das funktioniert mit der Taste F9. Nach wenigen Augenblicken ist die App auf dem virtuellen iPhone installiert. Was sehen Sie? Eine App in mehreren Registerkarten. Eine Registerkarte enthält die Karte, die bereits aktiv ist. Wunderbar, wir haben eine App mit individuellen Registerkarten und einem Kartensteuerelement erstellt, ohne eine einzige Zeile Code zu schreiben.

Wir wollen noch etwas weitermachen. Das Ziel: Einen Marker auf der Karte platzieren. Dazu ist es notwendig, dass wir Code in Delphi schreiben. Aktivieren Sie dazu das Hauptformular (TabbedForm) in der Strukturansicht und schalten Sie von Design auf Code um. Wir erstellen eine Prozedur SetMarker (Listing 4.1), um einen Positionszeiger auf der Karte einzublenden.

procedure SetMarker(myPosition:TMapCoordinate);
var
myMarker:TMapMarkerDescriptor;
begin
myMarker:=TMapMarkerDescriptor.Create(myPosition, 'Hello‘);
myMarker.Visible:=true;
TabbedForm.MapView.AddMarker(myMarker);
end;

Listing 4.1: Platzierung eines Markers auf der Karte

Die Funktionsweise ist schnell erläutert: Wir erzeugen ein Objekt vom Typ TMapMarkerDescriptor (Methode Create in Delphi), setzen die Visible-Eigenschaft auf true (Sichtbarkeit) und fügen den Marker dem MapView-Steuerelement hinzu. Das geht über die AddMarker-Methode. Damit sind wir schon fast fertig. Beim Start der App wird die Prozedur FormCreate durchlaufen. Hier erzeugen wir eine neue Geoposition, bestehend aus den Angaben zu Longitude und Latitude. Danach zentrieren wir die Karte auf diese Position und rufen unsere Methode SetMarker mit der eben definierten Position auf (Listing 4.2).

procedure TTabbedForm.FormCreate(Sender: TObject);
var
myPosition: TMapCoordinate;
begin
...
myPosition:=TMapCoordinate.Create(49.418701, 11.112542);
TabbedForm.MapView.Location:=myPosition;
SetMarker(myPosition);
end;

Listing 4.2: Karte auf eine bestimmte Position zentrieren

Das Ergebnis kann sich für den minimalen Aufwand durchaus schon sehen lassen. Nach dem Start der App wird auf der Karte nun zusätzlich ein Marker platziert (Abb. 4.3).

Abbildung 4.3: Kartensteuerelement in Registerkarte mit Marker an bestimmter Geoposition

Das ist eine coole Sache und die Voraussetzung für die Umsetzung einer Vielzahl von Anforderungen der unterschiedlichsten Apps.

Ebenso kann man die eigene Position automatisch, beispielsweise über den eingebauten GPS-Empfänger, das WLAN oder das Mobilfunknetz, ermitteln. Dazu gibt es das nichtvisuelle Steuerelement TLocationService. Es kapselt die Funktionen zu den unterschiedlichen Hardwareplattformen. Sie finden das Control in der Registerkarte Sensoren. Dort finden Sie auch Controls zur Arbeit mit dem Bewegungssensor (TMotionSensor) oder dem Lagesensor (TOrientationSensor).

4.2 Backend- und Cloud-Services

Apps brauchen Daten und Services. Beides bekommen sie üblicherweise aus der Cloud. Für die App-Besonderheiten haben sich dazu Backend-as-a-Service-(BaaS-)Provider etabliert. Diese bieten typische Dienste wie Datenspeicherung, Benutzerverwaltung, Social-Network-Integration und Push Notification. Alle BaaS-Anbieter funktionieren auf ähnliche Art und Weise. Die Konfiguration erfolgt i. d. R. über ein Dashboard im Browser. Für die Kommunikation werden definierte Schnittstellen, wie zum Beispiel REST, eingesetzt. RAD Studio stellt unter der Registerkarte BAAS Client mehrere nichtvisuelle Controls zur vereinfachten Konfiguration bereit, beispielsweise für den Dienst Kinvey. Um Funktionen wie Benutzerverwaltung oder Datenspeicherung leichter umsetzen zu können, gibt es dafür ebenso nichtvisuelle Steuerelemente (Abb. 4.4).

Abbildung 4.4: Nichtvisuelle Controls erlauben es schnell, ein Backend an die App zu binden

Verwendet man den angebotenen BaaS-Dienst, kommt man damit schnell zum Ziel. Möchte man einen anderen – hier nicht aufgeführten Dienst – verwenden, bleibt nur die Integration über eine generische Schnittstelle, zum Beispiel eine REST API.

Abbildung 4.5: Die Cloud-Steuerelemente kapseln die Kommunikation der Cloud-Dienste von Amazon und Azure

Die Komponenten, die sich unter der Registerkarte Cloud finden lassen (Abb. 4.5), dienen dazu, die Cloud-Services von Amazon und Azure an eine App zu binden. Konkret bieten die beiden Steuerelemente folgende Optionen:

- AmazonAPI: Enthält die Unterstützung für Amazon Simple Queue Service (SQS), Amazon Simple Storage Service (S3) und Amazon SimpleDB Service

- AzureAPI: Über die Dienstklassen werden die Funktionen des Azure-Portals für Mobile Apps bereitgestellt

Bevor man also einen BaaS- bzw. Cloud-Dienst händisch via Webschnittstelle (REST API) an die eigene App bindet, sollte man prüfen, ob man mit den vorhandenen Steuerelementen ans Ziel kommt und damit deutlich effektiver ist.

1 https://console.cloud.google.com/

5 Fazit

RAD Studio in Form von Delphi und C++Builder kann auf eine lange Tradition zurückblicken. Inzwischen werden über die Möglichkeit der geräteübergreifenden Anwendungen alle wichtigen Plattformen und Gerätetypen abgedeckt. Das umfasst sowohl klassische Desktopanwendungen für die unterschiedlichsten Windows-Versionen und macOS als auch Apps für die mobilen Systeme Android und iOS. Ein wichtiges Feature ist, dass jeweils native Applikationen erstellt werden. Das User Interface entwirft man komplett im Designer. RAD Studio erzeugt daraus mithilfe des Grafikframeworks FireMonkey die spezifischen Oberflächen für die Zielsysteme. FireMonkey erlaubt grafisch reichhaltige Oberflächen, die aus visuellen Komponenten zusammengesetzt werden.

Die Programmlogik wird mittels der Sprachen Delphi bzw. C++ realisiert. Für wiederkehrende Aufgaben steht eine Menge nichtvisueller Controls zur Verfügung. Das betrifft sowohl das Umsetzen klassischer Datenbankaufgaben als auch Anforderungen an moderne Apps. Zur letzteren Kategorie gehören u. a. die Verbindung zu Cloud-Diensten und das Ansprechen von spezifischer Hardware wie Bluetooth. RAD Studio hat sich damit zu einem interessanten Werkzeug für die Programmierung von geräte- bzw. plattformübergreifenden Anwendungen entwickelt.

Die Autoren

Olena Bochkor beschäftigt sich mit dem Design von Webseiten und Apps für mobile Geräte.

Dr. Veikko Krypczyk ist Entwickler und Fachautor.

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

Table of Contents

- Impressum

- 1 Einleitung

- 1.1 Kundenanforderungen

- 1.2 Geräte- und plattformübergreifende Anwendungen

- 2 RAD Studio

- 2.1 Installation

- 2.2 RAD Studio in der Übersicht

- 2.3 Ein erster Test

- 2.3.1 Anlegen eines neuen Projekts
- 2.3.2 Verstehen der Projektstruktur
- 2.3.3 Gestaltung der Benutzeroberfläche
- 2.3.4 Programmierung der Geschäftslogik

- 2.3.5 Programm aus der IDE starten und debuggen

- 3 Geräteübergreifende Apps

- 3.1 Systemumgebung einrichten
- 3.2 Projektskelett erstellen
- 3.3 Geräteübergreifende UI-Gestaltung
- 3.4 Plattformen hinzufügen

- 4 App-Besonderheiten

- 4.1 Geoservices

- 4.2 Backend- und Cloud-Services

- 5 Fazit

- Die Autoren