iOS-Tutorials: iOS-Anwendungsentwicklung mit Delphi

Transcription

Product Documentation
RAD Studio
iOS-Tutorials: iOS-Anwendungsentwicklung mit Delphi
Version XE4
© 2013 Embarcadero Technologies, Inc. Embarcadero, the Embarcadero Technologies
logos, and all other Embarcadero Technologies product or service names are
trademarks or registered trademarks of Embarcadero Technologies, Inc. All other
trademarks are property of their respective owners.
Embarcadero Technologies, Inc. is a leading provider of award-winning tools for
application developers and database professionals so they can design systems right,
build them faster and run them better, regardless of their platform or programming
language. Ninety of the Fortune 100 and an active community of more than three
million users worldwide rely on Embarcadero products to increase productivity, reduce
costs, simplify change management and compliance and accelerate innovation. The
company's flagship tools include: Embarcadero® Change Manager™, CodeGear™
RAD Studio, DBArtisan®, Delphi®, ER/Studio®, JBuilder® and Rapid SQL®. Founded in
1993, Embarcadero is headquartered in San Francisco, with offices located around the
world. Embarcadero is online at www.embarcadero.com.
April, 2013
Embarcadero Technologies
2
Contents
iOS-Tutorials: iOS-Anwendungsentwicklung mit Delphi ............................................... 8
Einrichten ........................................................................................................................ 8
Verwenden von grundlegenden Elementen der Benutzeroberfläche ................ 8
Verwenden von Gerätefunktionen ............................................................................ 9
Zugreifen auf Datenbanken ...................................................................................... 10
Siehe auch ................................................................................................................... 10
iOS-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac ................. 11
Voraussetzungen auf dem Mac ............................................................................... 11
Schritte zum Konfigurieren des Mac für die Ausführung einer iOS-Anwendung
auf dem iOS-Simulator ................................................................................................ 11
Schritt 1: Installieren des "Platform Assistant" ....................................................... 12
Schritt 2: Ausführen des "Platform Assistant" ........................................................ 13
Schritt 3: Installieren von Xcode auf dem Mac................................................... 14
Nächste Schritte....................................................................................................... 14
Weitere Schritte zum Konfigurieren des Mac für die Ausführung einer iOSAnwendung auf dem iOS-Simulator ........................................................................ 15
Schritt 1: Installieren der Xcode-Befehlszeilen-Tools auf einem Mac ............... 15
Schritt 2: Anmelden für ein Entwicklerkonto ........................................................ 16
Schritt 3: Anfordern, Herunterladen und Installieren Ihres
Entwicklungszertifikats ............................................................................................. 16
Schritt 4: Registrieren Ihres Geräts für die Bereitstellung .................................... 18
Siehe auch ................................................................................................................... 20
iOS-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Windows-PC ... 21
Konfigurieren der RAD Studio-Umgebung............................................................... 22
Erstellen eines Verbindungsprofils für den Mac .................................................. 22
Hinzufügen eines SDK zu dem Entwicklungssystem für das an den Mac
angeschlossene iOS-Gerät .................................................................................... 24
Siehe auch ................................................................................................................... 25
iOS-Tutorial: Erstellen einer FireMonkey iOS-Anwendung ......................................... 26
Vorbereitungen ........................................................................................................... 26
Schritt 1: Erstellen einer neuen FireMonkey-HD-Anwendung für iOS ................... 26
Schritt 2: Platzieren von Komponenten auf dem FireMonkey-iOS-Formular ...... 27
Schritt 3: Schreiben einer Delphi-Ereignisbehandlungsroutine für einen Klick auf
die Schaltfläche durch den Benutzer ...................................................................... 31
Schritt 4: Testen der iOS-Anwendung auf dem Mac (iOS-Simulator) .................. 32
Schritt 5: Testen der iOS-Anwendung auf einem angeschlossenen iOS-Gerät . 33
Siehe auch ................................................................................................................... 34
iOS-Tutorial: Verwenden von Schaltflächen-Komponenten mit unterschiedlichen
Stilen in iOS-Anwendungen ........................................................................................... 35
Schaltflächen in FireMonkey-Anwendungen für iOS ............................................. 35
Definieren des Aussehens und Verhaltens von Schaltflächen-Komponenten . 36
3
Erstellen von segmentierten Steuerelementen mit Schaltflächen-Komponenten
........................................................................................................................................ 37
Erstellen einer Bereichsleiste (Scope Bar) auf einer Symbolleisten-Komponente
........................................................................................................................................ 39
Siehe auch ................................................................................................................... 39
iOS-Tutorial: Verwenden von Kalender-Komponenten zur Datumsauswahl in iOSAnwendungen ................................................................................................................ 40
Kalender in FireMonkey-iOS-Anwendungen ........................................................... 40
Implementieren einer Ereignisbehandlungsroutine für Datumsänderungen
durch den Benutzer .................................................................................................... 41
Siehe auch ................................................................................................................... 42
iOS-Tutorial: Verwenden von Kombinationsfeld-Komponenten zur Auswahl von
Einträgen in iOS-Anwendungen ................................................................................... 43
Implementieren einer Auswahlkomponente in FireMonkey-iOS-Anwendungen
........................................................................................................................................ 43
Erstellen einer Eintragsliste im Code ......................................................................... 45
Anzeigen eines bestimmten Eintrags ....................................................................... 46
Implementieren einer Ereignisbehandlungsroutine für die Auswahl des
Benutzers ....................................................................................................................... 46
Siehe auch ................................................................................................................... 47
iOS-Tutorial: Verwenden von Webbrowser-Komponenten in iOS-Anwendungen48
Verwenden von Webbrowser-Komponenten in FireMonkey-iOS-Anwendungen
........................................................................................................................................ 48
Schritt 1: Entwerfen der Benutzeroberfläche .......................................................... 48
Schritt 2: Schreiben einer Ereignisbehandlungsroutine zum Öffnen einer
Webseite, wenn der Benutzer den URL im Eingabe-Steuerelement ändert ...... 50
Implementieren einer allgemeinen Methode zum Öffnen einer Webseite ... 51
Implementieren einer Ereignisbehandlungsroutine für das Ereignis
"OnChange" ............................................................................................................. 52
Implementieren einer Ereignisbehandlungsroutine zur Unterstützung der
Eingabetaste ............................................................................................................ 53
Implementieren einer Ereignisbehandlungsroutine für die "Zurück"Schaltfläche ............................................................................................................. 53
Schritt 3: Auswählen der geeigneten Tastatur für die Webbrowser-Anwendung
........................................................................................................................................ 53
Siehe auch ................................................................................................................... 54
iOS-Tutorial: Verwenden von Registerkarten-Komponenten zur Anzeige von
Seiten in iOS-Anwendungen ......................................................................................... 55
Register in FireMonkey-Anwendungen für iOS ....................................................... 55
Entwerfen von Registerkarten im Formular-Designer ............................................. 55
Verwenden von benutzerdefinierten Symbolen für Register ............................... 59
Definieren von Steuerelementen in einem TabControl ........................................ 62
Wechseln der Seite zur Laufzeit ................................................................................. 64
Durch Tippen auf das Register .............................................................................. 64
4
Durch Aktionen und eine Aktionsliste ................................................................... 64
Durch Quellcode ..................................................................................................... 67
Siehe auch ................................................................................................................... 68
iOS-Tutorial: Verwenden von Listenfeld-Komponenten zur Anzeige von
Tabellenansichten in iOS-Anwendungen.................................................................... 69
Erstellen von Elementen für die ListBox-Komponente ............................................ 69
Hinzufügen einer Kopfzeile......................................................................................... 71
Hinzufügen einer Gruppenkopfzeile/-fußzeile zu der Liste .................................... 73
Anzeigen von Listeneinträgen als eigene gruppierte Einträge............................ 74
Hinzufügen eines Kontrollkästchens oder eines anderen Elements zu einem
ListBox-Eintrag............................................................................................................... 75
Hinzufügen eines Symbols zu einem ListBox-Eintrag ............................................... 75
Hinzufügen von Detailinformationen zu einem Eintrag ......................................... 76
Programmseitiges Hinzufügen von Einträgen zu einer ListBox .............................. 77
Hinzufügen eines Suchfeldes ..................................................................................... 78
Siehe auch ................................................................................................................... 79
iOS-Tutorial: Verwenden von Layouts zur Ausrichtung unterschiedlicher
Formulargrößen in iOS-Anwendungen ........................................................................ 80
Jede FireMonkey-Komponente kann einen Besitzer, ein übergeordnetes
Objekt und untergeordnete Objekte haben ......................................................... 80
Verwenden von allgemeinen layoutbezogenen Eigenschaften einer
FireMonkey-Komponente .......................................................................................... 81
Verwenden der Eigenschaft "Align" ..................................................................... 81
Verwenden der Eigenschaft "Margins" ................................................................ 82
Verwenden der Eigenschaft "Padding" ............................................................... 82
Verwenden der Eigenschaft "Anchors" ................................................................ 83
Verwenden der Komponente "TLayout" .................................................................. 84
Arbeiten mit vollen Benutzeroberflächen: Verwenden von TVertScrollBoxKomponenten .............................................................................................................. 85
Siehe auch ................................................................................................................... 86
iOS-Tutorial: Aufnehmen und Teilen von Bildern in iOS-Anwendungen ................. 87
Erstellen der Benutzeroberfläche für die Anwendung .......................................... 88
Aufnehmen eines Fotos mit der iOS-Gerätekamera ............................................. 89
Verwenden eines Fotos aus der Fotobibliothek des iOS-Geräts .......................... 90
Teilen oder Drucken eines Fotos ............................................................................... 91
Siehe auch ................................................................................................................... 92
iOS-Tutorial: Verwenden von Positionssensoren auf iOS-Geräten ........................... 93
Entwerfen der Benutzeroberfläche .......................................................................... 94
Der Positionssensor ...................................................................................................... 95
Abrufen der Positionsinformationen (geografische Breite und Länge) von der
LocationSensor-Komponente ................................................................................... 95
Anzeigen der aktuellen Position mit Google Maps über eine TWebBrowserKomponente ................................................................................................................ 97
Verwenden der Rückwärts-Georeferenzierung ..................................................... 97
5
Anzeigen einer lesbaren Adresse in der ListBox-Komponente ........................... 100
Siehe auch ................................................................................................................. 100
iOS-Tutorial: Verwenden der Mitteilungszentrale auf iOS-Geräten ....................... 101
Drei grundlegende Mitteilungs- oder Hinweisstile ................................................ 101
Kennzeichen auf dem Anwendungssymbol ..................................................... 101
Mitteilungsbanner auf dem iPad ........................................................................ 101
Mitteilungshinweis .................................................................................................. 101
Mitteilungszentrale auf dem iPad ....................................................................... 101
Zugreifen auf den Mitteilungsdienst ....................................................................... 102
Festlegen der Zahl auf dem Kennzeichensymbol im Code ............................... 103
Planen von Mitteilungen .......................................................................................... 104
Aktualisieren oder Abbrechen von geplanten Mitteilungen ............................. 105
Sofortiges Anzeigen der Mitteilung ......................................................................... 106
Mitteilungsbanner oder Mitteilungshinweis ........................................................... 107
Hinzufügen von Aktionen zu Hinweisen ................................................................. 108
Siehe auch ................................................................................................................. 108
iOS-Tutorial: Verwenden von InterBase ToGo in iOS-Anwendungen .................... 109
Herstellen einer Verbindung zu der Datenbank mit dbExpress.......................... 110
Entwerfen und Einrichten der Benutzeroberfläche .............................................. 110
Herstellen der Verbindung zu den Daten .............................................................. 111
Bereitstellen der Anwendung auf iOS .................................................................... 114
Bereitstellen von InterBase ToGo, des dbExpress-Treibers und der
Datenbankdatei auf iOS ...................................................................................... 114
Ändern des Codes für die Verbindung zu einer lokalen Datenbankdatei auf
iOS ............................................................................................................................ 116
Ausführen der Anwendung auf dem iOS-Simulator oder auf einem iOS-Gerät
...................................................................................................................................... 117
Fehlerbehebung ........................................................................................................ 118
InterBase-Lizenzprobleme .................................................................................... 118
Exception-Behandlungsprobleme ...................................................................... 118
Typische Fehler und Lösungen ............................................................................ 119
Siehe auch ................................................................................................................. 119
iOS-Tutorial: Verwenden von SQLite in iOS-Anwendungen ................................... 120
Herstellen einer Verbindung zu der Datenbank mit dbExpress.......................... 121
Erstellen der Datenbank in der Windows-Umgebung für Entwicklungszwecke
...................................................................................................................................... 121
Erstellen der Datenbank im Daten-Explorer ...................................................... 121
Erstellen einer Tabelle im Daten-Explorer ........................................................... 123
Entwerfen und Einrichten der Benutzeroberfläche .............................................. 124
Herstellen der Verbindung zu den Daten .............................................................. 125
Erstellen einer Ereignisbehandlungsroutine zur Anzeige der Schaltfläche
"Delete" bei Auswahl eines Eintrags aus der Liste durch den Benutzer ............ 126
Erstellen einer Ereignisbehandlungsroutine für die Schaltfläche "Add" zum
Hinzufügen eines Eintrags zu der Liste .................................................................... 127
6
Erstellen einer Ereignisbehandlungsroutine für die Schaltfläche "Delete" zum
Entfernen eines Eintrags aus der Liste .................................................................... 129
Ändern des Codes für die Verbindung zu einer lokalen Datenbankdatei unter
iOS ................................................................................................................................ 130
Festlegen des Speicherorts der SQLite-Datenbank auf dem iOS-Gerät ...... 130
Erstellen einer Tabelle, falls keine vorhanden ist ............................................... 131
...................................................................................................................................... 132
Siehe auch ................................................................................................................. 132
iOS-Tutorial: Herstellen einer Verbindung zu Unternehmensdatenbanken von iOSClient-Anwendungen aus ........................................................................................... 133
Erstellen der Mittelschicht: ein DataSnap-Server .................................................. 134
Erstellen einer DataSnap-Server-VCL-Anwendung .......................................... 134
Definieren einer Datenmenge für den DataSnap-Server ............................... 136
Bereitstellen der Datenmenge vom DataSnap-Server .................................... 138
Ausführen des DataSnap-Servers ........................................................................ 138
Erstellen einer iOS-Anwendung für die Verbindung zum DataSnap-Server ..... 139
Bereitstellen der MIDAS-Bibliothek auf dem iOS-Simulator ................................. 143
...................................................................................................................................... 144
Siehe auch ................................................................................................................. 144
7
IOS-TUTORIALS: IOSANWENDUNGSENTWICKLUNG MIT DELPHI
Diese Tutorials führen Sie durch die zur Erstellung von iOS-Anwendungen mit RAD
Studio erforderlichen Schritte:


Nach dem ersten Tutorial zur Einrichtung der Umgebung wird in jedem
Tutorial das Erstellen einer iOS-Anwendung mit FireMonkey-Tools gezeigt.
In den Tutorials werden die zum Erzielen eines nativen Erscheinungsbildes
und Verhaltens von iOS-Anwendungen empfohlenen FireMonkeyKomponenten verwendet.
EINRICHTEN

Konfigurieren der Entwicklungsumgebung auf dem
Mac

Konfigurieren der Entwicklungsumgebung auf dem
Windows-PC
VERWENDEN VON GRUNDLEGENDEN ELEMENTEN DER
BENUTZEROBERFLÄCHE

Erstellen einer FireMonkey iOS-Anwendung

Verwenden von Schaltflächen-Komponenten mit
unterschiedlichen Stilen in iOS-Anwendungen
8

Verwenden von Kalender-Komponenten zur
Datumsauswahl in iOS-Anwendungen

Verwenden von Kombinationsfeld-Komponenten zur
Auswahl von Einträgen in iOS-Anwendungen

Verwenden von Webbrowser-Komponenten in iOSAnwendungen

Verwenden von Registerkarten-Komponenten zur
Anzeige von Seiten in iOS-Anwendungen

Verwenden von Listenfeld-Komponenten zur Anzeige
von Tabellenansichten in iOS-Anwendungen

Verwenden von Layouts zur Ausrichtung
unterschiedlicher Formulargrößen in iOSAnwendungen
VERWENDEN VON GERÄTEFUNKTIONEN

Aufnehmen und Teilen von Bildern in iOSAnwendungen
9

Verwenden von Positionssensoren auf iOS-Geräten

Verwenden der Mitteilungszentrale auf iOS-Geräten
ZUGREIFEN AUF DATENBANKEN

Verwenden von InterBase ToGo in iOS-Anwendungen

Verwenden von SQLite in iOS-Anwendungen

Herstellen einer Verbindung zu
Unternehmensdatenbanken von iOS-ClientAnwendungen aus
SIEHE AUCH





FireMonkey Quick Start
Erstellen einer FireMonkey iOS-App
FireMonkey-Anwendungsdesign
iOS-Codefragmente
Mobile iOS-Anwendungsentwicklung
10
IOS-TUTORIAL: KONFIGURIEREN DER
ENTWICKLUNGSUMGEBUNG AUF DEM MAC
FireMonkey-Anwendungen für die iOS-Zielplattform werden zuerst mit dem iOSSimulator auf dem Mac getestet. Im zweiten Teil des Tests wird die Zielplattform
iOS-Gerät verwendet, für die ein Test-iOS-Gerät am Mac angeschlossen sein
muss.


Im ersten Teil dieses Tutorials werden die Schritte beschrieben, die zur
Ausführung einer iOS-Anwendung auf dem iOS-Simulator auf dem Mac
erforderlich sind.
Im zweiten Teil dieses Tutorials werden weitere Schritte beschrieben, die
Sie zur Ausführung einer iOS-Anwendung auf Ihrem iOS-Gerät durchführen
müssen.
VORAUSSETZUNGEN AUF DEM MAC

OS X 10.7 Lion oder 10.8 Mountain Lion
(Diese beiden Betriebssysteme werden nicht auf alten PowerPC- und
680x0-basierten Macintosh-Systemen unterstützt. Alle Macs seit 2007 sind
Intel-basiert; alle seit 2008 verwenden 64 Bit, was für Lion erforderlich ist.)



iOS 5.1 und höher
Neueste Version von Xcode mit installiertem iOS-SDK und den XcodeBefehlszeilen-Tools
o Dazu ist die Mitgliedschaft bei einem Apple-Entwicklerprogramm
(Apple Developer Program) erforderlich. Die AppleEntwicklerprogramme werden in diesem Thema unter Anmelden für
ein Entwicklerkonto behandelt.
An den Mac über einen USB-Anschluss angeschlossenes iOS-Gerät
(erforderlich zum Testen und Ausführen der iOS-App auf dem Gerät)
SCHRITTE ZUM KONFIGURIEREN DES MAC FÜR DIE
AUSFÜHRUNG EINER IOS-ANWENDUNG AUF DEM IOSSIMULATOR
Um eine iOS-Anwendung an den iOS-Simulator auf dem Mac weiterzugeben,
müssen Sie die folgenden Tools auf dem Mac installieren:

Platform Assistant (PAServer)
11
Zum Debuggen und Testen verwendet RAD Studio den Platform Assistant,
eine Anwendung, die Sie auf dem Mac installieren und ausführen müssen.

Xcode
Xcode, die Entwicklungs- und Debug-Umgebung auf dem Mac, stellt die
für die Entwicklung erforderlichen Dateien für Mac OS X- und iOSAnwendungen bereit.
SCHRITT 1: INSTALLIEREN DES "PLATFORM ASSISTANT"
Wie oben erwähnt, muss der "Platform Assistant" auf dem Mac ausgeführt
werden, wenn Sie eine iOS-App vom PC an den iOS-Simulator oder ein iOSGerät weitergeben.
Das Mac OS X-Installationsprogramm für den "Platform Assistant" heißt
RADPAServerXE4.pkg und befindet sich an zwei Orten:

Im Ordner PAServer im RAD Studio-Installationsverzeichnis.
Zum Beispiel: C:\Programme\Embarcadero\RAD
Studio\n.n\PAServer\RADPAServerXE4.pkg.

Im Web zum Herunterladen auf den Mac:
http://installers.codegear.com/release/radstudio/11.0/PAServer/RADPASer
verXE4.pkg
12
Weitere Einzelheiten finden Sie unter Installieren des Platform Assistant auf dem
Mac.
SCHRITT 2: AUSFÜHREN DES "PLATFORM ASSISTANT"
Aktivieren Sie auf dem Mac im Finder die .app-Datei (RAD PAServer XE4.app)
wie folgt:
1. Navigieren Sie zum obersten Applications-Ordner.
2. Doppelklicken Sie auf RAD PAServer XE4.app, um den "Platform Assistant"
zu starten.
Das Terminal-Fenster wird mit dem "Platform Assistant"-Banner und der
Passworteingabeaufforderung angezeigt:
Remote-Profil-Passwort <Eingabetaste für kein Passwort>:
13
3. Als Nächstes werden Sie aufgefordert, Ihr Mac-Benutzerpasswort
einzugeben, damit der "Platform Assistant" Ihre Anwendung debuggen
(die Steuerung eines anderen Prozesses übernehmen) kann. Geben Sie Ihr
Passwort ein, und wählen Sie Take Control.
Weitere Einzelheiten zum Ausführen des "Platform Assistant" finden Sie unter
Ausführen des Platform Assistant auf dem Mac.
SCHRITT 3: INSTALLIEREN VON XCODE AUF DEM MAC
Xcode, die Entwicklungs- und Debug-Umgebung auf dem Mac, stellt die
erforderlichen Entwicklungsdateien für Mac OS X- und iOS-Anwendungen bereit.
Xcode kann von einer der folgenden Quellen installiert werden:



Doppelklicken Sie zum Installieren von Xcode auf Ihrem System auf der
Mac OS X-Installations-DVD unter dem Verzeichnis für optionale
Installationen auf Xcode.mpkg.
Laden Sie Xcode kostenlos aus dem Mac App Store herunter.
Als registrierter Apple-Entwickler können Sie die kostenlose Version von
Xcode als Paket (.dmg) herunterladen. So registrieren Sie sich und laden
Xcode herunter:
1. Registrieren Sie sich (kostenlos) als Apple-Entwickler unter
http://developer.apple.com/programs/register/.
2. Laden Sie Xcode als Paket von
https://developer.apple.com/downloads herunter.
NÄCHSTE SCHRITTE
Sie haben Ihren Mac für die Ausführung einer iOS-Anwendung auf dem iOSSimulator konfiguriert.
14

Unter iOS-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem
Windows-PC finden Sie Informationen zum Ausführen einer iOSAnwendung auf dem iOS-Simulator und zum Fertigstellen der
Konfiguration in der RAD Studio-IDE.

Führen Sie die folgenden Schritte aus, um die iOS-Anwendung auf Ihrem
iOS-Gerät auszuführen und die Konfiguration auf dem Mac fertigzustellen.
Sie können diese Schritte nach dem Testen der Anwendung auf dem iOSSimulator ausführen.
WEITERE SCHRITTE ZUM KONFIGURIEREN DES MAC FÜR DIE
AUSFÜHRUNG EINER IOS-ANWENDUNG AUF DEM IOSSIMULATOR
Anhand der folgenden Schritte können Sie eine iOS-Anwendung auf Ihrem iOSGerät ausführen.
SCHRITT 1: INSTALLIEREN DER XCODE-BEFEHLSZEILEN-TOOLS AUF EINEM MAC
So installieren Sie die erforderlichen Xcode-Tools über Xcode auf dem Mac:
1. Starten Sie Xcode auf dem Mac.
2. Wählen Sie im Xcode-Menü Preferences aus.
15
3. Klicken Sie im Bereich General auf Downloads.
4. Aktivieren Sie im Fenster Downloads die Registerkarte Components.
5. Klicken Sie neben Command Line Tools auf die Schaltfläche Install.
Während der Installation werden Sie nach Ihren Apple-EntwicklerAnmeldedaten gefragt.
Weitere Einzelheiten finden Sie unter Xcode-Befehlszeilen-Tools.
SCHRITT 2: ANMELDEN FÜR EIN ENTWICKLERKONTO
Für das Erzeugen, Ausführen, Debuggen und Bereitstellen von Anwendungen für
iOS müssen Sie Mitglied bei einem der iOS-Entwicklerprogramme sein.
Für die Mitgliedschaft bei einem Entwicklerprogramm stehen folgende
Möglichkeiten zur Verfügung:


Als Einzelentwickler.
Als Mitglied (oder Leiter) eines Teams in einem Unternehmens- oder
Universitätsprogramm.
Weitere Einzelheiten finden Sie unter Beitreten zu einem iOSEntwicklerprogramm.
SCHRITT 3: ANFORDERN, HERUNTERLADEN UND INSTALLIEREN IHRES
ENTWICKLUNGSZERTIFIKATS
Anwendungen, die auf dem Gerät (oder auf dem iOS-Simulator) bereitgestellt
werden, müssen vor deren Ausführung verschlüsselt signiert werden. Das
Entwicklungszertifikat enthält die für die Signierung von Anwendungen
erforderlichen Informationen. Jede Einzelperson (ein einzelner Entwickler oder
16
ein Teammitglied) muss über ein eindeutiges Entwicklungszertifikat verfügen, das
für mehrere Anwendungen verwendet werden kann.
Für Entwicklungsteams müssen Entwicklungszertifikate von jedem Teammitglied
angefordert werden, und diese Anforderungen müssen von einem
Teamadministrator genehmigt werden.
Anfordern, Herunterladen und Installieren Ihres Zertifikats
1. Wählen Sie in der Anwendung Schlüsselbundverwaltung auf dem Mac
aus dem Menü Schlüsselbundverwaltung: Zertifikatsassistent > Zertifikat
einer Zertifizierungsinstanz anfordern aus.
Speichern Sie die Zertifikatsanforderung als Datei, und senden Sie diese
Datei dann an Ihre Zertifizierungsinstanz durch Hochladen an das Apple
iOS provisioning portal (iOS-Bereitstellungsportal).
Wenn Sie Mitglied eines Entwicklungsteams für ein
Unternehmens/Organisationsprogramm sind, muss Ihr
Teamadministrator Ihre Anforderung genehmigen. Nach der
Genehmigung durch den Teamadministrator können Sie das
Zertifikat herunterladen.
o Wenn Sie Einzelentwickler sind, sollte kurz nach Ihrer Anforderung
eine Option zum Herunterladen Ihres Zertifikats angezeigt werden.
Einzelheiten dazu finden Sie in der Apple-Dokumentation unter:
Creating signing certificates (Erstellen von Signierungszertifikaten).
2. Wechseln Sie zum iOS Provisioning Portal (iOS-Bereitstellungsportal). Wenn
sich der Status von Submitted in Issued geändert hat, können Sie das
Entwicklungszertifikat herunterladen.
o
17
3. Rufen Sie das Entwicklungszertifikat durch einen Doppelklick ab. Es wird
automatisch in der Anwendung Schlüsselbundverwaltung geladen.
SCHRITT 4: REGISTRIEREN IHRES GERÄTS FÜR DIE BEREITSTELLUNG
Bevor auf einem Gerät Benutzeranwendungen ausgeführt werden können, muss
es im Apple Provisioning Portal (Apple-Bereitstellungsportal) registriert werden.
Geräte werden anhand der eindeutigen Geräte-ID (Unique Device ID, UDID)
registriert. Die UDID wird mit Xcode wie folgt ermittelt:
1.
2.
3.
4.
Schließen Sie Ihr iOS-Gerät an Ihren Mac-Computer an.
Öffnen Sie Xcode und dann den Organizer (Fenster > Organizer).
Klicken Sie auf der Registerkarte Geräte auf Ihr Gerät.
Neben der Beschriftung Bezeichner befindet sich eine Zeichenfolge:
Diese Zeichenfolge ist die UDID Ihres Geräts.
o
o
Wenn Sie Einzelentwickler sind, registrieren Sie Ihr Gerät, indem Sie
die UDID auf der Registerkarte "Devices" im Apple Provisioning Portal
(Apple-Bereitstellungsportal) angeben.
Wenn Sie Teil eines Unternehmens/Organisationsteams sind, bitten
Sie Ihren Teamadministrator, Ihr Gerät zu registrieren.
18
Schritt 5: Erstellen und Installieren eines Bereitstellungsprofils
Über Bereitstellungsprofile werden Entwickler und Geräte mit einem
Entwicklungsteam verknüpft. Dieses Bereitstellungsprofil ist zum Ausführen von
Anwendungen auf einem iOS-Gerät erforderlich.


Wenn Sie Einzelentwickler sind, müssen Sie ein Bereitstellungsprofil erstellen.
Genaue Informationen dazu finden Sie unter: Creating and Downloading
a Distribution Provisioning Profile (Erstellen und Herunterladen eines
Bereitstellungsprofils für die Weitergabe).
Wenn Sie Teil eines Unternehmens/Organisationsteams sind, müssen Ihre
Teamadministratoren ein Bereitstellungsprofil erstellen, das Sie verwenden
können.
Das erstellte Bereitstellungsprofil muss wie folgt in Xcode installiert werden:
1. Öffnen Sie Xcode und dann den Organizer (Fenster > Organizer) auf dem
Mac.
2. Wählen Sie im Abschnitt Library den Eintrag Provisioning Profiles aus, und
klicken Sie auf Refresh.
3. Xcode fordert Sie zur Eingabe Ihrer Apple-ID auf. Geben Sie Ihre
Anmeldeinformationen ein, und wählen Sie Log in.
Die für Sie verfügbaren Bereitstellungsprofile werden in Ihr Xcode installiert:
4. Wählen Sie ein gültiges iOS-Bereitstellungsprofil aus, und ziehen Sie es in
die Bereitstellungsprofile für Ihr Testgerät.
Sie haben Ihren Mac für die Ausführung der iOS-Anwendung auf Ihrem iOSGerät konfiguriert.
19
Informationen zum Ausführen der iOS-Anwendung und Fertigstellen der
Konfiguration in der RAD Studio-IDE finden Sie unter iOS-Tutorial: Konfigurieren
der Entwicklungsumgebung auf dem Windows-PC. Wenn Sie Ihren PC zur
Ausführung der Anwendung auf dem iOS-Simulator konfiguriert haben, können
Sie diesen Schritt überspringen.
SIEHE AUCH












iOS-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem WindowsPC
Paserver: Die Platform Assistant Server-Anwendung
Apple Developer Program (Apple-Entwicklerprogramm)
iOS Developer Program (iOS-Entwicklerprogramm)
Creating and Configuring App IDs (Erstellen und Konfigurieren von AppIDs)
Creating signing certificates (Erstellen von Signierungszertifikaten)
iOS Provisioning Portal (iOS-Bereitstellungsportal)
Devices tab of the Apple Provisioning Portal (Apple-Bereitstellungsportal)
Create an Apple ID (Erstellen einer Apple-ID)
Creating and Downloading a Distribution Provisioning Profile (Erstellen und
Herunterladen eines Bereitstellungsprofils für die Weitergabe)
Installieren des Platform Assistant auf dem Mac
Ausführen des Platform Assistant auf dem Mac
20
IOS-TUTORIAL: KONFIGURIEREN DER
ENTWICKLUNGSUMGEBUNG AUF DEM
WINDOWS-PC
Bevor Sie mit diesem Tutorial beginnen, sollten Sie das folgende Tutorial
durcharbeiten:

iOS-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac
FireMonkey-Anwendungen für die iOS-Zielplattform werden anfänglich mit dem
iOS-Simulator auf dem Mac getestet. Im zweiten Teil des Tests wird die
Zielplattform iOS-Gerät verwendet, für die ein iOS-Gerät am Mac angeschlossen
sein muss. Für die Bereitstellung einer iOS-Anwendung auf Ihrem Gerät zum
Debuggen und Testen verwendet RAD Studio den Platform Assistant, den Sie auf
dem Mac installieren und ausführen müssen.
In diesem Abschnitt werden die Schritte zum Einrichten der
Entwicklungsumgebung nach der Konfiguration der Umgebung auf dem Mac
beschrieben.
21
KONFIGURIEREN DER RAD STUDIO-UMGEBUNG
Anhand der folgenden Konfigurationsschritte können Sie die iOS-Entwicklung mit
RAD Studio beschleunigen.
ERSTELLEN EINES VERBINDUNGSPROFILS FÜR DEN MAC
1. Öffnen Sie Tools > Optionen > Umgebungsoptionen > VerbindungsprofilManager.
2. Wählen Sie Hinzufügen:
3. Der Experte Verbindungsprofil erstellen wird angezeigt. Legen Sie einen
Namen für das Verbindungsprofil, z.B. "Mein Mac", fest.
Wählen Sie als Plattform OS X aus, und klicken Sie dann auf Weiter:
22
4. Geben Sie auf der Seite "Host-Computer-Information" den Namen oder
die IP-Adresse des Host-Macs, eine Port-Nummer (der Standard-Port 64211
funktioniert in der Regel) und ein optionales Passwort (wenn Sie eins
verwenden möchten) an.
5. Klicken Sie auf Verbindung testen, und überprüfen Sie, ob das
Verbindungsprofil ohne Fehler ausgeführt wird (die Meldung "Verbindung
zu <Hostname> auf Port <Portnummer> erfolgreich ausgeführt" sollte
angezeigt werden):
23
HINZUFÜGEN EINES SDK ZU DEM ENTWICKLUNGSSYSTEM FÜR DAS AN DEN MAC
ANGESCHLOSSENE IOS-GERÄT
1. Öffnen Sie Tools > Optionen > Umgebungsoptionen > SDK-Manager.
2. Wählen Sie Hinzufügen.
3. Wählen Sie im Dialogfeld Neues SDK hinzufügen als Plattform iOS-Gerät
aus.
4. Wählen Sie eine Plattform für die Verbindung aus (z.B. "iOS-Gerät").
5. Nach Auswahl der Plattform füllt die IDE ein Profil (z.B. "Mein Mac") und das
Kombinationsfeld SDK-Version auswählen mit der Liste der SDK-Versionen,
24
die auf dem Computer verfügbar sind, auf dem der Platform Assistant
Server ausgeführt wird:
Klicken Sie auf OK, um das Dialogfeld zu schließen.
SIEHE AUCH









iOS-Tutorial: Erstellen einer FireMonkey iOS-Anwendung
Arbeiten mit einem Mac und einem PC
Ausführen von iOS-Anwendungen auf einem iOS-Gerät
Ausführen von Anwendungen auf dem iOS-Simulator
Plattformvoraussetzungen für FireMonkey
Erstellen einer FireMonkey iOS-App
Mac OS X-Anwendungsentwicklung
Erstellen einer FireMonkey-Anwendung
Seiten auf "Apple developer.apple.com"
o iOS Developer Library
o iOS Developer Library: Getting Started
o iOS Dev Center
o Provisioning an iOS Device
o Preparing Your iOS App for Distribution in the App Store
o iAd Network
25
IOS-TUTORIAL: ERSTELLEN EINER
FIREMONKEY IOS-ANWENDUNG
In diesem Thema wird das Erstellen einer "Hello World"-FireMonkey-Anwendung
für die iOS-Zielplattform beschrieben.
VORBEREITUNGEN
Um iOS-Anwendungen mit RAD Studio zu erstellen, müssen Sie einige
wichtige Konfigurationsschritte ausführen. In diesem Tutorial wird davon
ausgegangen, dass Sie bereits alle erforderlichen Konfigurationsschritte
ausgeführt haben.
Einzelheiten finden Sie unter:

iOS-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac

iOS-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem
Windows-PC
SCHRITT 1: ERSTELLEN EINER NEUEN FIREMONKEY-HDANWENDUNG FÜR IOS
1. Wählen Sie Datei > Neu >Mobile FireMonkey-Anwendung - Delphi:
2. Wählen Sie Leere Anwendung.
26
Im Designer für mobile FireMonkey-Formulare wird ein neues Formular für eine
iOS-Anwendung angezeigt.
SCHRITT 2: PLATZIEREN VON KOMPONENTEN AUF DEM
FIREMONKEY-IOS-FORMULAR
Der erste Schritt beim Erstellen einer FireMonkey-iOS-Anwendung besteht, genau
wie bei Desktop-Anwendungen, aus dem Entwerfen der Benutzeroberfläche. In
der IDE stehen viele wiederverwendbare Komponenten zum Erstellen von
Benutzeroberflächen zur Verfügung.
1. Erweitern Sie in der Tool-Palette mit der Maus die Kategorie Standard
durch Klicken auf das Plus-Zeichen (+) neben dem Kategorienamen.
2. Wählen Sie die Komponente TEdit aus, und legen Sie sie im FormularDesigner ab. Eine Instanz der TEdit-Komponente wird im Formular
angezeigt:
27
Wiederholen Sie diese Schritte, aber fügen Sie jetzt dem Formular eine TLabelund eine TButton-Komponente hinzu. Wählen Sie die Schaltfläche aus, und
ändern Sie im Objektinspektor die Eigenschaft Text in "Say Hello".
Jetzt sollten die drei Komponenten im Formular-Designer angezeigt werden:
Nach dem Ablegen dieser Komponenten im Formular-Designer werden deren
Namen automatisch von der IDE festgelegt.
Um den Namen einer Komponente anzuzeigen oder zu ändern, klicken Sie im
Formular-Designer auf die entsprechende Komponente, und suchen Sie im
Objektinspektor und in der Strukturansicht deren Eigenschaft Name:
28
Für TButton-Komponenten wird der Komponentenname standardmäßig auf
Button1 gesetzt (oder auf Button2, Button3, je nachdem, wie viele TButtons Sie in
dieser Anwendung erstellt haben).
Auch das Formular, auf dem sich diese Komponenten befinden, hat einen
Namen. Klicken Sie auf den Hintergrund des Designers für mobile FireMonkeyFormulare, und wählen Sie im Objektinspektor die Eigenschaft Name aus. Der
Name des Formulars Form1 (oder Form2, Form3,...) wird angezeigt. In der
Strukturansicht können Sie den Namen des Formulars auch schnell finden:
Sie können durch Klicken auf die Registerkarte Code im unteren Bereich des
Formular-Designers oder durch Drücken der Taste F12 schnell zum Quellcode
wechseln. Sie können jederzeit zwischen dem Formular-Designer und dem
Quelltext-Editor wechseln:
29
Im Quelltext-Editor wird der Quellcode angezeigt, den die IDE erzeugt hat. Es
sollten die drei festgelegten Komponenten (Edit1, Label1 und Button1)
vorhanden sein:
30
SCHRITT 3: SCHREIBEN EINER DELPHIEREIGNISBEHANDLUNGSROUTINE FÜR EINEN KLICK AUF DIE
SCHALTFLÄCHE DURCH DEN BENUTZER
Im nächsten Schritt wird eine Ereignisbehandlungsroutine für die TButtonKomponente erstellt. Ereignisbehandlungsroutinen können für FireMonkey-iOSAnwendungen auf die gleiche Weise wie für Desktop-Anwendungen definiert
werden. Das typische Ereignis für TButton-Komponenten ist das Klicken auf die
Schaltfläche.
Doppelklicken Sie im Formular-Designer auf die Schaltfläche, und RAD Studio
erstellt den Skeleton-Code, den Sie zum Implementieren einer
Ereignisbehandlungsroutine für das Klickereignis der Schaltfläche verwenden
können:
Nun können Sie zwischen den Anweisungen begin und end der Methode
Button1Click Reaktionen implementieren.
Das folgende Codefragment implementiert eine Reaktion, die ein kleines
Dialogfeld mit dem Text "Hello + <in das Eingabefeld eingegebener Name>"
anzeigt:
Label1.Text := 'Hello ' + Edit1.Text + ' !';
In Delphi müssen die Anführungszeichen um String-Literale einfache gerade
Anführungszeichen sein (z.B. 'string'). Mit dem Pluszeichen (+) können Strings
verkettet werden. Wenn Sie in einem String ein einfaches Anführungszeichen
benötigen, können Sie zwei aufeinanderfolgende einfache Anführungszeichen
verwenden, was ein einzelnes Anführungszeichen ergibt.
Während Sie den Code eingeben, werden Kurzhinweise zur Art der Parameter,
die Sie angeben müssen, angezeigt. In den Kurzhinweisen wird auch die Art der
Member angezeigt, die in einer gegebenen Klasse unterstützt werden.
31
SCHRITT 4: TESTEN DER IOS-ANWENDUNG AUF DEM MAC
(IOS-SIMULATOR)
Die Implementierung dieser Anwendung ist abgeschlossen, und Sie können sie
jetzt ausführen. Klicken Sie dazu in der IDE auf die Schaltfläche Start (
), oder
drücken Sie F9, oder wählen Sie im Hauptmenü von RAD Studio Start > Start.
Standardmäßig werden FireMonkey-iOS-Anwendungen auf der iOS-SimulatorZielplattform ausgeführt. Sie können in der Projektverwaltung die Zielplattform
bestätigen:
Wenn Sie die Anwendung ausführen, wird sie auf dem Mac und dann für den
iOS-Simulator auf dem Mac bereitgestellt. Für dieses Beispiel wird ein Formular
mit einem Eingabefeld und einer Schaltfläche angezeigt. Geben Sie in das
Eingabefeld Text ein, und klicken Sie auf die Schaltfläche Say Hello:
32
SCHRITT 5: TESTEN DER IOS-ANWENDUNG AUF EINEM
ANGESCHLOSSENEN IOS-GERÄT
Wenn Sie vor dem Erstellen des neuen Projekts die in iOS-Tutorial: Konfigurieren
der Entwicklungsumgebung auf dem Mac und iOS-Tutorial: Konfigurieren der
Entwicklungsumgebung auf dem Windows-PC beschriebenen Schritte
ausgeführt haben, können Sie jetzt die iOS-App auf einem iOS-Gerät testen, das
über ein USB-Kabel an den Mac angeschlossen ist.
Wählen Sie zum Ausführen der iOS-App auf einem angeschlossenen iOS-Gerät
zuerst die Zielplattform iOS-Gerät aus, damit der "Platform Assistant" die
Anwendung für das angeschlossene iOS-Gerät bereitstellt:
33
Nach Auswahl der iOS-Gerät-Zielplattform führen Sie die iOS-App durch Klicken
auf die Schaltfläche Start in der IDE, durch Drücken von F9 oder Auswahl von
Start > Start aus.
Auf Ihrem Mac erscheint möglicherweise ein Dialogfeld, in dem Sie die
Codesignierung Ihrer iOS-App bestätigen müssen. Wählen Sie entweder "Always
Allow" oder "Allow", um Ihre App zu signieren.
Nehmen Sie dann Ihr iOS-Gerät zur Hand, und warten Sie bis die FireMonkey-iOSApp angezeigt wird. Das FireMonkey-Startbild (aus $(BDS)\bin\Artwork\iOS) wird
angezeigt:
SIEHE AUCH



iOS-Tutorial: Verwenden von Schaltflächen-Komponenten mit
34
IOS-TUTORIAL: VERWENDEN VON
SCHALTFLÄCHEN-KOMPONENTEN MIT
UNTERSCHIEDLICHEN STILEN IN IOSANWENDUNGEN
SCHALTFLÄCHEN IN FIREMONKEY-ANWENDUNGEN FÜR IOS
FireMonkey definiert verschiedene Schaltflächentypen, und Sie können alle
diese verschiedenen Typen mit den hier beschriebenen Schritten verwenden. Zu
den FireMonkey-Schaltflächen zählen TButton und TSpeedButton.
Im Folgenden sind einige Beispiele verschiedener Stile für SchaltflächenKomponenten in unterschiedlichen Benutzeroberflächen dargestellt.

Schaltflächen im Formular:
o
o

Schaltflächen in der Navigationsleiste (Symbolleiste):
o
o
o
o
o
o
35
DEFINIEREN DES AUSSEHENS UND VERHALTENS VON
SCHALTFLÄCHEN-KOMPONENTEN
Nach dem Platzieren einer neuen Schaltfläche im Designer für mobile
FireMonkey-Formulare können Sie im Objektinspektor einige wichtige
Eigenschaften für eine ausgewählte Komponente festlegen.
Wählen Sie eine Komponente (in diesem Fall: eine Schaltfläche) aus, und
suchen Sie dann bestimmte Eigenschaften, und ändern Sie deren Wert
folgendermaßen:




Ändern Sie den Text, der auf der Schaltflächenoberfläche angezeigt wird,
indem Sie den Wert der Eigenschaft Text aktualisieren.
Ändern Sie den Wert der Eigenschaften Position.X und Position.Y (oder
ziehen Sie die Komponente mit der Maus).
Ändern Sie den Wert der Eigenschaften Height und/oder Width (oder
ziehen Sie mit der Maus am Rand die Komponente).
Klicken Sie in der Eigenschaft StyleLookup auf den nach unten weisenden
Pfeil.
In der Dropdown-Liste StyleLookup können Sie einen vordefinierten Stil auf
Basis der Verwendung der Komponente auswählen:
36
ERSTELLEN VON SEGMENTIERTEN STEUERELEMENTEN MIT
SCHALTFLÄCHEN-KOMPONENTEN
FireMonkey verwendet zum Definieren eines segmentierten Steuerelements die
Schaltflächen-Komponente. Mit segmentierten Steuerelementen können
Benutzer einen Wert aus mehreren Optionen auswählen.
Führen Sie folgende Schritte durch, um ein segmentiertes Steuerelement zu
definieren:
37
1. Platzieren Sie drei TSpeedButton-Komponenten aus der Tool-Palette auf
dem Formular. Ordnen Sie die TSpeedButton-Komponenten mit der Maus
nebeneinander an:
2. Wählen Sie die erste Komponente aus, und ändern Sie deren Eigenschaft
StyleLookup in segmentedbuttonleft:
3. Wählen Sie die zweite Komponente aus, und ändern Sie deren
Eigenschaft StyleLookup in segmentedbuttonmiddle:
4. Wählen Sie die dritte Komponente aus, und ändern Sie deren Eigenschaft
StyleLookup in segmentedbuttonright: Alle drei Schaltflächen sehen nun
wie ein segmentiertes Steuerelement aus:
5. Wählen Sie jede Komponente aus, und ändern Sie die Eigenschaft Text
beliebig:
6. Klicken und ziehen Sie den Mauszeiger über die drei Schaltflächen, um
diese Komponenten auszuwählen:
7. Setzen Sie die Eigenschaft GroupName auf einen eindeutigen Namen,
wie z.B. LocationSegments:
38
8. Setzen Sie die Eigenschaft IsPressed einer Komponente auf True, um eine
dieser Komponenten standardmäßig als Gedrückt festzulegen:
ERSTELLEN EINER BEREICHSLEISTE (SCOPE BAR) AUF EINER
SYMBOLLEISTEN-KOMPONENTE
Sie können ein segmentiertes Steuerelement auf einer Symbolleiste erstellen; ein
solches Steuerelement wird auch Scope Bar (Bereichsleiste) genannt, mit der
der Suchbereich gesteuert werden kann.
Verwenden Sie dieselben TSpeedButton-Steuerelemente wie in den
vorhergehenden Schritten, aber mit den folgenden Werten für die Eigenschaft
StyleLookup.



toolbuttonleft
toolbuttonmiddle
toolbuttonright
SIEHE AUCH




iOS-Tutorial: Erstellen einer FireMonkey iOS-Anwendung
FMX.StdCtrls.TButton
FMX.Controls.TStyledControl.StyleLookup
FMX.StdCtrls.TToolBar
39
IOS-TUTORIAL: VERWENDEN VON KALENDERKOMPONENTEN ZUR DATUMSAUSWAHL IN IOSANWENDUNGEN
KALENDER IN FIREMONKEY-IOS-ANWENDUNGEN
FireMonkey kapselt mit der Komponente TCalenderEdit Kalender-Komponenten
oder Datumsauswahlfelder für die iOS-Zielplattform:
Anhand der folgenden einfachen Schritte können Sie die Komponente
TCalenderEdit schnell einsetzen:
1. Wählen Sie in der Tool-Palette die Komponente TCalenderEdit aus, und
legen Sie sie im Designer für mobile FireMonkey-Formulare ab. Geben Sie
in das Suchfeld ( ) der Tool-Palette die ersten Zeichen ("Cale") ein, um
die Komponente schnell zu finden:
Nach dem Ablegen der TCalenderEdit-Komponente wird sie im Designer
für mobile FireMonkey-Formulare angezeigt.
40
2. Im Grunde ist das alles. Führen Sie die Anwendung entweder auf dem iOSSimulator oder auf dem angeschlossenen iOS-Gerät aus. Wenn Sie auf
TCalenderEdit tippen, wird das Kalender-Steuerelement angezeigt, und
Sie können ein Datum auswählen.
IMPLEMENTIEREN EINER EREIGNISBEHANDLUNGSROUTINE FÜR
DATUMSÄNDERUNGEN DURCH DEN BENUTZER
Nach dem Ändern des Datums durch den Benutzer wird das Ereignis OnChange
ausgelöst. Sie können eine Ereignisbehandlungsroutine für das Ereignis
OnChange implementieren, um auf die Benutzeraktion zu reagieren.
So implementieren Sie eine OnChange-Ereignisbehandlungsroutine:
1. Wählen Sie die Komponente TCalenderEdit aus.
2. Öffnen Sie im Objektinspektor die Seite Ereignisse, und doppelklicken Sie
auf den leeren Bereich neben OnChange.
3. Schreiben Sie folgenden Code:
procedure TForm25.CalendarEdit1Change(Sender: TObject);
begin
ShowMessage(FormatDateTime('dddddd', CalendarEdit1.Date));
end;
Dieser Code zeigt das Meldungsdialogfeld mit dem ausgewählten Datum an.
Die Funktion FormatDateTime wandelt das ausgewählte Datum in ein
bestimmtes Format um (in diesem Fall in das lange Datumsformat dddddd):
41
SIEHE AUCH




iOS-Tutorial: Verwenden von Kombinationsfeld-Komponenten zur Auswahl
von Einträgen in iOS-Anwendungen
Unterstützung für Datum und Uhrzeit
Routinen für die Typumwandlung
42
KOMBINATIONSFELD-KOMPONENTEN ZUR
AUSWAHL VON EINTRÄGEN IN IOSANWENDUNGEN
IMPLEMENTIEREN EINER AUSWAHLKOMPONENTE IN
FIREMONKEY-IOS-ANWENDUNGEN
FireMonkey kapselt auf der iOS-Plattform Auswahlkomponenten mit der
Komponente TComboBox:
So legen Sie eine Auswahlkomponente und die Listeneinträge fest:
1. Wählen Sie Datei > Neu > Mobile FireMonkey-Anwendung - Delphi >
Mobile HD-FireMonkey-Anwendung.
2. Wählen Sie in der Tool-Palette die Komponente TComboBox aus, und
ziehen Sie sie in den Designer für mobile FireMonkey-Formulare. Geben Sie
in das Suchfeld der Tool-Palette die ersten Zeichen ("Com") ein, um
TComboBox schnell zu finden:
43
3. Nach dem Ablegen der TComboBox-Komponente wird sie im FormularDesigner angezeigt. Klicken Sie mit der rechten Maustaste auf die
TComboBox-Komponente, und wählen Sie Eintrags-Editor...:
4. Klicken Sie mehrmals auf Eintrag hinzufügen, um Einträge hinzuzufügen.
5. Wählen Sie in der Strukturansicht den Eintrag ListBoxItem1 (den ersten
Eintrag in der Liste) aus.
6. Bearbeiten Sie im Objektinspektor die Eigenschaft Text für ListBoxItem1. In
diesem Beispiel (die 50 Staaten der USA) ist der erste Eintrag in der Liste
"Alabama".
44
7. Bearbeiten Sie auch die anderen Einträge, z.B. Alaska, Arizona, Arkansas,
California, Colorado usw.
8. Führen Sie die Anwendung entweder auf dem iOS-Simulator oder auf der
iOS-Gerätezielplattform aus. Wenn Sie auf TComboBox tippen, wird die
Auswahlkomponente angezeigt, und Sie können einen Eintrag auswählen.
ERSTELLEN EINER EINTRAGSLISTE IM CODE
Zum Erstellen einer Eintragsliste im Code können Sie die Methode Add wie folgt
verwenden:
procedure TForm27.FormCreate(Sender: TObject);
begin
ComboBox1.Items.Add('Alabama');
ComboBox1.Items.Add('Alaska');
ComboBox1.Items.Add('Arizona');
ComboBox1.Items.Add('Arkansas');
ComboBox1.Items.Add('California');
// Other states can be listed here
ComboBox1.Items.Add('Virginia');
ComboBox1.Items.Add('Washington');
ComboBox1.Items.Add('West Virginia');
ComboBox1.Items.Add('Wisconsin');
ComboBox1.Items.Add('Wyoming');
end;
45
ANZEIGEN EINES BESTIMMTEN EINTRAGS
Der aktuell ausgewählte Eintrag wird von der Eigenschaft ItemIndex festgelegt.
ItemIndex ist ein Integerwert, der einen nullbasierten Index (d.h., das erste
Element hat den Index 0) angibt.
Zum Anzeigen der Liste, in der der fünfte Eintrag ("California" im folgenden
Beispielcode) ausgewählt ist, geben Sie ItemIndex wie folgt an:
begin
// Index of 5th item is "4"
ComboBox1.ItemIndex := 4;
end;
Wenn Sie den Indexwert nicht kennen, können Sie den Wert mit der Methode
IndexOf folgendermaßen ermitteln:
begin
ComboBox1.ItemIndex := ComboBox1.Items.IndexOf('California');
end;
IMPLEMENTIEREN EINER EREIGNISBEHANDLUNGSROUTINE FÜR
DIE AUSWAHL DES BENUTZERS
Wenn der Benutzer einen Eintrag ausgewählt hat, wird das Ereignis OnChange
ausgelöst. Um auf die Benutzeraktion zu reagieren, können Sie eine
Ereignisbehandlungsroutine für das Ereignis OnChange implementieren.
So implementieren Sie eine OnChange-Ereignisbehandlungsroutine:
46
1. Wählen Sie die Komponente TComboBox aus.
2. Öffnen Sie im Objektinspektor die Seite Ereignisse, und doppelklicken Sie
auf den leeren Bereich neben OnClick.
3. Der Quelltext-Editor wird angezeigt. Schreiben Sie folgenden Code:
procedure TForm27.CalendarEdit1Change(Sender: TObject);
begin
ShowMessage(Format('Item %s at Index %d was selected. ',
[ComboBox1.Selected.Text, ComboBox1.ItemIndex]));
end;
Diese Ereignisbehandlungsroutine zeigt ein Meldungsdialogfeld an, in dem der
ausgewählte Eintrag angegeben ist. Die Funktion Format gibt einen formatierten
String zurück, der sich aus einem Format-String und einem Array mit Argumenten
zusammensetzt:
SIEHE AUCH




iOS-Tutorial: Verwenden von Kalender-Komponenten zur Datumsauswahl
in iOS-Anwendungen
iOS-Tutorial: Verwenden von Registerkarten-Komponenten zur Anzeige
von Seiten in iOS-Anwendungen
47
WEBBROWSER-KOMPONENTEN IN IOSANWENDUNGEN
VERWENDEN VON WEBBROWSER-KOMPONENTEN IN
FIREMONKEY-IOS-ANWENDUNGEN
Auf der iOS-Plattform kapselt FireMonkey die Webbrowser-Komponente als
TWebBrowser-Komponente:
In diesem Thema wird das Erstellen einer einfachen FireMonkey-WebbrowserAnwendung für iOS beschrieben.
SCHRITT 1: ENTWERFEN DER BENUTZEROBERFLÄCHE
1. Wählen Sie Datei > Neu > Mobile FireMonkey-Anwendung - Delphi >
Mobile HD-FireMonkey-Anwendung.
2. Wählen Sie in der Tool-Palette die Komponente TToolBar aus, und ziehen
Sie sie in den Designer für mobile FireMonkey-Formulare. Geben Sie in das
48
Suchfeld der Tool-Palette einige Buchstaben (z.B. "tool") ein, um TToolBar
schnell zu finden:
3. Nach dem Ablegen der Komponente wird die TToolBar-Komponente
oben im Designer für mobile Formulare angezeigt:
4. Wählen Sie in der Tool-Palette die Komponente TButton aus, und legen Sie
sie auf der TToolBar-Komponente ab.
5. Wählen Sie im Designer für mobile Formulare die SchaltflächenKomponente aus, und wählen Sie dann im Objektinspektor in der
Eigenschaft StyleLookup den Eintrag priortoolbuttonbordered aus.
Mit dem Wert priortoolbuttonbordered von StyleLookup für TButton wird
eine "Zurück"-Schaltfläche im iOS-Stil hinzugefügt:
Weitere Einzelheiten zum Auswählen eines Stils in FireMonkey-iOSAnwendungen finden Sie unter iOS-Tutorial: Verwenden von
Schaltflächen-Komponenten mit unterschiedlichen Stilen in iOSAnwendungen.
6. Wählen Sie in der Tool-Palette die Komponente TEdit aus, und legen Sie sie
auf der TToolBar-Komponente ab. Passen Sie die Größe des TEditSteuerelements so an, dass es die gesamte Breite von ToolBar ausfüllt:
49
7. Wählen Sie in der Tool-Palette die Komponente TWebBrowser aus, und
legen Sie sie auf dem Formular ab.
8. Wählen Sie die TWebBrowser-Komponente im Designer für mobile
Formulare aus, und wählen Sie im Objektinspektor für die Eigenschaft Align
den Wert alClient aus.
Wenn Sie diese Schritte ausgeführt haben, sollte das Formular etwa
folgendermaßen aussehen:
SCHRITT 2: SCHREIBEN EINER
EREIGNISBEHANDLUNGSROUTINE ZUM ÖFFNEN EINER
WEBSEITE, WENN DER BENUTZER DEN URL IM EINGABESTEUERELEMENT ÄNDERT
Im Unterschied zur Desktop-Plattform verwenden mobile Geräte die virtuelle
Tastatur zur Eingabe von Text (siehe die folgende Abbildung). Der Benutzer kann
die Aktion durch Klicken auf "Fertig" oder "Return" abschließen.
50
In FireMonkey sind viele Arten von Ereignisbehandlungsroutinen verfügbar, die
die meisten Benutzeraktionen abdecken. Nach Auswahl der Schaltfläche
"Fertig" sendet das FireMonkey-Framework ein OnChange-Ereignis an das TEditSteuerelement. Für die Schaltfläche "Return" gibt es kein bestimmtes Ereignis. In
diesem Abschnitt werden Ereignisbehandlungsroutinen für beide Szenarien
implementiert.
IMPLEMENTIEREN EINER ALLGEMEINEN METHODE ZUM ÖFFNEN EINER WEBSEITE
Implementieren Sie vor der Implementierung von Ereignisbehandlungsroutinen
zuerst eine allgemeine Methode zum Öffnen einer Webseite auf Basis der
Eigenschaft Text des TEdit-Steuerelements.
1. Erstellen Sie im Quelltext-Editor die folgende neue Zeile:
procedure OpenURL;
nach { Private-Deklarationen }
51
2. Drücken Sie STRG+UMSCHALT+C, um einen Platzhalter am Ende der Datei
einzufügen:
3. Implementieren Sie die Methode OpenURL wie in dem folgenden
Codefragment:
IMPLEMENTIEREN EINER EREIGNISBEHANDLUNGSROUTINE FÜR DAS EREIGNIS
"ONCHANGE"
1. Wählen Sie im Designer für mobile Formulare die Eingabe-Komponente
aus, und doppelklicken Sie dann im Objektinspektor (Registerkarte
Ereignisse) auf eine freie Stellen neben dem Ereignis OnChange, um die
Ereignisbehandlungsroutine zu erstellen.
Der Objektinspektor erstellt eine neue Ereignisbehandlungsroutine mit dem
Namen Edit1Change:
2. Stellen Sie die Ereignisbehandlungsroutine fertig, indem Sie den folgenden
Code hinzufügen:
52
IMPLEMENTIEREN EINER EREIGNISBEHANDLUNGSROUTINE ZUR UNTERSTÜTZUNG DER
EINGABETASTE
Für die Eingabetaste ist kein bestimmtes Ereignis definiert. Sie können aber
solche Ereignisse mit dem Ereignis OnKeyDown überwachen. OnKeyDown stellt
Informationen über die gedrückte Klasse durch mehrere Parameter in seiner
Ereignisbehandlungsroutine bereit. Sie können dieses Ereignis folgendermaßen
implementieren:
IMPLEMENTIEREN EINER EREIGNISBEHANDLUNGSROUTINE FÜR DIE "ZURÜCK"SCHALTFLÄCHE
Zum Implementieren einer Zurück-Schaltfläche für Ihren Webbrowser können Sie
einfach die Methode GoBack für die Webbrowser-Komponente aufrufen:
Das grundlegende Verhalten ist für diese Webbrowser-Anwendung jetzt
implementiert. Führen Sie die Anwendung entweder auf dem iOS-Simulator oder
auf einem iOS-Gerät aus.
SCHRITT 3: AUSWÄHLEN DER GEEIGNETEN TASTATUR FÜR DIE
WEBBROWSER-ANWENDUNG
Nach dem ersten Ausführen Ihrer Webbrowser-Anwendung stellen Sie
möglicherweise fest, dass die virtuelle Tastatur nicht optimal ist. iOS stellt die
folgenden virtuellen Tastaturen bereit:
53
vktAlphabet
vktDefault
vktEmailAddress
vktNamePhonePad
vktNumberPad
vktNumbersAnd
Punctuation
vktPhonePad
vktURL
Wählen Sie vktURL in der Eigenschaft KeyboardType als virtuelle Tastatur für das
Eingabe-Steuerelement aus:
SIEHE AUCH







iOS-Tutorial: Verwenden von Kombinationsfeld-Komponenten zur Auswahl
von Einträgen in iOS-Anwendungen
TWebBrowser
TToolBar
TButton
TEdit
KeyboardType
StyleLookup
54
REGISTERKARTEN-KOMPONENTEN ZUR
ANZEIGE VON SEITEN IN IOS-ANWENDUNGEN
REGISTER IN FIREMONKEY-ANWENDUNGEN FÜR IOS
Register werden von FMX.TabControl.TTabControl definiert. TTabControl ist ein
Container zur Aufnahme von mehreren Registerkarten:


Jede Registerkarte kann beliebige Steuerelemente als UI-Elemente
enthalten.
Sie können das Register für diese Seiten ausblenden und Seiten ohne
Anzeige der Register ändern.
Für jedes Register können Sie vordefinierte Symbole sowie benutzerdefinierte
Symbole und einen Beschriftungstext festlegen.
Register können am oberen oder unteren Rand des Steuerelements platziert
werden.
ENTWERFEN VON REGISTERKARTEN IM FORMULAR-DESIGNER
Führen Sie mit der Komponente TTabControl die folgenden Schritte aus, um
Registerkarten in einer Anwendung zu erstellen:
1. Erstellen Sie eine mobile FireMonkey-Anwendung. Wählen Sie
beispielsweise Datei > Neu > Mobile FireMonkey-Anwendung - Delphi >
Mobile HD-FireMonkey-Anwendung. Verwenden Sie die StandardZielplattform für iPhone (iOS-Simulator).
2. Wählen Sie in der Tool-Palette die Komponente TTabControl aus:
55
3. Nach dem Ablegen der TTabControl-Komponente wird im Designer für
mobile FireMonkey-Formulare ein leeres TabControl angezeigt:
4. Normalerweise wird für Anwendungen mit TabControl-Steuerelementen
zum Anzeigen der Seiten der Vollbildmodus verwendet. Dazu müssen Sie
die Standardausrichtung von TabControl ändern. Ändern Sie im
Objektinspektor die Eigenschaft Align von TabControl in alClient:
56
5. Klicken Sie mit der rechten Maustaste auf das TabControl-Steuerelement,
und wählen Sie im Kontextmenü Eintrags-Editor....
6. Klicken Sie dreimal auf Eintrag hinzufügen, damit drei Instanzen von
TabItem erstellt werden. Schließen Sie das Dialogfeld.
7. Wählen Sie im Designer für mobile FireMonkey-Formulare das erste
TabItem aus, und ändern Sie dessen Eigenschaft StyleLookup in
tabitembookmarks:
57
8. Sie können auf jeder Seite beliebige Komponenten platzieren. Um im
Formular-Designer zu einer anderen Seite zu wechseln, klicken Sie einfach
auf entsprechende Register, oder ändern Sie im Objektinspektor die
Eigenschaft ActiveTab:
9. Um die Position von Registern zu ändern, wählen Sie die Eigenschaft
TabPosition der TabControls-Komponente aus. Sie können im
Objektinspektor für jedes Register einen der folgenden Werte der
Eigenschaft TabPosition auswählen:
58
tpTop
Register werden
oben angezeigt.
tpBottom
Register werden
unten angezeigt.
tpDots
tpNone
Es werden keine
Register
angezeigt. Punkte
oder die Ellipse
([...]) werden
angezeigt, um
anzugeben, dass
weitere Seiten
vorhanden sind.
Es werden zur
Laufzeit keine
Register oder
Punkte angezeigt,
obwohl sie zur
Entwurfszeit
angezeigt
werden. Seiten
können nur durch
Code oder eine
Aktion geändert
werden.
VERWENDEN VON BENUTZERDEFINIERTEN SYMBOLEN FÜR
REGISTER
Sie können benutzerdefinierte Symbole sowie benutzerdefinierten Text für
Registerkarten anhand der folgenden Schritte verwenden:
59
1. Platzieren Sie eine TabControl-Komponente auf dem Formular, legen Sie
deren Ausrichtung fest (Eigenschaft Align), und erstellen Sie mehrere
Register:
2. Wählen Sie ein Register aus, und klicken Sie im Objektinspektor im Feld
"Bitmap" der Eigenschaft CustomIcon von TTabItem auf die EllipsenSchaltfläche [...]:
3. Wählen Sie im Dropdown-Menü Bearbeiten...:
4. Klicken Sie im Bitmap-Editor auf die Schaltfläche Laden..., und wählen Sie
eine PNG-Datei aus. Die empfohlene Größe beträgt für die normale
Auflösung 30x30 Pixel und für die hohe Auflösung 60x60 Pixel (das Symbol
BitmapHiRes wird im nächsten Schritt festgelegt):
60
5. Schließen Sie den Bitmap-Editor, und wählen Sie im Objektinspektor das
Symbol aus, das Sie für das Feld BitmapHiRes (hohe Auflösung) von
CustomIcon verwenden möchten.
6. Wählen Sie im Objektinspektor für die Eigenschaft StyleLookup den Eintrag
tabitemcustom aus.
7. Ändern Sie in der Eigenschaft Text den Text des Registers.
61
Die in diesem Tutorial verwendeten benutzerdefinierten Glyphen finden Sie im
Verzeichnis $(BDS)\Images\GlyFX.
Nach Festlegung eines benutzerdefinierten Symbols erzeugt das FireMonkeyFramework anhand der angegebenen PNG-Datei ein Bild für den ausgewählten
Zustand und ein Bild für den nicht ausgewählten (abgedunkelten) Zustand.
Diese Transformation wird mit dem Alphakanal der Bitmap-Daten durchgeführt.
Zum Beispiel:
Originalbild
Ausgewähltes Bild
Nicht ausgewähltes Bild
DEFINIEREN VON STEUERELEMENTEN IN EINEM TABCONTROL
Wie bereits erwähnt, kann jede Registerkarte eine beliebige Anzahl von
Steuerelementen, einschließlich eines weiteren TabControl, enthalten. In solchen
Fällen können Sie in der Strukturansicht verschiedene Registerkarten schnell
durchsuchen und verwalten:
62
63
WECHSELN DER SEITE ZUR LAUFZEIT
DURCH TIPPEN AUF DAS REGISTER
Wenn Register angezeigt werden (wenn die Eigenschaft TabPosition nicht auf
tpNone gesetzt ist), können Endbenutzer einfach auf die Register tippen, um
zwischen Seiten zu wechseln.
DURCH AKTIONEN UND EINE AKTIONSLISTE
Aktionen sind einem oder mehreren Elementen der Benutzeroberfläche
zugeordnet, z.B. Menübefehlen, Schaltflächen und Symbolleisten. Aktionen
dienen zwei Zwecken:


Aktionen stellen allgemeine Eigenschaften für
Benutzeroberflächenelemente dar, z.B. ob ein Steuerelement oder ein
Kontrollkästchen aktiviert ist.
Aktionen reagieren auf das Auslösen eines Steuerelements, beispielsweise
wenn der Anwendungsbenutzer auf eine Schaltfläche klickt oder einen
Menüeintrag auswählt.
Mit den folgenden Schritten ermöglichen Sie, dass Benutzer durch Klicken auf
eine Schaltfläche zu anderen Registerkarten wechseln können:
1. Platzieren Sie in einer mobilen FireMonkey-Anwendung ein TabControl,
und fügen Sie mehrere Registerelemente hinzu (TabItem1, TabItem2 und
TabItem3).
2. Fügen Sie aus der Tool-Palette dem Formular ein TButton-Steuerelement
und dann eine ActionList-Komponente hinzu:
64
3. Wählen Sie im Objektinspektor die Schaltflächen-Komponente und im
Dropdown-Menü Aktion > Neue Standardaktion > Registerkarte >
TChangeTabAction aus. Wenn der Benutzer auf diese Schaltfläche drückt,
wird die definierte Aktion ausgeführt (die Registerkarte wird gewechselt):
65
4. Wählen Sie in der Strukturansicht die Aktion ChangeTabAction1 und dann
für die Eigenschaft Tab im Objektinspektor TabItem2 aus. Durch
Verknüpfen von TabItem2 kann mit dieser Aktion die Seite in TabItem2
geändert werden:
5. Bei dem vorherigen Schritt wird die Beschriftung (die Eigenschaft Text) der
Schaltfläche automatisch in "Gehe zu Security" geändert, weil der Titel von
TabItem2 in diesem Beispiel "Security" ist. Ändern Sie die Größe der
Schaltfläche, damit die neue Beschriftung Platz hat, oder ändern Sie die
Eigenschaft CustomText der Komponente ChangeTabAction1 wie im
Folgenden gezeigt:
66
6. ChangeTabAction unterstützt auch die Slide-Animation zur Darstellung
eines Wechsels von Seiten. Setzen Sie dazu die Eigenschaft Transition auf
ttSlide:
DURCH QUELLCODE
Zum Ändern der aktiven Registerkarte im Quellcode können Sie eine der
folgenden drei Möglichkeiten verwenden:

Weisen Sie der Eigenschaft ActiveTab eine Instanz von TTabItem zu:
TabControl1.ActiveTab := TabItem1;

Setzen Sie die Eigenschaft TabIndex auf einen anderen Wert. Die
Eigenschaft TabIndex ist ein nullbasierter Integerwert (Sie können jede Zahl
zwischen 0 und TabControl1.TabCount - 1 angeben).
TabControl1.TabIndex := 1;

Wenn ChangeTabAction definiert ist, können Sie auch aus dem
Quellcode ein Aktion ausführen:
// You can set the target at run time if it is not defined yet.
ChangeTabAction1.Tab := TabItem2;
// Call the action
ChangeTabAction1.Execute;
67
SIEHE AUCH



iOS-Tutorial: Verwenden von Webbrowser-Komponenten in iOSAnwendungen
Tabellenansichten in iOS-Anwendungen
68
IOS-TUTORIAL: VERWENDEN VON LISTENFELDKOMPONENTEN ZUR ANZEIGE VON
TABELLENANSICHTEN IN IOS-ANWENDUNGEN
Auf der iOS-Plattform verwendet FireMonkey die Komponente
FMX.ListBox.TListBox zur Anzeige einer Tabellenansicht im iOS-Stil, wie diese
Listenfelder:
In diesem Tutorial werden die grundlegenden Schritte zum Erstellen von
Elementen für eine Tabellenansicht in einer FireMonkey-iOS-Anwendung
beschrieben.
ERSTELLEN VON ELEMENTEN FÜR DIE LISTBOX-KOMPONENTE
1. Wählen Sie Datei > Neu > Mobile FireMonkey-Anwendung - Delphi.
2. Wählen Sie in der Tool-Palette die Komponente TListBox aus, und ziehen
Sie sie in den Designer für mobile FireMonkey-Formulare. Geben Sie in das
Suchfeld der Tool-Palette einige Buchstaben (z.B. "tlist") ein, um TListBox
schnell zu finden:
69
3. Wählen Sie die TListBox-Komponente im Designer für mobile Formulare
aus, und wählen Sie im Objektinspektor für die Eigenschaft Align den Wert
alClient aus:
4. Klicken Sie im Designer für mobile FireMonkey-Formulare mit der rechten
Maustaste auf die TListBox-Komponente, und wählen Sie Eintrags-Editor:
70
5. Klicken Sie im Eintrags-Designer mehrmals auf die Schaltfläche Eintrag
hinzufügen, um der ListBox mehrere Einträge hinzuzufügen:
6. Schließen Sie den Eintrags-Designer. Die hinzugefügten ListBox-Einträge
werden nun in der TListBox-Komponente angezeigt. Zum Beispiel:
HINZUFÜGEN EINER KOPFZEILE
71
Mit den folgenden Schritten können Sie der TListBox-Komponente eine Kopfzeile
hinzufügen:
Maustaste auf die TListBox-Komponente, und wählen Sie Eintrag
hinzufügen > TListBoxHeader:
2. Wählen Sie in der Tool Palette die TLabel-Komponente aus, und ziehen Sie
sie auf die gerade hinzugefügte TListBoxHeader-Komponente:
3. Ändern Sie im Objektinspektor die Eigenschaften der TLabel-Komponente
folgendermaßen:
Eigenschaft
Align
Wert
alClient
StyleLookup toollabel
TextAlign
taCenter
Text
(Beliebiger Textwert)
72
HINZUFÜGEN EINER GRUPPENKOPFZEILE/-FUßZEILE ZU DER
LISTE
Sie können eine Gruppenkopfzeile und eine Gruppenfußzeile für Einträge in der
TListBox wie folgt hinzufügen:
Maustaste auf die TListBox-Komponente, und wählen Sie Eintrags-Editor.
2. Wählen Sie im Eintrags-Designer aus der Dropdown-Liste
TListBoxGroupHeader aus, und wählen Sie dann Eintrag hinzufügen:
3. Wählen Sie aus der Dropdown-Liste TListBoxGroupFooter aus, und wählen
Sie dann Eintrag hinzufügen.
4. Wählen Sie in der Liste mit den Einträgen ListBoxGroupHeader1 aus, und
klicken Sie mehrmals auf die Schaltfläche Nach oben, bis dieser Eintrag
ganz oben in der Liste steht:
73
5. Schließen Sie das Dialogfeld. Die TListBox-Komponente enthält jetzt eine
Gruppenkopfzeile und eine Gruppenfußzeile.
ANZEIGEN VON LISTENEINTRÄGEN ALS EIGENE GRUPPIERTE
EINTRÄGE
Einträge in einer ListBox können entweder als lineare Liste oder als gruppierte
Liste angezeigt werden. Diese Auswahlmöglichkeit wird von den Eigenschaften
GroupingKind und StyleLookup, wie in der folgenden Abbildung gezeigt,
gesteuert:
Anzeigen von Einträgen als lineare
Liste
Anzeigen von Einträgen als gruppierte
Liste
gsPlain = GroupingKind
Eigenschaftswert
gsGrouped = GroupingKind
Eigenschaftswert
listboxstyle = StyleLookup
Eigenschaftswert
transparentlistboxstyle = StyleLookup
Eigenschaftswert
Sie können im Objektinspektor für die TListBox-Komponente einen beliebigen Stil
auswählen.
74
HINZUFÜGEN EINES KONTROLLKÄSTCHENS ODER EINES
ANDEREN ELEMENTS ZU EINEM LISTBOX-EINTRAG
Jedem Eintrag in einer TListBox können mit der Eigenschaft ItemData.Accessory
Elemente, wie z.B. ein Häkchen, hinzugefügt werden. Die folgende Abbildung
zeigt die Werte, die Sie ItemData.Accessory und dem zugehörigen Element
zuweisen können:
Wenn der ListBox-Eintrag im Formular-Designer ausgewählt ist, können Sie im
Objektinspektor die Eigenschaft Accessory auswählen.
HINZUFÜGEN EINES SYMBOLS ZU EINEM LISTBOX-EINTRAG
Jedem Eintrag in einer ListBox-Komponente können mit der Eigenschaft
ItemData.Bitmap Bitmap-Daten als Symbol hinzugefügt werden:
75
Wenn der ListBox-Eintrag im Formular-Designer ausgewählt ist, können Sie im
Objektinspektor die Eigenschaft Bitmap auswählen.
HINZUFÜGEN VON DETAILINFORMATIONEN ZU EINEM EINTRAG
Sie können jedem Eintrag in der ListBox-Komponente zusätzliche
Textinformationen hinzufügen.
Geben Sie zusätzlichen Text in der Eigenschaft ItemData.Detail an, und legen Sie
die Position des Detailtextes in der Eigenschaft StyleLookup, wie in der folgenden
Tabelle gezeigt, fest:
Eigenschaft "StyleLookup"
Darstellung
listboxitemnodetail
listboxitembottomdetail
listboxitemrightdetail
listboxitemleftdetail
76
PROGRAMMSEITIGES HINZUFÜGEN VON EINTRÄGEN ZU EINER
LISTBOX
Zum Hinzufügen von Standardeinträgen zu einer ListBox können Sie einfach die
Methode Items.Add wie im folgenden Code aufrufen:
ListBox1.Items.Add('Text to add');
Wenn Sie andere Einträge als Standardeinträge hinzufügen oder andere
Eigenschaften steuern möchten, können Sie zuerst eine Instanz von dem Eintrag
erstellen und ihn dann der Liste hinzufügen.
Der folgende Code fügt einer ListBox die in der Abbildung gezeigten Einträge
hinzu:
77
var
c: Char;
i: Integer;
Buffer: String;
ListBoxItem : TListBoxItem;
ListBoxGroupHeader : TListBoxGroupHeader;
begin
ListBox1.BeginUpdate;
for c := 'a' to 'z' do
begin
// Add header ('A' to 'Z') to the List
ListBoxGroupHeader := TListBoxGroupHeader.Create(ListBox1);
ListBoxGroupHeader.Text := UpperCase(c);
ListBox1.AddObject(ListBoxGroupHeader);
// Add items ('a', 'aa', 'aaa', 'b', 'bb', 'bbb', 'c', ...) to the list
for i := 1 to 3 do
begin
// StringOfChar returns a string with a specified number of repeating
characters.
Buffer := StringOfChar(c, i);
// Simply add item
// ListBox1.Items.Add(Buffer);
// or, you can add items by creating an instance of TListBoxItem by yourself
ListBoxItem := TListBoxItem.Create(ListBox1);
ListBoxItem.Text := Buffer;
// (aNone=0, aMore=1, aDetail=2, aCheckmark=3)
ListBoxItem.ItemData.Accessory := TListBoxItemData.TAccessory(i);
ListBox1.AddObject(ListBoxItem);
end;
end;
ListBox1.EndUpdate;
end;
HINZUFÜGEN EINES SUCHFELDES
Sie können einer ListBox ein Suchfeld hinzufügen. Mit Suchfeldern können
Benutzer schnell eine Auswahl in einer langen Liste treffen (siehe die folgenden
Abbildungen):
78

Klicken Sie zum Hinzufügen eines Suchfeldes mit der rechten Maustaste
auf die TListBox-Komponente, und wählen Sie im Kontextmenü einfach
Eintrag hinzufügen > TSearchBox aus:
SIEHE AUCH




FMX.ListBox.TListBox
iOS-Tutorial: Verwenden von Registerkarten-Komponenten zur Anzeige
von Seiten in iOS-Anwendungen
79
IOS-TUTORIAL: VERWENDEN VON LAYOUTS
ZUR AUSRICHTUNG UNTERSCHIEDLICHER
FORMULARGRÖßEN IN IOS-ANWENDUNGEN
In diesem Tutorial wird eine allgemeine Strategie für die Verwendung eines
gemeinsamen Formulars für verschiedene Standards (wie iPhone und iPad)
beschrieben. Unterschiedliche Formulare für verschiedene Standards werden
dafür nicht benötigt.
Im Designer für mobile FireMonkey-Formulare können Sie die
Benutzeroberfläche in der Vorschau anzeigen, ohne dafür die Anwendung auf
einem Gerät ausführen zu müssen – ändern Sie einfach in der Dropdown-Liste in
der rechten oberen Ecke das Gerät oder die Ausrichtung:
JEDE FIREMONKEY-KOMPONENTE KANN EINEN BESITZER, EIN
ÜBERGEORDNETES OBJEKT UND UNTERGEORDNETE OBJEKTE
HABEN
Jede FireMonkey-Komponente beinhaltet das Konzept von Besitzer,
übergeordnetem Objekt und untergeordneten Objekten. Wenn Sie eine
Komponente auf einem Formular platzieren, wird das Formular zum Besitzer und
zum übergeordneten Objekt der Komponente.
Wenn Sie einer Komponente (z.B. einer Symbolleiste) Komponenten (z.B. eine
Schaltfläche, eine Beschriftung usw.) hinzufügen, ist die Symbolleiste (ToolBar)
gleichzeitig übergeordnetes Objekt und Besitzer der Schaltfläche, der
Beschriftung usw. Diese Über-/Untergeordnet-Beziehung wird grafisch in der
Baumansicht in der Strukturansicht dargestellt.
Das Layout eines untergeordneten Objekts ist als Wert relativ zum
übergeordneten Objekt definiert. In der folgenden Abbildung ist Label1 Toolbar1
untergeordnet, und das Layout von Label1 ist relativ zu Toolbar1.
80
VERWENDEN VON ALLGEMEINEN LAYOUTBEZOGENEN
EIGENSCHAFTEN EINER FIREMONKEY-KOMPONENTE
VERWENDEN DER EIGENSCHAFT "ALIGN"
Die Eigenschaft Align eines Steuerelements bestimmt, ob es automatisch
entlang der vier Seiten oder in der Mitte des übergeordneten Objekts neu
positioniert wird und/oder dessen Größe geändert wird, sowohl als
Ausgangseinstellung als auch bei Größenänderungen des übergeordneten
Objekts. Der Vorgabewert für die Eigenschaft Align ist alNone, d.h., dass keine
automatischen Berechnungen durchgeführt werden: das Steuerelement
verbleibt an seiner Position.
Typische Werte für die Eigenschaft Align sind folgende (Azurblau gibt den
Bereich für das untergeordnete Objekt an):
alNone
alTop
alBottom
alLeft
alRight
alCenter
alClient
Wenn Sie für eine Komponente einen Align-Wert von alTop, alBottom, alLeft
oder alRight festlegen, verwenden die Align-Eigenschaften der anderen
Komponenten den verbleibenden Bereich.
Die Größe und Form des verbleibenden Bereichs (alClient) werden auch auf
Basis der Geräteausrichtung und des Standards (iPhone oder iPad) geändert.
Die folgenden Abbildungen zeigen das Layout im Querformat (horizontal) und
im Hochformat (vertikal) für drei Komponenten, wobei für zwei die Ausrichtung
alTop und für die dritte alClient festgelegt ist.
81
VERWENDEN DER EIGENSCHAFT "MARGINS"
Der Außenabstand (Margins) sorgt für die Trennung zwischen automatisch von
einem übergeordneten Objekt positionierten Steuerelementen.
In der folgenden Abbildung ist für die rechte Seite der Komponente (alClient)
die Eigenschaft Margins festgelegt, damit um die Komponente Platz frei bleibt.
VERWENDEN DER EIGENSCHAFT "PADDING"
Der Innenabstand (Padding) spart Platz innerhalb der Inhaltsbox des
übergeordneten Objekts aus. Im Objektinspektor können Sie Werte (in Pixel) für
Padding festlegen:




Links
Rechts
Unten
Oben
In der folgenden Abbildung ist für die übergeordnete Komponente (die zwei
Bereiche enthält) die Eigenschaft Padding festgelegt, damit innerhalb der
übergeordneten Komponente Platz frei bleibt:
82
VERWENDEN DER EIGENSCHAFT "ANCHORS"
Anker (Anchors) werden benötigt, wenn ein Steuerelement seine Position in
einem bestimmten Abstand zu den Rändern des übergeordneten
Steuerelements beibehalten muss oder vergrößert werden muss und trotzdem
der ursprüngliche Abstand zwischen seinen Rändern und denjenigen des
übergeordneten Steuerelements beibehalten werden muss. Verankerte
Steuerelemente "kleben" an den Seiten des Containers und werden auch
vergrößert, falls angegeben.
Eigenschaft "Anchors" für Eingabe-Steuerelemente
Angenommen, für ein Eingabe-Steuerelement auf einer Symbolleiste (ToolBar)
soll ein fester Abstand zwischen dem rechten Rand des Eingabe-Steuerelements
und dem Formularrand (ToolBar) beibehalten werden. Mit Ankern können Sie
festlegen, dass ein Steuerelement in Bezug auf die Seiten seines übergeordneten
Objekts unveränderlich bleiben soll.
Wenn Sie möchten, dass das Eingabe-Steuerelement in Bezug auf ToolBar (das
übergeordnete Objekt) dieselbe relative Position beibehalten soll, können Sie
die Eigenschaft Anchors auf akLeft, akTop, akRight setzen. Wenn die Größe von
ToolBar geändert wird, wird auch die Größe des Eingabe-Steuerelements
entsprechend den Anchors-Einstellungen geändert:
Eigenschaft "Anchors" für Schaltflächen-Steuerelemente
Angenommen, für ein Schaltflächen-Steuerelement, das sich am rechten Ende
der Symbolleiste (ToolBar) befindet, soll derselbe Abstand zwischen dem rechten
Rand des Schaltflächen-Steuerelements und dem Rand des Formulars
83
beibehalten werden. Es soll aber nicht derselbe Abstand zwischen dem linken
Rand des Schaltflächen-Steuerelements und dem linken Rand des Formulars
beibehalten werden. In diesem Fall können Sie die Eigenschaft Anchors auf
akTop, akRight setzen (wählen Sie akLeft nicht aus), sodass das SchaltflächenSteuerelement für Top und Right denselben Abstand zu ToolBar (übergeordnet)
beibehält.
VERWENDEN DER KOMPONENTE "TLAYOUT"
Mit der Komponente TLayout, die zur Laufzeit nicht sichtbar ist, können
untergeordnete Steuerelemente für die gemeinsame Bearbeitung gruppiert
werden. Sie können beispielsweise die Sichtbarkeit einer Gruppe von
Steuerelementen gleichzeitig festlegen, indem Sie nur die Eigenschaft Visible des
Layouts setzen. TLayout legt keine der Eigenschaften der untergeordneten
Steuerelemente automatisch fest.
In der Strukturansicht können Sie ausgewählte Steuerelemente als TLayout
untergeordnet festlegen.
Markieren Sie die Steuerelemente, die Sie verschieben möchten. Ziehen Sie
dann die Gruppe der Steuerelemente auf das Steuerelement, das das
übergeordnete Objekt sein soll, und legen Sie die Steuerelemente dort ab. In der
Strukturansicht ist die Gruppe der Steuerelemente jetzt dem neuen
übergeordneten Objekt untergeordnet:
1. Anfangsstatus
2. Zu verschiebende
Steuerelemente
markieren
3. Auf das
übergeordnete Objekt
ziehen
84
Mit den TLayout-Eigenschaften Align, Padding, Margins, Anchors und anderen
können Sie das Layout für einen bestimmten Bereich festlegen. Die TLayoutKomponente kann genauso wie das DIV-Tag in HTML verwendet werden.
ARBEITEN MIT VOLLEN BENUTZEROBERFLÄCHEN: VERWENDEN
VON TVERTSCROLLBOX-KOMPONENTEN
Im Allgemeinen sollten Formulare nicht zu viele Elemente enthalten, damit
Benutzer nicht zum Verschieben des Bildschirminhalts gezwungen sind. In vielen
Fällen können Sie mit einer TabControl-Komponente mit mehreren Seiten das
Verschieben des Bildschirminhalts vermeiden.
Wenn Sie aber viele Elemente auf einem Formular platzieren müssen, können Sie
mit einer TVertScrollBox-Komponente einen Verschiebe-Bereich wie folgt
definieren:
1. Wählen Sie im Designer für mobile FireMonkey-Formulare die Option
Benutzerdefiniertes Gerät aus.
2. Ändern Sie die Größe des benutzerdefinierten Geräts, indem Sie den Rand
des Designers bis zur gewünschten Form und Größe aufziehen.
3. Legen Sie eine TVertScrollBox-Komponente auf dem Formular ab, und
setzen Sie deren Eigenschaft Align auf alClient. Dies bewirkt, dass die
TVertScrollBox den gesamten Client-Bereich ausfüllt.
4. Legen Sie Komponenten auf der TVertScrollBox-Komponente ab:
85
Der Inhalt dieses Formulars kann zur Laufzeit durch Streifen über die
Benutzeroberfläche verschoben werden.
SIEHE AUCH






iOS-Tutorial: Verwenden von Positionssensoren auf iOS-Geräten
Tutorial: Verwenden von FireMonkey-Layouts
Strategien für FireMonkey-Layouts
Anordnen von FireMonkey-Steuerelementen
Gesten in FireMonkey
86
IOS-TUTORIAL: AUFNEHMEN UND TEILEN VON
BILDERN IN IOS-ANWENDUNGEN
durcharbeiten:

In diesem Tutorial werden die folgenden typischen Aufgaben für die
Verwendung von Fotos in iOS-Anwendungen behandelt:
Aufnehmen eines Fotos mit
der iOS-Gerätekamera
Verwenden eines Fotos
aus der Fotobibliothek
des iOS-Geräts
Teilen oder Drucken
eines Fotos
Diese Funktionen werden als Aktionen bereitgestellt, und Sie müssen für jede
Aufgabe nur eine Codezeile schreiben.
Aktionen sind einem oder mehreren Elementen der Benutzeroberfläche
zugeordnet, z.B. Menübefehlen, Schaltflächen und Symbolleisten.
Aktionen dienen zwei Zwecken:

Eine Aktion kann allgemeine Eigenschaften für
Benutzeroberflächenelemente darstellen, z.B. ob ein Steuerelement oder
ein Kontrollkästchen aktiviert ist.
87

Eine Aktion kann auf das Auslösen eines Steuerelements reagieren,
beispielsweise wenn der Benutzer auf eine Schaltfläche klickt oder einen
Menüeintrag auswählt.
In diesem Tutorial wird gezeigt, wie Sie Benutzeroberflächenelementen (z.B. einer
Schaltfläche) Aktionen für jede Funktion, die Sie unterstützen möchten,
zuweisen.
ERSTELLEN DER BENUTZEROBERFLÄCHE FÜR DIE
ANWENDUNG
Die Benutzeroberfläche dieser Beispielanwendung ist sehr einfach (siehe die
folgende Abbildung):
Legen Sie im Formular-Designer die folgenden Komponenten ab:



TToolBar
o Drei TButton-Komponenten. Jede Schaltfläche verwendet andere
Symbole.
o Setzen Sie die Eigenschaft StyleLookup der drei Schaltflächen auf
cameratoolbuttonbordered, searchtoolbuttonbordered, bzw.
actiontoolbuttonbordered.
TImage
o Setzen Sie die Eigenschaft Align auf alClient.
TActionList
88
AUFNEHMEN EINES FOTOS MIT DER IOS-GERÄTEKAMERA
Sie können eine Aktion zum Aufnehmen eines Fotos mit der Kamera auf dem
iOS-Gerät mit den folgenden Schritten festlegen:
1. Wählen Sie im Formular-Designer die Schaltfläche (zum Aufnehmen eines
Fotos) aus.
2. Öffnen Sie im Objektinspektor die Dropdown-Liste der Eigenschaft Action.
3. Wählen Sie Neue Standardaktion | Medienbibliothek |
TTakePhotoFromCameraAction:
4. Erweitern Sie auf der Registerkarte Ereignisse den Knoten Action, und
doppelklicken Sie auf das Ereignis OnDidFinishTaking.
5. Fügen Sie der OnDidFinishTaking-Ereignisbehandlungsroutine den
folgenden Code hinzu:
procedure TForm1.TakePhotoFromCameraAction1DidFinishTaking(Image: TBitmap);
begin
Image1.Bitmap.Assign(Image);
end;
Mit diesem Code wird ein mit der iOS-Gerätekamera aufgenommenes Fotos der
Eigenschaft Bitmap der Komponente TImage zugewiesen.
89
VERWENDEN EINES FOTOS AUS DER FOTOBIBLIOTHEK DES
IOS-GERÄTS
Sie können eine Aktion für die Verwendung eines Fotos aus der Fotobibliothek
mit den folgenden Schritten festlegen:
1. Wählen Sie im Formular-Designer die Schaltfläche aus, die für das
Auswählen eines Fotos verwendet werden soll.
2. Klicken Sie im Objektinspektor auf die Dropdown-Liste für die Eigenschaft
Action, und wählen Sie Neue Standardaktion | Medienbibliothek |
TTakePhotoFromLibraryAction.
doppelklicken Sie auf das Ereignis OnDidFinishTaking.
4. Fügen Sie der OnDidFinishTaking-Ereignisbehandlungsroutine den
procedure TForm1.TakePhotoFromLibraryAction1DidFinishTaking(Image: TBitmap);
begin
Image1.Bitmap.Assign(Image);
end;
Mit diesem Code wird ein aus der Fotobibliothek übernommenes Foto der
Eigenschaft Bitmap der Komponente TImage zugewiesen.
90
TEILEN ODER DRUCKEN EINES FOTOS
Von einer iOS-App aus können Sie Fotos auf sozialen Netzwerksites (wie
Facebook und Twitter) teilen, Fotos an einen Drucker senden, Fotos als Anlage
für E-Mails verwenden, Fotos Kontakten zuordnen usw.
Dieser Dienst für das vielfache Teilen wird als "Teilfelder"-Funktionalität
bezeichnet, und Sie können diese Funktionalität mit den folgenden Schritten
implementieren:
1. Wählen Sie im Formular-Designer eine Schaltfläche (zum Teilen eines
Fotos) aus.
2. Klicken Sie im Objektinspektor auf die Dropdown-Liste für die Eigenschaft
Action, und wählen Sie Neue Standardaktion | Medienbibliothek |
ShowShareSheetAction.
doppelklicken Sie auf das Ereignis OnBeforeExecute.
4. Fügen Sie der OnBeforeExecute-Ereignisbehandlungsroutine den
procedure TForm1.ShowShareSheetAction1BeforeExecute(Sender: TObject);
begin
ShowShareSheetAction1.Bitmap.Assign(Image1.Bitmap);
end;
91
Mit dem obigen Code wird ein Foto auf der TImage-Komponente der
"'Teilfelder'-Funktionalität" zugewiesen.
Nach Auswahl von Facebook aus der Liste der Dienste können Sie das Foto auf
Facebook mit Ihrem Kommentar posten:
SIEHE AUCH







iOS-Tutorial: Verwenden der Mitteilungszentrale auf iOS-Geräten
FireMonkey-Aktionen
FMX.StdCtrls.TButton
FMX.Objects.TImage
FMX.MediaLibrary
http://appleinsider.com/articles/12/02/16/share_sheets_twitter_integration
_to_make_mountain_lion_more_social/
92
POSITIONSSENSOREN AUF IOS-GERÄTEN
Bevor Sie mit diesem Tutorial beginnen, sollten Sie die folgenden Tutorials
durcharbeiten:



Formulargrößen in iOS-Anwendungen
In diesem Tutorial sind die grundlegenden Schritte zum Lokalisieren Ihres iOSGerätes (anhand der geografischen Breite und Länge) und zum Verwenden der
Rückwärts-Georeferenzierung für die Umwandlung dieser Daten in eine lesbare
Adresse beschrieben, wie in der folgenden Abbildung dargestellt:
93
ENTWERFEN DER BENUTZEROBERFLÄCHE
Diese Demo-Anwendung enthält zwei Hauptkomponenten: eine TListBox (auf
der linken Seite) und einen TWebBrowser.

Setzen Sie für die TListBox die Eigenschaft Align auf alLeft, um die linke
Seite der UI für die Komponente zu reservieren. Erstellen Sie anschließend
die folgenden Unterkomponenten für die ListBox:
o eine TListBoxHeader-Komponente mit den folgenden
Unterkomponenten:
 eine TLabel-Komponente zum Anzeigen des Titels "Location
Demo"
 eine Switch-Komponente (Switch1) zum Ein- und Ausschalten
von TLocationSensor
o eine TListBoxGroupHeader-Komponente mit dem Text "Your
Location"
o eine TListBoxItem-Komponente mit dem Namen
"ListBoxItemLatitude" und dem Text "Latitude"
"ListBoxItemLongitude" und dem Text "Longitude"
o eine TListBoxGroupHeader-Komponente mit dem Text "Current
Address"
"ListBoxItemAdminArea" und dem Text "AdminArea"
"ListBoxItemCountryCode" und dem Text "CountryCode"
94
eine TListBoxItem-Komponente mit dem Namen
"ListBoxItemCountryName" und dem Text "CountryName"
"ListBoxItemFeatureName" und dem Text "FeatureName"
o eine TListBoxItem-Komponente mit dem Namen "ListBoxItemLocality"
und dem Text "Locality"
"ListBoxItemPostalCode" und dem Text "PostalCode"
"ListBoxItemSubAdminArea" und dem Text "SubAdminArea"
"ListBoxItemSubLocality" und dem Text "SubLocality"
"ListBoxItemSubThoroughfare" und dem Text "SubThoroughfare"
"ListBoxItemThoroughfare" und dem Text "Thoroughfare"
eine TWebBrowser-Komponente (WebBrowser1) zum Anzeigen der
Webseite (Google Maps). Setzen Sie die Eigenschaft Align auf alClient.
o

Wählen Sie anschließend alle TListBoxItem-Elemente aus, und wählen Sie in der
Eigenschaft StyleLookup den Wert listboxitemleftdetail aus. Damit legen Sie fest,
dass in TListBoxItem eine Beschriftung und detaillierter Text angezeigt werden
kann.
DER POSITIONSSENSOR
Der Positionssensor ist in der Komponente TLocationSensor gekapselt.
TLocationSensor löst ein OnLocationChanged-Ereignis aus, wenn das Gerät eine
Bewegung erkennt. Die Empfindlichkeit von TLocationSensor können Sie mit der
Eigenschaft Distance einstellen. Wenn Sie "Distance" auf "10" setzen, löst
TLocationSensor ein OnLocationChanged-Ereignis aus, wenn Sie sich 10 Meter
von der aktuellen Position weg bewegen.
ABRUFEN DER POSITIONSINFORMATIONEN (GEOGRAFISCHE
BREITE UND LÄNGE) VON DER LOCATIONSENSORKOMPONENTE
Zuerst müssen Sie die TLocationSensor-Komponente aktivieren. Sie können
TLocationSensor auf Basis Ihrer Eingabe, wie z.B. einer TSwitch-Komponente, oder
anderer Anwendungsereignisse ein- und ausschalten.
95
Im folgenden Codefragment wird TLocationSensor aufgrund der Änderung des
Wertes in der Komponente TSwitch gesteuert:
procedure TForm44.Switch1Switch(Sender: TObject);
begin
LocationSensor1.Active := Switch1.IsChecked;
end;
Wie bereits weiter oben erwähnt, löst TLocationSensor ein OnLocationChangedEreignis aus, wenn das iOS-Gerät bewegt wird. Sie können die aktuelle Position
(geografische Breite und Länge) mithilfe von Parametern für diese
Ereignisbehandlungsroutine wie folgt anzeigen:
procedure TForm44.LocationSensor1LocationChanged(Sender: TObject;
const OldLocation, NewLocation: TLocationCoord2D);
begin
// Show current location
ListBoxItemLatitude.ItemData.Detail := NewLocation.Latitude.ToString;
ListBoxItemLongitude.ItemData.Detail := NewLocation.Longitude.ToString;
end;
96
ANZEIGEN DER AKTUELLEN POSITION MIT GOOGLE MAPS ÜBER
EINE TWEBBROWSER-KOMPONENTE
Wie im iOS-Tutorial: Verwenden von Webbrowser-Komponenten in iOSAnwendungen erläutert, kapselt die TWebBrowser-Komponente einen
Webbrowser für iOS.
Sie können Google Maps aus der TWebBrowser-Komponente mit den folgenden
URL-Parametern aufrufen: https://maps.google.com/maps?q=(Latitudevalue),(Longitude-value)&output=embed
Diesen URL können Sie der zuvor erstellten OnLocationChangedEreignisbehandlungsroutine wie folgt hinzufügen:
var
URLString: String;
begin
// code for previous step goes here
// Show Map using Google Maps
URLString := Format(
'https://maps.google.com/maps?q=%s,%s&output=embed',
[NewLocation.Latitude.ToString, NewLocation.Longitude.ToString]);
WebBrowser1.Navigate(URLString);
end;
VERWENDEN DER RÜCKWÄRTS-GEOREFERENZIERUNG
TGeocoder ist ein Objekt, das den Georeferenzierungsdienst (oder den
Rückwärts-Georeferenzierungsdienst) kapselt.
Georeferenzierung ist der Vorgang des Umwandelns von geografischen Daten,
wie Adresse und Postleitzahl, in geografische Koordinaten. RückwärtsGeoreferenzierung ist der Vorgang des Umwandelns von geografischen
Koordinaten in andere geografische Daten, wie eine Adresse.
In diesem Beispiel wird mit TGeocoder die Position (geografische Breite und
Länge) per "Rückwärts-Georeferenzierung" in lesbare Adressdaten
umgewandelt.
Dafür wird für TGeocoder der folgende grundlegende Aktionsablauf
durchgeführt:
97
1. Erstellen einer Instanz von TGeocoder
2. Definieren eines OnGeocodeReverse-Ereignisses, damit das Ereignis später
empfangen werden kann.
3. Festlegen von Daten für die Ausführung der "RückwärtsGeoreferenzierung".
4. TGeocoder greift auf den Dienst im Netzwerk zu, um die
Adressinformationen aufzulösen.
5. TGeocoder löst ein OnGeocodeReverse-Ereignis aus.
6. Die iOS-App empfängt die Adressinformationen über die Parameter im
OnGeocodeReverse-Ereignis und aktualisiert die Benutzeroberfläche.
Weil TGeocoder keine Komponente (sondern nur eine Klasse) ist, müssen Sie
diese Schritte im Code festlegen (Sie können auf dem Formular weder eine
Komponente ablegen, noch im Objektinspektor eine
Ereignisbehandlungsroutine zuweisen).
Zuerst definieren Sie im private-Abschnitt des Formulars ein neues Feld
"FGeocoder: TGeocoder". Sie können auch eine "OnGeocodeReverseEvent"Prozedur wie im folgenden Codefragment definieren.
type
TForm44 = class(TForm)
// IDE defines visible (or non-visual) components here automatically
private
{ Private declarations }
FGeocoder: TGeocoder;
procedure OnGeocodeReverseEvent(const Address: TCivicAddress);
public
{ Public declarations }
end;
Wechseln Sie anschließend in die Zeile von <wikibold>OnGeocodeReverseEvent</wiki-bold>, und drücken Sie
<code>STRG+UMSCHALT+C</code>. Dadurch wird die folgende Prozedur (die
später verwendet wird) im Code angelegt:
procedure TForm44.OnGeocodeReverseEvent(const Address: TCivicAddress);
begin
end;
Jetzt können Sie eine Instanz von TGeocoder erstellen, und sie mit dem
folgenden Code mit Daten einrichten.
98
TGeocoder.Current gibt den Typ der Klasse an, die den
Georeferenzierungsdienst implementiert. Der Code in TGeocoder.Current.Create
ruft den Konstruktor (Create) für den angegebenen Typ auf, und speichert ihn
im Feld FGeocoder. Sie sollten auch eine Ereignisbehandlungsroutine festlegen,
die ausgelöst wird, wenn TGeocoder die Rückwärts-Georeferenzierung
ausgeführt hat. Weisen Sie OnGeocodeReverseEvent (im vorherigen Schritt
definiert) zu FGeocoder.OnGeocodeReverse zu.
Wenn Sie erfolgreich eine Instanz von TGeocoder erstellt haben und TGeocoder
nicht ausgeführt wird, rufen Sie TGeocoder.GeocodeReverse mit den
Positionsinformationen auf. Wenn TGeocoder Daten empfängt, wird das Ereignis
OnGeocodeReverseEvent ausgelöst.
begin
// code for previous steps goes here
// Setup an instance of TGeocoder
if not Assigned(FGeocoder) then
begin
if Assigned(TGeocoder.Current) then
FGeocoder := TGeocoder.Current.Create;
if Assigned(FGeocoder) then
FGeocoder.OnGeocodeReverse := OnGeocodeReverseEvent;
end;
// Translate location to address
if Assigned(FGeocoder) and not FGeocoder.Geocoding then
FGeocoder.GeocodeReverse(NewLocation);
end;
99
ANZEIGEN EINER LESBAREN ADRESSE IN DER LISTBOXKOMPONENTE
Wie weiter oben beschrieben, wird ein OnGeocodeReverseEvent-Ereignis
ausgelöst, nachdem die Rückwärts-Georeferenzierung abgeschlossen ist.
Als Nächstes weisen Sie im Adressparameter TCivicAddress Eigenschaften zu, um
lesbare Adressdaten in den Feldern des Listenfeldes anzuzeigen:
procedure TForm44.OnGeocodeReverseEvent(const Address: TCivicAddress);
begin
ListBoxItemAdminArea.ItemData.Detail
:= Address.AdminArea;
ListBoxItemCountryCode.ItemData.Detail
:= Address.CountryCode;
ListBoxItemCountryName.ItemData.Detail
:= Address.CountryName;
ListBoxItemFeatureName.ItemData.Detail
:= Address.FeatureName;
ListBoxItemLocality.ItemData.Detail
:= Address.Locality;
ListBoxItemPostalCode.ItemData.Detail
:= Address.PostalCode;
ListBoxItemSubAdminArea.ItemData.Detail
:= Address.SubAdminArea;
ListBoxItemSubLocality.ItemData.Detail
:= Address.SubLocality;
ListBoxItemSubThoroughfare.ItemData.Detail := Address.SubThoroughfare;
ListBoxItemThoroughfare.ItemData.Detail
:= Address.Thoroughfare;
end;
SIEHE AUCH




Formulargrößen in iOS-Anwendungen
iOS-Tutorial: Verwenden der Mitteilungszentrale auf iOS-Geräten
System.Sensors.TGeocoder
FMX.Sensors.TLocationSensor
100
IOS-TUTORIAL: VERWENDEN DER
MITTEILUNGSZENTRALE AUF IOS-GERÄTEN
In diesem Tutorial werden die grundlegenden Schritte zur Verwendung der
Mitteilungszentrale für iOS-Geräte beschrieben.
DREI GRUNDLEGENDE MITTEILUNGS- ODER HINWEISSTILE
Wenn Benutzer Mitteilungen für Apps auf ihren iOS-Geräten festlegen, können
diese von Apps in den hier dargestellten drei grundlegenden Stilen angezeigt
werden. Das Banner erscheint kurz, aber Hinweise erfordern eine Benutzeraktion.
KENNZEICHEN AUF DEM ANWENDUNGSSYMBOL
MITTEILUNGSBANNER AUF DEM IPAD
MITTEILUNGSHINWEIS
MITTEILUNGSZENTRALE AUF DEM IPAD
Die folgende Abbildung zeigt die iPad-Mitteilungszentrale. Benutzer können die
Liste mit den neuesten Mitteilungen vom oberen Bildschirmrand
"herunterziehen":
101
ZUGREIFEN AUF DEN MITTEILUNGSDIENST
Das Mitteilungsdienst-Interface (IFMXNotificationCenter) ist als FireMonkeyPlattformdienst (TPlatformServices) definiert.
Um auf den Mitteilungsdienst zuzugreifen, müssen Sie Folgendes ausführen:

Fügen Sie der uses-Klausel die folgenden zwei Units hinzu, sofern sie nicht
bereits vorhanden sind:
uses
FMX.Platform, FMX.Notification;

Führen Sie mit folgendem Code eine Abfrage der FireMonkeyMitteilungsdienste aus:
var
NotificationService: IFMXNotificationCenter;
begin
if TPlatformServices.Current.SupportsPlatformService(IFMXNotificationCenter) then
NotificationService :=
TPlatformServices.Current.GetPlatformService(IFMXNotificationCenter)
as IFMXNotificationCenter;
// Use the Notification Service
end;
Das Interface IFMXNotificationCenter stellt grundlegende Dienste für die
Verwendung der Zahl auf dem Kennzeichensymbol sowie für die Mitteilung
selbst bereit.
102
FESTLEGEN DER ZAHL AUF DEM KENNZEICHENSYMBOL IM
CODE
IFMXNotificationCenter legt mit der Methode SetIconBadgeNumber die Zahl auf
dem Kennzeichensymbol fest:
procedure TForm1.SerIconBadgeNumber;
var
begin
// Reset Icon Badge Number
if Assigned(NotificationService) then
NotificationService.SetIconBadgeNumber(18);
end;
Nachdem Setzen der Zahl auf dem Kennzeichensymbol auf 18 wird sie auf dem
iOS-Startbildschirm angezeigt.
Mit der Methode ResetIconBadgeNumber können Sie die Zahl auf dem
Kennzeichensymbol zurücksetzen:
procedure TForm1.ResetIconBadgeNumber;
var
begin
// Set Icon Badge Number
NotificationService.ResetIconBadgeNumber;
end;
103
PLANEN VON MITTEILUNGEN
Mit der Methode ScheduleNotification können Sie Mitteilungen planen.
Um eine Mittelung anzuzeigen, müssen Sie eine Instanz der Klasse TNotification
erstellen und dann den Namen (Bezeichner) und die Mitteilung festlegen:
procedure TForm1.ScheduleNotification;
var
Notification: TNotification;
begin
begin
Notification := TNotification.Create;
try
Notification.Name := 'MyNotification';
Notification.AlertBody := 'Delphi for iOS is here!';
// Fired in 10 second
Notification.FireDate := Now + EncodeTime(0,0,10,0);
// Send notification in Notification Center
NotificationService.ScheduleNotification(Notification);
finally
Notification.Free;
end;
end
end;
Nachdem Festlegen der Mitteilung wird sie oben auf dem iOS-Startbildschirm
angezeigt.
104
AKTUALISIEREN ODER ABBRECHEN VON GEPLANTEN
MITTEILUNGEN
Jede geplante Mitteilung ist durch die Eigenschaft Name des TNotificationObjekts eindeutig festgelegt.
Um eine geplante Mitteilung zu aktualisieren, rufen Sie einfach erneut
ScheduleNotification mit einer Instanz von TNotification auf, die denselben
Namen hat (Eigenschaft "Name").
Um eine geplante Mitteilung abzubrechen, rufen Sie die Methode
CancelNotification mit dem verwendeten Bezeichner auf:
procedure TForm1.CancelNotification;
var
begin
NotificationService.CancelNotification('MyNotification');
end;
105
SOFORTIGES ANZEIGEN DER MITTEILUNG
Sie können eine Mitteilung sofort mit der Methode PresentNotification anzeigen.
Um eine Mittelung anzuzeigen, müssen Sie ein Instanz der Klasse TNotification
erstellen und dann den Namen (Bezeichner) und die Mitteilung festlegen:
procedure TForm1.PresentNotification;
var
Notification: TNotification;
begin
begin
try
// Set Icon Badge Number as well
Notification.ApplicationIconBadgeNumber := 18;
// Show Notification Message
NotificationService.PresentNotification(Notification);
finally
Notification.Free;
end;
end;
end;
106
MITTEILUNGSBANNER ODER MITTEILUNGSHINWEIS
Standardmäßig zeigt Ihre Anwendung das Mitteilungsbanner an:

Mitteilungsbanner auf dem iPad

Mitteilungshinweis
Um einen Mitteilungshinweis anstelle eines Mitteilungsbanners zu verwenden,
muss der Endbenutzer den Hinweisstil auf der Konfigurationsseite der
Mitteilungszentrale ändern:
107
HINZUFÜGEN VON AKTIONEN ZU HINWEISEN
Sie können einen Hinweis durch Hinzufügen einer Aktions-Schaltfläche anpassen.
Zum Anpassen einer Hinweisaktion müssen Sie die Aktion in der Eigenschaft
AlertAction festlegen und dann die Eigenschaft HasAction wie folgt auf True
setzen:
try
Notification.AlertAction := 'Code Now!';
Notification.HasAction := True;
// Fired in 10 seconds
Notification.FireDate := Now + EncodeTime(0,0,10,0);
// Show Notification Message
NotificationService.ScheduleNotification(Notification);
finally
Notification.Free;
end;
SIEHE AUCH



iOS-Tutorial: Aufnehmen und Teilen von Bildern in iOS-Anwendungen
FMX.Notification.IFMXNotificationCenter
108
IOS-TUTORIAL: VERWENDEN VON INTERBASE
TOGO IN IOS-ANWENDUNGEN
durcharbeiten:

In diesem Tutorial werden die grundlegenden Schritte zum Durchsuchen der von
InterBase ToGo verwalteten Daten auf Ihrem iOS-Gerät mithilfe des dbExpressFrameworks beschrieben.
109
HERSTELLEN EINER VERBINDUNG ZU DER DATENBANK MIT
DBEXPRESS
dbExpress ist ein sehr schnelles, in Delphi geschriebenes Framework für den
Datenbankzugriff. RAD Studio enthält Treiber für die wichtigsten Datenbanken,
wie InterBase, Oracle, DB2, SQL Server, MySQL, Firebird, SQLite und ODBC. Sie
können auf diese Datenbanken mit denselben hier beschriebenen Schritten
zugreifen.

Für die iOS-Plattform unterstützt dbExpress InterBase ToGo sowie SQLite.
Diese Datenbankprodukte können auf iOS-Geräten ausgeführt werden.

Für andere Datenbanken, wie z.B. Oracle, benötigen Sie zumindest eine
Client-Bibliothek. Auf Windows-Plattformen wird die Client-Bibliothek für die
Verbindung als DLL bereitgestellt. Deshalb müssen Sie Anwendungen mit
Mittelschichttechnologien, wie DataSnap, entwickeln, um von iOSGeräten eine Verbindung zu diesen Datenbankprodukten herzustellen.
Wie eine Verbindung zu einer Unternehmensdatenbank ohne eine ClientBibliothek auf dem iOS-Gerät hergestellt wird, ist im iOS-Tutorial: Herstellen einer
Verbindung zu Unternehmensdatenbanken von iOS-Client-Anwendungen aus
beschrieben.
ENTWERFEN UND EINRICHTEN DER BENUTZEROBERFLÄCHE
In diesem Tutorial wird eine TListBox-Komponente als UI-Element verwendet.
Führen Sie die folgenden Schritte aus, um eine ListBox-Komponente einzurichten:
1. Um eine Mobile HD-FireMonkey-Anwendung zu erstellen, wählen Sie Datei
> Neu > Mobile FireMonkey-Anwendung - Delphi > Leere Anwendung aus.
2. Legen Sie eine TListBox-Komponente auf dem Formular ab.
3. Legen Sie im Objektinspektor die folgenden Eigenschaften für die ListBoxKomponente fest:
o Setzen Sie die Eigenschaft Align auf alClient, damit die ListBoxKomponente das gesamte Formular verwendet.
o Setzen Sie die Eigenschaft DefaultItemStyles.ItemStyle auf
listboxitembottomdetail.
4. Klicken Sie entweder im Designer oder im Editor mit der rechten Maustaste
auf die TListBox-Komponente, wählen Sie Eintrag hinzufügen, und fügen
Sie die folgenden Komponenten hinzu:
o TListBoxHeader
o TSearchBox
110
5. Schließen Sie den Eintrags-Designer.
6. Fügen Sie dem TListBoxHeader die Komponente TLabel hinzu, und setzen
Sie im Objektinspektor die folgenden Eigenschaften:
o Setzen Sie die Eigenschaft Align für die TLabel-Komponente auf
alClient.
o Setzen Sie die Eigenschaft StyleLookup auf toollabel.
o Setzen Sie die Eigenschaft TextAlign auf taCenter.
o Setzen Sie die Eigenschaft Text auf DB DEMO.
HERSTELLEN DER VERBINDUNG ZU DEN DATEN
Mit den folgenden grundlegenden Schritten stellen Sie eine Verbindung zu den
Daten in einer Datenbank über dbExpress her:
1. Doppelklicken Sie in der Tool-Palette auf die Komponente
TSQLConnection.
2. Setzen Sie im Objektinspektor folgende Eigenschaften für TSQLConnection:
1. Diese App verwendet InterBase ToGo, setzen Sie daher die
Eigenschaft Driver auf IBLite/ToGo.
111
2. Setzen Sie die Eigenschaft LoginPrompt auf False, damit der
Benutzer nicht zur Eingabe von Anmeldedaten aufgefordert wird.
3. Klicken Sie bei der Eigenschaft Params auf die Ellipsen-Schaltfläche
[...], und setzen Sie den Wert Database auf
C:\Benutzer\Öffentlich\Öffentliche Dokumente\RAD
Studio\11.0\Samples\Data\dbdemos.gdb (Speicherort der
Datenbank); schließen Sie dann das Dialogfeld:
4. Setzen Sie die Eigenschaft Connected auf True.
Hinweis: Wenn in der Entwicklungsumgebung eine Fehlermeldung
("Datenbank nicht verfügbar") angezeigt wird, bedeutet dies, dass Sie
über keine aktuelle Lizenz für InterBase verfügen. Einige Editionen des
Produkts beinhalten die Lizenz für InterBase Developer Edition. Weitere
Informationen finden Sie unter Fehlerbehebung.
112
3. Fügen Sie dem Formular eine TSQLDataSet-Komponente hinzu, und setzen
Sie die folgenden Eigenschaften:
1. Setzen Sie die Eigenschaft SQLConnection auf SQLConnection1 (die
Sie im vorherigen Schritt hinzugefügt haben).
2. Setzen Sie die Eigenschaft CommandText auf select COMMON_NAME,
SPECIES_NAME from BIOLIFE order by COMMON_NAME.
3. Setzen Sie die Eigenschaft Active auf True.
4. Öffnen Sie den LiveBindings-Designer, und verbinden Sie die Daten und
die Benutzeroberfläche folgendermaßen:
1. Klicken Sie in BindSourceDB1 auf COMMON_NAME, und ziehen Sie
den Mauszeiger auf Item.Text in ListBox1.
2. Klicken Sie in BindSourceDB1 auf SPECIES_NAME, und ziehen Sie den
Mauszeiger auf Item.Detail in ListBox1.
113
BEREITSTELLEN DER ANWENDUNG AUF IOS
Bis jetzt haben Sie InterBase auf dem Desktop verwendet. Das bedeutet, dass
sich die eigentliche Datenbank auf Ihrer lokalen Festplatte (z.B.
C:\Benutzer\Öffentlich\Öffentlich Dokumente\RAD
Studio\11.0\Samples\Data\dbdemos.gdb) befindet. Auf dem iOS-Gerät wird
die Anwendung in einer Sandbox ausgeführt, und daher können Sie Daten im
Ordner Dokumente unter dem Anwendungsordner weder lesen noch schreiben.
Führen Sie die folgenden Schritte aus, um eine Verbindung zu einer lokalen
Datenbank auf iOS herzustellen:


Stellen Sie die Datenbank auf dem iOS-Gerät bereit.
Ändern Sie die Konfiguration (für die Verbindung zu der Datenbankdatei)
in eine lokale Datei unter dem Ordner Dokumente.
BEREITSTELLEN VON INTERBASE TOGO, DES DBEXPRESS-TREIBERS UND DER
DATENBANKDATEI AUF IOS
Damit Ihre Anwendung unter iOS ausgeführt werden kann, müssen Sie die
folgenden Dateien bereitstellen:



Interbase ToGo
dbExpress-Treiber für InterBase
Die Datenbankdatei (dbdemos.gdb)
1. Öffnen Sie den Bereitstellungs-Manager durch Auswahl von Projekt >
Bereitstellung.
2. Wählen Sie in der Dropdown-Liste mit den Zielplattformen oben im
Bereitstellungs-Manager Alle Konfigurationen - iOS-Simulator-Plattform
aus.
3. Wählen Sie Weitere Dateien hinzufügen ( ):
4. Wählen Sie die folgenden Datenbankmodule aus, und klicken Sie dann
auf OK, um das Dialogfeld Weitere Dateien zu schließen:
o InterBase ToGo. Sie müssen die Lizenz auswählen, die beim
Bereitstellen einer Anwendung auf dem Gerät verwendet werden
soll. Die verfügbaren Lizenzdateien sind im Dialogfeld Weitere
Dateien unter dem folgenden Namensmuster aufgeführt: reg_*.slip.
114
o
Wie in der folgenden Abbildung gezeigt, werden beide
Lizenzdateien IBToGo und IBLite für dieses Tutorial ausgewählt.
DBExpress InterBase-Treiber
5. Wählen Sie Dateien hinzufügen, und wählen Sie die Datenbankdatei (z.B.
C:\Benutzer\Öffentlich\Öffentliche Dokumente\RAD
Studio\11.0\Samples\Data\dbdemos.gdb) aus.
6. Wählen Sie dbdemos.gdb, und ändern Sie Externer Pfad in
StartUp\Documents\.
7. Markieren Sie die Spalte Plattformen (doppelklicken Sie auf die EllipsenSchaltfläche [...] in der Zeile für dbdemos.gdb):
1. Überprüfen Sie, ob iOS-Simulator und iOS-Gerät für dbdemos.gdb
vorhanden sind.
2. Entfernen Sie Win32 aus der Liste, sofern es vorhanden ist (Sie
müssen keine Datenbankdateien auf die Win32-Plattform kopieren).
8. Wählen Sie die Plattform Alle Konfigurationen - iOS-Gerät aus, und stellen
Sie sicher, dass für dbdemos.gdb die Weitergabeeinstellung auf
StartUp\Documents\ gesetzt ist.
Wie bereits weiter oben konfiguriert, wird die Datenbankdatei (dbdemos.gdb) in
den Ordner Dokumente im Sandbox-Bereich Ihrer iOS-App kopiert.
115
ÄNDERN DES CODES FÜR DIE VERBINDUNG ZU EINER LOKALEN DATENBANKDATEI AUF
IOS
Wie im vorherigen Schritt beschrieben, wird die TSQLConnection-Komponente
mit einer Datenbank auf dem lokalen Dateisystem mit einem absoluten Pfad
verbunden. Deshalb müssen Sie den Speicherort der Datei vor dem Herstellen
einer Verbindung zu der Datenbank wie folgt ändern:
1. Wählen Sie im Formular-Designer die SQLConnection1-Komponente aus.
2. Doppelklicken Sie im Objektinspektor in das Wertefeld des Ereignisses
BeforeConnect.
3. Fügen Sie den folgenden Code für diese Ereignisbehandlungsroutine
hinzu:
procedure TForm1.SQLConnection1BeforeConnect(Sender: TObject);
begin
{$IFDEF IOS}
SQLConnection1.Params.Values['Database']
:= GetHomePath + PathDelim
+ 'Documents' + PathDelim + 'dbdemos.gdb';
{$ENDIF}
end;
Mit der Funktion GetHomePath können Sie den tatsächlichen Speicherort einer
iOS-App ermitteln. Verwenden Sie die Konstante PathDelim, weil PathDelim
explizit das Pfadtrennzeichen der Zielplattform (anstatt des hart-codierten
Trennzeichens, wie \ oder /) verwendet.
116
AUSFÜHREN DER ANWENDUNG AUF DEM IOS-SIMULATOR
ODER AUF EINEM IOS-GERÄT
Ihre Anwendung kann nun ausgeführt werden. Sie sollten genau wie in der IDE
die Daten durchsuchen können. Die Liste kann auch mithilfe des Suchfeldes
eingegrenzt werden, wie in der zweiten Abbildung gezeigt:
117
FEHLERBEHEBUNG
INTERBASE-LIZENZPROBLEME
Wenn in der Entwicklungsumgebung beim Verbinden zu einer Datenbank eine
Fehlermeldung ("Datenbank nicht verfügbar") angezeigt wird, bedeutet das,
dass Sie über keine aktuelle Lizenz für InterBase verfügen.


Einige Editionen des Produkts beinhalten eine Lizenz für InterBase
Developer Edition.
Um die Lizenz für InterBase Developer Edition für eine registrierte RAD
Studio-Installation zu aktivieren, wechseln Sie zum Embarcadero
Produktlizenz-Manager (klicken Sie auf Start | Alle Programme |
Embarcadero InterBase XE3).
EXCEPTION-BEHANDLUNGSPROBLEME
Wenn die Anwendung eine Exception auslöst, ohne dass entsprechender
Exception-Behandlungscode vorhanden ist, stürzt die iOS-App einfach zur
Laufzeit ab (verschwindet).
In diesem Fall sollten Sie für die Fehlerbehebung mit den folgenden
Schritten manuell eine Verbindung zu der Datenbank herstellen:
1. Wählen Sie die Komponente SQLConnection1 aus, und ändern Sie
die Eigenschaft Connected in False.
2. Legen Sie auf dem Formular eine Schaltfläche ab, und erstellen Sie
die folgende Ereignisbehandlungsroutine, um manuell eine
Verbindung zu der Datenbank herzustellen:
procedure TForm1.Button1Click(Sender: TObject);
begin
try
SQLConnection1.Connected := True;
SQLDataSet1.Active := True;
except
on e: Exception do
begin
ShowMessage(e.Message);
end;
end;
end;
118
TYPISCHE FEHLER UND LÖSUNGEN
Im Folgenden finden Sie typische Fehler, die bei der Verbindung zu der
Datenbank auftreten könnten, und entsprechende Lösungsvorschläge:
Fehler auf iOS
Vorschlag
Überprüfen Sie, ob die Datenbankdatei (dbdemos.gdb)
in "StartUp\Documents\" vorhanden ist.
Überprüfen Sie, ob die Lizenzdatei für InterBase ToGo
vorhanden ist.
Überprüfen Sie, ob Sie auf die lokale Datei zeigen (fügen
Sie eine Ereignisbehandlungsroutine für das Ereignis
OnBeforeConnect der Komponente SQLConnection1
hinzu).
SIEHE AUCH




InterBase ToGo mit dbExpress
http://www.embarcadero.com/products/interbase/product-editions
iOS-Tutorial: Verwenden von SQLite in iOS-Anwendungen
iOS-Tutorial: Herstellen einer Verbindung zu Unternehmensdatenbanken
von iOS-Client-Anwendungen aus
119
IOS-TUTORIAL: VERWENDEN VON SQLITE IN
IOS-ANWENDUNGEN
durcharbeiten:

In diesem Tutorial werden die grundlegenden Schritte zum Verwenden von
SQLite als lokalen Datenspeicher auf Ihrem iOS-Gerät mit dem dbExpressFramework beschrieben.
120
HERSTELLEN EINER VERBINDUNG ZU DER DATENBANK MIT
DBEXPRESS
dbExpress ist ein sehr schnelles, in Delphi geschriebenes Framework für den
Datenbankzugriff. RAD Studio enthält Treiber für die wichtigsten Datenbanken,
wie InterBase, Oracle, DB2, SQL Server, MySQL, Firebird, SQLite und ODBC. Sie
können auf diese Datenbanken mit denselben hier beschriebenen Schritten
zugreifen.

Für die iOS-Plattform unterstützt dbExpress InterBase ToGo sowie SQLite.
Diese Datenbankprodukte können auf iOS-Geräten ausgeführt werden.

Für andere Datenbanken, wie z.B. Oracle, benötigen Sie zumindest eine
Client-Bibliothek. Auf Windows-Plattformen wird die Client-Bibliothek für die
Verbindung als DLL bereitgestellt. Deshalb müssen Sie Anwendungen mit
Mittelschichttechnologien, wie DataSnap, entwickeln, um von iOSGeräten eine Verbindung zu diesen Datenbankprodukten herzustellen.
Wie eine Verbindung zu einer Unternehmensdatenbank ohne eine ClientBibliothek auf dem iOS-Gerät hergestellt wird, ist im iOS-Tutorial: Herstellen einer
Verbindung zu Unternehmensdatenbanken von iOS-Client-Anwendungen aus
beschrieben.
ERSTELLEN DER DATENBANK IN DER WINDOWS-UMGEBUNG
FÜR ENTWICKLUNGSZWECKE
Zuerst müssen Sie eine SQLite-Datenbankdatei auf Ihrer WindowsEntwicklungsplattform erstellen. Befolgen Sie die folgenden Schritte, um mit dem
Designer für mobile Formulare die Benutzeroberfläche Ihrer iOS-App zu
entwerfen.
ERSTELLEN DER DATENBANK IM DATEN-EXPLORER
1. Wechseln Sie zum Daten-Explorer, klicken Sie mit der rechten Maustaste
auf den Knoten SQLite, und wählen Sie Neue Verbindung hinzufügen:
2. Legen Sie den Namen der Verbindung, z.B. ShoppingList, fest.
121
3. Geben Sie den Speicherort für die Datenbankdatei an:
4. Klicken Sie auf die Schaltfläche Erweitert, um das Dialogfeld Erweiterte
Eigenschaften zu öffnen.
5. Ändern Sie die Eigenschaft FailIfMissing in False, und schließen Sie das
Dialogfeld:
Hinweis: Durch Setzen von FailIfMissing auf False wird der Daten-Explorer
angewiesen, eine neue Datenbankdatei zu erstellen, falls die Datei nicht
verfügbar ist.
6. Klicken Sie auf die Schaltfläche Verbindung testen. Durch diese Operation
wird die neue Datenbankdatei erstellt, falls die Datei nicht vorhanden ist:
122
ERSTELLEN EINER TABELLE IM DATEN-EXPLORER
1. Wählen Sie im Daten-Explorer im Abschnitt SQLite den Knoten ShoppingList
aus, und wählen Sie dann im Kontextmenü Neue Tabelle.
2. Legen Sie eine Spalte mit dem Titel ShopItem und dem Datentyp TEXT fest.
3. Klicken Sie auf die Schaltfläche Speichern, und geben Sie einen
Tabellennamen (z.B. Item) an.
123
ENTWERFEN UND EINRICHTEN DER BENUTZEROBERFLÄCHE
In diesem Tutorial wird eine TListBox-Komponente als UI-Element verwendet.
Führen Sie die folgenden Schritte aus, um eine ListBox-Komponente und andere
UI-Komponenten einzurichten:
1. Erstellen Sie mit Datei > Neu > Mobile FireMonkey-Anwendung - Delphi
eine mobile FireMonkey-Anwendung.
2. Legen Sie eine TToolBar-Komponente auf dem Formular ab.
3. Legen Sie eine TButton-Komponente auf der ToolBar-Komponente ab.
4. Setzen Sie im Objektinspektor die folgenden Eigenschaften:
o Setzen Sie die Eigenschaft Name auf ButtonAdd.
o Setzen Sie die Eigenschaft StyleLookup auf addtoolbuttonbordered.
5. Legen Sie eine TButton-Komponente auf der ToolBar-Komponente ab.
o Setzen Sie die Eigenschaft Name auf ButtonDelete.
o Setzen Sie die Eigenschaft StyleLookup auf deletetoolbutton.
o Setzen Sie die Eigenschaft Text auf Delete.
o Setzen Sie die Eigenschaft Visible auf False.
7. Legen Sie eine TLabel-Komponente auf der ToolBar-Komponente ab.
o Setzen Sie die Eigenschaft Align auf alClient.
o Setzen Sie die Eigenschaft StyleLookup auf toollabel.
124
Setzen Sie die Eigenschaft Text auf Shopping List.
Setzen Sie die Eigenschaft TextAlign auf taCenter.
9. Legen Sie eine TListBox-Komponente auf dem Formular ab.
o Setzen Sie die Eigenschaft Align auf alClient, damit die ListBoxKomponente das gesamte Formular verwendet.
o
o
HERSTELLEN DER VERBINDUNG ZU DEN DATEN
Führen Sie die folgenden grundlegenden Schritte aus, um eine Verbindung zu
den Daten in einer Datenbank herzustellen, die bereits im Daten-Explorer
definiert ist:
1. Wählen Sie im Daten-Explorer die Tabelle Item aus, und ziehen Sie sie in
den Formular-Designer.
Hinweis: Damit werden zwei Komponenten (ShoppingList: TSQLConnection
und Item: TSQLDataSet) auf dem Formular erstellt.
2. Wählen Sie im Formular die Komponente ShoppingList aus, und ändern Sie
die Eigenschaft Connected in True.
3. Wählen Sie im Formular die Komponente Item aus, und ändern Sie die
Eigenschaft Active in True.
4. Wählen Sie Ansicht > LiveBindings-Designer. Der LiveBindings-Designer
wird geöffnet.
5. Wählen Sie ShopItem in der Komponente Item aus, und ziehen Sie
ShopItem auf ListBox1.
125
Durch diese Schritte wird die Benutzeroberfläche der App mit den Daten in der
SQLite-Datenbank verbunden. Wenn Sie für dieses Tutorial eine Tabelle mit
Daten verwendet haben, werden die Daten jetzt im Formular-Designer
angezeigt.
ERSTELLEN EINER EREIGNISBEHANDLUNGSROUTINE ZUR
ANZEIGE DER SCHALTFLÄCHE "DELETE" BEI AUSWAHL EINES
EINTRAGS AUS DER LISTE DURCH DEN BENUTZER
Die Eigenschaft Visible für die Schaltfläche Delete ist auf False gesetzt. Deshalb
ist diese Schaltfläche für den Benutzer standardmäßig nicht sichtbar. Sie können
die Schaltfläche folgendermaßen anzeigen, wenn der Benutzer einen Eintrag in
der Liste auswählt:

Wählen Sie ListBox1 aus, und definieren Sie die folgende
Ereignisbehandlungsroutine für das Ereignis OnItemClick.
procedure TForm1.ListBox1ItemClick(const Sender: TCustomListBox;
const Item: TListBoxItem);
begin
ButtonDelete.Visible := ListBox1.Selected <> nil;
end;
126
ERSTELLEN EINER EREIGNISBEHANDLUNGSROUTINE FÜR DIE
SCHALTFLÄCHE "ADD" ZUM HINZUFÜGEN EINES EINTRAGS ZU
DER LISTE
Im nächsten Schritt wird diese Anwendung durch eine Funktion zum Hinzufügen
von Einträgen zu der Einkaufsliste erweitert.
1. Legen Sie eine TSQLQuery-Komponente auf dem Formular ab.
o Setzen Sie die Eigenschaft Name auf SQLQueryInsert.
o Setzen Sie die Eigenschaft SQLConnection auf ShoppingList.
o Setzen Sie die SQL-Eigenschaft wie folgt:
INSERT INTO ITEM (ShopItem) VALUES (:ShopItem)
o
o
Klicken Sie bei der Eigenschaft Params auf die Schaltfläche
Einblenden (...).
Wählen Sie den Parameter ShopItem aus, und setzen Sie DataType
auf ftString:
127
3. Doppelklicken Sie im Formular-Designer auf die Komponente AddButton.
Fügen Sie den folgenden Code für diese Ereignisbehandlungsroutine
hinzu:
procedure TForm1.ButtonAddClick(Sender: TObject);
var
TaskName: String;
begin
try
if InputQuery('Enter New Item', 'Name', TaskName) and (TaskName.Trim <> '') then
begin
SQLQueryInsert.ParamByName('ShopItem').AsString := TaskName;
SQLQueryInsert.ExecSQL();
Item.Refresh;
end;
except
on e: Exception do
begin
ShowMessage(e.Message);
end;
end;
end;
Die Funktion InputQuery zeigt ein Dialogfeld an, in dem der Benutzer
aufgefordert wird, Text einzugeben. Die Funktion gibt True zurück, wenn der
Benutzer OK auswählt, damit der Datenbank nur Daten hinzugefügt werden,
wenn der Benutzer OK wählt, und der Text nicht leer ist.
128
ERSTELLEN EINER EREIGNISBEHANDLUNGSROUTINE FÜR DIE
SCHALTFLÄCHE "DELETE" ZUM ENTFERNEN EINES EINTRAGS
AUS DER LISTE
Im nächsten Schritt wird diese Anwendung durch eine Funktion zum Entfernen
von Einträgen aus der Einkaufsliste erweitert:
1. Legen Sie eine TSQLQuery-Komponente auf dem Formular ab.
o Setzen Sie die Eigenschaft Name auf SQLQueryDelete.
o Setzen Sie die Eigenschaft SQLConnection auf ShoppingList.
o Setzen Sie die SQL-Eigenschaft wie folgt:
delete from Item where ShopItem = :ShopItem
Klicken Sie bei der Eigenschaft Params auf die Schaltfläche
Einblenden (...).
o Wählen Sie den Parameter ShopItem aus, und setzen Sie DataType
auf ftString.
3. Doppelklicken Sie im Formular-Designer auf die Komponente
DeleteButton. Fügen Sie den folgenden Code für diese
Ereignisbehandlungsroutine hinzu.
o
129
procedure TForm1.ButtonDeleteClick(Sender: TObject);
var
TaskName: String;
begin
TaskName := ListBox1.Selected.Text;
try
SQLQueryDelete.ParamByName('ShopItem').AsString := TaskName;
SQLQueryDelete.ExecSQL();
Item.Refresh;
except
on e: Exception do
begin
SHowMessage(e.Message);
end;
end;
end;
ÄNDERN DES CODES FÜR DIE VERBINDUNG ZU EINER LOKALEN
DATENBANKDATEI UNTER IOS
Die Hauptfunktionen für diese Anwendung sind nun implementiert. Im DatenExplorer haben Sie zuvor eine Datenbankdatei für Windows erstellt. Die
Datenbankdatei steht erst für Ihr iOS-Gerät zur Verfügung, wenn Sie sie auf das
iOS-Gerät kopieren oder ad-hoc erstellen.
Mit den folgenden Schritten können Sie eine SQLite-Datenbank und -Tabelle
erstellen:
FESTLEGEN DES SPEICHERORTS DER SQLITE-DATENBANK AUF DEM IOS-GERÄT
1. Wählen Sie im Formular-Designer die Komponente ShoppingList aus.
2. Doppelklicken Sie im Objektinspektor auf das Ereignis BeforeConnect.
hinzu:
procedure TForm1.SQLConnectionSQLiteBeforeConnect(Sender: TObject);
begin
{$IFDEF IOS}
ShoppingList.Params.Values['Database'] := GetHomePath + PathDelim +
'Documents' + PathDelim + 'shoplist.s3db';
{$ENDIF}
end;
130
Mit der Funktion GetHomePath können Sie den tatsächlichen Speicherort einer
iOS-App ermitteln. Verwenden Sie die Konstante System.SysUtils.PathDelim, weil
PathDelim explizit das Pfadtrennzeichen der Zielplattform (anstatt des hartcodierten Trennzeichens, wie \ oder /) verwendet.
ERSTELLEN EINER TABELLE, FALLS KEINE VORHANDEN IST
Mit SQLite können Sie mit der Anweisung CREATE TABLE IF NOT EXISTS eine Tabelle
erstellen, wenn noch keine Tabelle vorhanden ist. Eine Tabelle sollte angelegt
werden, nachdem die TSQLConnection-Komponente eine Verbindung zu der
Datenbank hergestellt hat und bevor die TSQLDataSet-Komponente eine
Verbindung zu der Tabelle herstellt. Gehen Sie dazu folgendermaßen vor:
1. Wählen Sie im Formular-Designer die Komponente ShoppingList aus.
2. Doppelklicken Sie im Objektinspektor auf das Ereignis AfterConnect.
hinzu:
procedure TForm1.ShoppingListAfterConnect(Sender: TObject);
begin
ShoppingList.ExecuteDirect('CREATE TABLE IF NOT EXISTS Item (ShopItem
NULL)');
end;
TEXT NOT
131
Ihre Anwendung kann nun ausgeführt werden (wählen Sie Start > Start).
Falls bei der Ausführung der Anwendung Probleme auftreten, führen Sie die
Schritte unter Fehlerbehebung aus.
SIEHE AUCH



iOS-Tutorial: Verwenden von InterBase ToGo in iOS-Anwendungen
iOS-Tutorial: Herstellen einer Verbindung zu Unternehmensdatenbanken
von iOS-Client-Anwendungen aus
Unterstützung von SQLite in XE3
132
IOS-TUTORIAL: HERSTELLEN EINER
VERBINDUNG ZU
UNTERNEHMENSDATENBANKEN VON IOSCLIENT-ANWENDUNGEN AUS
durcharbeiten:


In diesem Tutorial wird beschrieben, wie Sie von einer iOS-Client-Anwendung aus
eine Verbindung zu einer Unternehmensdatenbank herstellen.
Für die Verbindung zu einer Unternehmensdatenbank benötigen Sie eine ClientBibliothek. Meistens wird die Client-Bibliothek vom Hersteller der Datenbank als
DLL bereitgestellt. Für iOS-Geräte ist dieses Vorgehen nicht angebracht, weil
keine Client-Bibliothek verfügbar ist. Zur Lösung dieses Problems können Sie eine
Mittelschicht für die Verbindung zu einer Unternehmensdatenbank entwickeln,
und Ihre iOS-Anwendung kann mit der Mittelschicht interagieren. RAD Studio
stellt das DataSnap-Framework bereit, mit dem Sie die Mittelschicht, fast ohne zu
programmieren, entwickeln (und darauf zugreifen) können. In diesem Tutorial
werden die Schritte zum Entwickeln der Mittelschicht und des iOS-Clients
beschrieben.
133
ERSTELLEN DER MITTELSCHICHT: EIN DATASNAP-SERVER
Erstellen Sie zunächst einen DataSnap-Server, der eine Tabelle von einem
Datenbankserver bereitstellt. In diesem Tutorial wird als DataSnap-Server eine
DataSnap-Server-VCL-Formularanwendung verwendet.
Hinweis: In diesem Tutorial dient der DataSnap-Server (VCL-Anwendung) als
Mittelschicht in einer mehrschichtigen Datenbankanwendung. Sie können eine
Instanz eines DataSnap-Servers einfach erstellen und später wieder löschen.
Wenn Ihnen die grundlegenden Schritte klar sind, können Sie die Mittelschicht in
eine Windows-Dienstanwendung umwandeln.
ERSTELLEN EINER DATASNAP-SERVER-VCL-ANWENDUNG
1. Erstellen Sie ein neues Projekt. Wählen Sie Datei > Neu > Weitere, und im
Dialogfeld Objektgalerie wählen Sie Delphi-Projekte > DataSnap-Server >
DataSnap-Server, um ein neues Delphi-Projekt zu erstellen.
2. Der Experte Neuer DataSnap-Server wird angezeigt, und Sie müssen die
Schritte befolgen, ohne allzu viele Parameter zu verändern.
134
3. Im Experten Neuer DataSnap-Server:
1. Wählen Sie als ersten Schritt VCL-Formularanwendung als
Anwendungstyp aus.
2. Wählen Sie als zweiten Schritt das Protokoll TCP/IP, die
Servermethodenklasse und Beispielmethoden aus der Liste aus.
3. Belassen Sie im dritten Schritt die Einstellung des Standard-TCP/IP
Kommunikations-Ports auf 211. Damit wird sichergestellt, dass die
Kommunikation zwischen dem Client und dem Server über den
Standard-DataSnap-Port ausgeführt wird.
4. Wählen Sie als vierten und letzten Schritt TDSServerModule als
Vorfahre für die Servermethoden aus.
4. Speichern Sie die neue Formular-Unit unter DataSnapServerUnit.pas.
5. Wechseln Sie zu DataSnapServerUnit, und ändern Sie die Eigenschaft
Name des Formulars in DSServerForm.
6. Speichern Sie die Servermethoden-Unit (vom Experten standardmäßig als
ServerMethodsUnit1 erstellt) unter dem Namen ServerModuleUnit.pas.
7. Speichern Sie die Servercontainer-Unit (vom Experten standardmäßig als
ServerContainerUnit1 erstellt) unter dem Namen ServerContainerUnit.pas.
8. Speichern Sie das neue Projekt unter DataSnapServerProject.droj.
135
9. Wählen Sie in der Projektverwaltung ProjectGroup1, und speichern Sie das
Projekt unter DataSnapTutorialProjectGroup.groupproj.
DEFINIEREN EINER DATENMENGE FÜR DEN DATASNAP-SERVER
1. Wechseln Sie zur Datei ServerContainerUnit.pas, und ersetzen Sie die usesKlausel in der implementation-Abschnitt durch uses Winapi.Windows,
ServerModuleUnit;
2. Wechseln Sie zur Datei ServerModuleUnit.pas.
3. Ändern Sie im Formular-Designer die Eigenschaft Name des Servermoduls
in DSServerModule_EMPLOYEE.
4. Konfigurieren Sie die folgenden Komponenten für das Servermodul:
o Legen Sie eine TSQLConnection-Komponente auf dem Servermodul
ab, und setzen Sie die folgenden Eigenschaften:
TSQLConnection kapselt die dbExpress-Verbindung zu einem
Datenbankserver.





Setzen Sie die Eigenschaft Name auf
SQLConnection_EMPLOYEE.
Setzen Sie die Eigenschaft LoginPrompt auf False.
Setzen Sie Driver auf InterBase.
Erweitern Sie den Knoten Driver, und setzen Sie die
Eigenschaft DataBase auf C:\Benutzer\Öffentlich\Öffentliche
Dokumente\RAD
Studio\11.0\Samples\Data\EMPLOYEE.GDB.
Ändern Sie die Eigenschaft Connected in True. Falls Sie eine
Fehlermeldung erhalten, überprüfen Sie die DriverEigenschaften:
136
o
Legen Sie eine TSQLDataSet-Komponente auf dem Servermodul ab,
und setzen Sie die folgenden Eigenschaften:
TSQLDataSet stellt die Daten dar, die mit dbExpress abgerufen wurden.
Setzen Sie die Eigenschaft Name auf SQLDataSet_EMPLOYEE.
Setzen Sie die Eigenschaft SQLConnection auf
SQLConnection_EMPLOYEE.
 Setzen Sie die Eigenschaft CommandType auf ctTable.
 Setzen Sie die Eigenschaft CommandText auf EMPLOYEE.
 Ändern Sie die Eigenschaft Active in True. Falls Sie eine
Fehlermeldung erhalten, überprüfen Sie die Eigenschaften,
die Sie gerade konfiguriert haben.
Legen Sie eine TDataSetProvider-Komponente auf dem
Servermodul ab, und setzen Sie die folgenden Eigenschaften:


o
Die Komponente TDataSetProvider packt Daten aus einer Datenmenge
und übergibt ein oder mehrere übertragbare Datenpakete an den
DataSnap-Client.


Setzen Sie die Eigenschaft Name auf
DataSetProvider_EMPLOYEE.
Setzen Sie die Eigenschaft DataSet auf
SQLDataSet_EMPLOYEE.

137
Hinweis: In diesem Tutorial wird InterBase verwendet. Sie können aber mit
denselben Schritten eine Verbindung zu jedem beliebigen Datenbankserver
herstellen. Wählen Sie für die Verbindung den entsprechenden Treiber und
andere Eigenschaften für die jeweilige Datenbank aus.
BEREITSTELLEN DER DATENMENGE VOM DATASNAP-SERVER
Sie haben gerade ein neues Servermodul mit einer DataSet-Komponente und
einer DataSetProvider-Komponente erstellt, die Daten in die nächste Schicht
packt. Als Nächstes muss das Servermodul für den DataSnap-Client
bereitgestellt werden.
1. Öffnen Sie im Formular-Designer ServerContainerUnit.
2. Wählen Sie DSServerClass1, und aktualisieren Sie die vorhandene
Ereignisbehandlungsroutine für das Ereignis OnGetClass. Fügen Sie der
Ereignisbehandlungsroutine DSServerClass1 den folgenden Code hinzu:
procedure TServerContainer1.DSServerClass1GetClass(DSServerClass: TDSServerClass;
var PersistentClass: TPersistentClass);
begin
PersistentClass := TDSServerModule_EMPLOYEE;
end;
Mit dieser Ereignisbehandlungsroutine stellt der DataSnap-Server Provider und
public-Methoden in dieser Klasse für einen DataSnap-Client bereit. Ausgehend
von den Schritten im vorherigen Abschnitt wird nun die Komponente
DataSetProvider_EMPLOYEE DataSetProvider für den DataSnap-Client
bereitgestellt.
AUSFÜHREN DES DATASNAP-SERVERS
Die Implementierung des DataSnap-Servers ist abgeschlossen. Klicken Sie mit der
rechten Maustaste auf DataSnapServerProject.exe, und wählen Sie Ohne
Debugger ausführen.
138
.
Der DataSnap-Server wird nun auf Ihrem Windows-Computer ausgeführt. Da
dieser DataSnap-Server keine UI-Elemente hat, sieht er wie ein leeres Formular
aus, und das ist hier genau das erwartete Verhalten.
ERSTELLEN EINER IOS-ANWENDUNG FÜR DIE VERBINDUNG
ZUM DATASNAP-SERVER
Als Nächstes wird die iOS-Client-Anwendung erstellt.
1. Klicken Sie in der Projektverwaltung mit der rechten Maustaste auf
DataSnapTutorialProjectGroup, und wählen Sie Neues Projekt
hinzufügen....
2. Wählen Sie auf der Seite Delphi-Projekte den Eintrag Mobile FireMonkeyAnwendung aus:
139
3. Speichern Sie die neue Unit unter DataSnapClientUnit.pas.
4. Speichern Sie das neue Projekt unter DataSnapClientProject.droj.
5. Öffnen Sie DataSnapClientUnit, und ändern Sie die Eigenschaft Name des
Formulars in DSClientForm.
6. Ziehen Sie die folgenden Komponenten in den Designer für mobile
FireMonkey-Formulare:
o TSQLConnection (SQLConnection1)
TSQLConnection kapselt die dbExpress-Verbindung zu einem
Datenbankserver. Außerdem unterstützt die Komponente den DataSnapServer.




Setzen Sie die Eigenschaft Driver auf DataSnap.
Erweitern Sie die Eigenschaft Driver, und setzen Sie die
Eigenschaft HostName auf den Host-Namen des DataSnapServers.
Setzen Sie die Eigenschaft LoginPrompt auf False.
Setzen Sie die Eigenschaft Connected auf True.
Wenn Sie eine Feherlmeldung erhalten, überprüfen Sie die gerade
festgelegten Eigenschaften nochmals.
o
TDSProviderConnection (DSProviderConnection1)
Die Komponente TDSProviderConnection stellt die Konnektivität zum
DataSnap-Server über dbExpress her.

Setzen Sie die Eigenschaft SQLConnection auf
SQLConnection1.
140
Setzen Sie ServerClassName auf TDSServerModule_EMPLOYEE.
Dieser Name muss mit dem Namen der Klasse des
Servermoduls des DataSnap-Servers übereinstimmen.
 Setzen Sie die Eigenschaft Connected auf True.
TClientDataSet (ClientDataSet1)

o
TClientDataSet implementiert eine datenbankunabhängige
Datenmenge, die als lokaler Speicherpuffer der Datensätze aus einer
anderen Datenmenge verwendet werden kann.
Setzen Sie die Eigenschaft RemoteServer auf
DSProviderConnection1.
 Setzen Sie die Eigenschaft ProviderName auf
DataSetProvider_EMPLOYEE. Dieser Name muss mit dem
Namen des Providers für den DataSnap-Server
übereinstimmen.
 Setzen Sie die Eigenschaft Active auf True.
TListBox
 Setzen Sie Align auf alClient.

o
7. Öffnen Sie den LiveBindings-Designer, und verbinden Sie die Daten und
die Benutzeroberfläche folgendermaßen:
1. Klicken Sie in BindSourceDB1 auf FULL_NAME, und ziehen Sie den
Mauszeiger auf Item.Text in ListBox1:
141
2.
Nun haben Sie den DataSnap-Client unter iOS erstellt und
konfiguriert. Die Daten vom DataSnap-Server sollten nun in der IDE
angezeigt werden:
142
BEREITSTELLEN DER MIDAS-BIBLIOTHEK AUF DEM IOSSIMULATOR
Damit Ihre Anwendung auf dem iOS-Simulator ausgeführt werden kann, müssen
Sie die folgenden Dateien bereitstellen:

MIDAS-Bibliothek
1. Öffnen Sie den Bereitstellungs-Manager durch Auswahl von Projekt >
Bereitstellung.
2. Wählen Sie Weitere Dateien hinzufügen ( ):
3. Wählen Sie das folgende Modul aus, und klicken Sie dann auf OK, um den
Bereitstellungs-Manager zu schließen:
o MIDAS-Bibliothek
143
Ihre Anwendung kann nun ausgeführt werden.
Wählen Sie in der Projektverwaltung entweder die Zielplattform iOS-Simulator
oder iOS-Gerät, und führen Sie Ihre Anwendung aus. Sie sollten genau wie in der
IDE durch die Daten blättern können.
SIEHE AUCH





iOS-Tutorial: Verwenden von SQLite in iOS-Anwendungen
DataSnap-Anwendungen entwickeln
Grundlagen der mehrschichtigen Datenbank-Anwendungen
Datasnap.DSServer.TDSServer
144

iOS-Tutorials: iOS-Anwendungsentwicklung mit Delphi

Transcription

Similar documents

Schulprogramm - Evangelische Schule Friedrichshagen

Accelerator Guide für die interne App-Entwicklung

MyVideo maximiert ROI durch Werbung

Insight Microsoft Optimization Services S O F T W A R E E D I T I O N

DELPHI 04 Standard-Komponenten © Herbert Paukert