Erstellen von iOS-Apps

Nach oben zu Mobile iOS-Anwendungsentwicklung

So erstellen Sie eine iOS-App:

Datei > Neu > Geräteübergreifende Anwendung - Delphi
Datei > Neu > Geräteübergreifende Anwendung - C++Builder

Wählen Sie dann im Experten Geräteübergreifende Anwendung einen geräteübergreifenden Anwendungstyp aus.

Workflow für FireMonkey-iOS

Die Entwicklung von FireMonkey-iOS-Anwendungen erfolgt auf Ihrer Entwicklungsplattform und auf dem Mac. Nach Abschluss der erforderlichen Schritte zur Einrichtung der Umgebung und dem Compilieren des Projekts in der RAD Studio-IDE werden beim Ausführen des Projekts die ausführbaren Dateien und die erforderlichen Bibliotheken auf den Mac übertragen.

Wichtig: Beginnen Sie hier

• Bevor Sie mit Ihrem ersten iOS-Projekt beginnen, müssen Sie unter Windows und auf dem Mac einige wichtige Installations- und Konfigurationsschritte durchführen. Beispielsweise müssen Sie ein Bereitstellungsprofil für das jeweilige iOS-Entwicklungsgerät konfigurieren, das Sie für den Test Ihrer Anwendung auf dem Mac verwenden möchten..

• Die dazu erforderlichen Schritte sind unter Mobile iOS-Anwendungsentwicklung beschrieben.

Entwickeln Sie anschließend Ihr Projekt gemäß der folgenden allgemeinen Reihenfolge:

Schritte in RAD Studio

1. Starten Sie Ihr Projekt mit einem der folgenden Experten für geräteübergreifende Anwendungen:

   Datei > Neu > Weitere > Delphi-Projekte > Geräteübergreifende Anwendung

   Datei > Neu > Weitere > C++Builder-Projekte > Geräteübergreifende Anwendung

2. Wählen Sie im Experten Geräteübergreifende Anwendung einen geräteübergreifenden Anwendungstyp, wie Registerkarten oder Leere Anwendung, aus.
3. Die Master-Ansicht wird im Formular-Designer angezeigt.
4. Wählen Sie eine der iOS-Geräteplattformen (iOS-Gerät - 32 Bit oder iOS-Gerät - 64 Bit) aus, um alle verfügbaren Komponenten für iOS anzuzeigen, andernfalls werden sie abgedunkelt dargestellt.

   Fügen Sie im Formular-Designer und im Quelltext-Editor in RAD Studio dem Formular Steuerelemente hinzu, legen Sie Werte für Eigenschaften und Ereignisse fest, und schreiben Sie den entsprechenden Code dafür.

Tipp: Beginnen Sie mit der Erstellung Ihrer iOS-App anhand von Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android).

Stilauswahl

Oben im Formular-Designer für geräteübergreifende Anwendungen wird die Stilauswahl angezeigt:

Im Dropdown-Menü der Stilauswahl sind alle Stile aufgeführt, die Sie für die Master-Ansicht anwenden können.

Wählen Sie aus der Stilauswahl den Stil iOS aus, um alle Eigenschaften für die Komponenten entsprechend der Zielplattform anzuzeigen.

Ansichtsauswahl

Oben im Formular-Designer für geräteübergreifende Anwendungen wird die Ansichtsauswahl angezeigt:

Das Dropdown-Menü der Ansichtsauswahl enthält alle verfügbaren Ansichten für die verschiedenen Plattformen, wie iOS, Android, Windows und OS X.

Verwenden Sie die Master-Ansicht für das allgemeine Design Ihrer Anwendung. Anschließend können Sie Ihrem Projekt neue Ansichten hinzufügen, um Ihre Anwendung für einen bestimmten Gerätetyp anzupassen. Es ist sogar möglich, neue angepasste Ansichten zu erstellen; siehe Hinzufügen einer angepassten Ansicht zur Ansichtsauswahl. Die Standardansichten für iOS-Geräte sind:

• iPhone 3.5"
• iPhone 4"
• iPad Mini
• iPad

Alle Ansichten erben Komponenten und Eigenschaften von der Master-Ansicht. Weitere Informationen finden Sie unter Formular-Designer.

Hinweis: Wenn Sie einige Bereiche Ihrer Anwendung nur für iOS anpassen möchten, können Sie dies mit der Ansicht iOS durchführen. Alternativ können Sie über die bedingte Compilierung iOS-spezifischen Code zur Laufzeit ausführen.

Siehe auch Mobile-Tutorial: Verwenden von Layouts zur Ausrichtung unterschiedlicher Formulargrößen (iOS und Android) , das die Verwendung der Master-Ansicht für verschiedene Standards (wie Telefon oder Tablet) ohne unterschiedliche Ansichten für jeden Standard zeigt.

Zuordnung von Ansichten und iOS-Simulatorzielen

Ansicht	iOS-Simulatorziel
iPad Mini	iPad
iPhone 3.5	iPhone
iPhone 4	iPhone5

Bevorzugte Komponenten für iOS im Vergleich zu Desktop-Plattformen

Auf der iOS-Plattform unterscheiden sich der native Stil und das Format vom Stil und Format von Anwendungen für Desktop-Plattformen. Daher müssen Sie für geräteübergreifende Apps iOS-spezifische Regeln hinsichtlich Formatierung und Anordnung von Komponenten auf der iOS-Plattform beachten.

In der folgenden Beispielliste werden FireMonkey-Komponenten, die typischerweise auf Desktop-Plattformen verwendet werden, Komponenten gegenübergestellt, die bevorzugt für iOS geeignet sind:

Unterschiede bei wichtigen Komponenten:

Desktop-Komponenten	iOS-Komponenten
TTreeView	TListView TListBox
TRadioGroup TRadioButton	TSegmentedControl ListBox
TCheckBox	TSwitch
TMenuBar TMainMenu	TToolBar mit Schaltflächen TTabControl

Bevorzugte FireMonkey-Komponenten für iOS-Apps:

TButton	TEdit	TCalendarEdit	TListView
TTrackBar	TTabControl	TSpeeButton	TMemo
TSwitch	TComboBox	TToolBar	TScrollBox
TLabel	TNumberBox	TListBox	TProgressBar
TPanel

Weitere Informationen als PDF-Datei und Video (einschließlich von Empfehlungen für Format und Stil) finden Sie im EDN-Artikel iOS User Interface Design with Delphi XE4 (EN).

Beispielsweise enthält der EDN-Artikel (EN) Tipps zur Verwendung von allgemeinen Komponenten, wie TListBox, TListView, TToolBar und TSpeedButton, in iOS-Apps plus einer detaillierten Demo, in der gezeigt wird, wie Sie eine Einstellungs-App (Settings) für die iOS-Plattform erstellen:

Einzelne Beispiel-Frames aus iOS User Interface Design with Delphi XE4 (EN)
TListBox-Regeln	TListView-Regeln	Settings-Demo

Komponentenbeschränkungen bei FireMonkey-Apps für iOS

Während des Entwurfs von iOS-Apps in RAD Studio können Sie nur Komponenten verwenden, die auf iOS-Geräten unterstützt werden. Wenn die aktive Zielplattform Ihres Projekts eine iOS-Geräteplattform (iOS-Gerät - 32 Bit oder iOS-Gerät - 64 Bit) ist, werden nicht unterstützte Komponenten in der Tool-Palette abgedunkelt dargestellt.

Nicht akzeptierte internationale Zeichen (Unicode) auf der iOS-Zielplattform

Internationale Zeichen (Unicode) werden an mehreren Stellen in iOS-Apps nicht akzeptiert. Beispielsweise können Namen wie hélène und éléments die Ausführung einer iOS-App verhindern.

Verwenden Sie internationale Zeichen insbesondere nicht:

• In Ihrem Windows-Benutzernamen
• In Namen von Verbindungsprofilen
• In Namen von iOS-Projekten
• In dem Namen des Anwendungspakets (die ausführbare .app-Datei)

Folgende Meldung wird angezeigt, wenn Sie versuchen, eine iOS-App zu erzeugen, die Unicode-Zeichen enthält:

  Can't get full path to application bundle. No such file or directory

In diesem Fall wird die iOS-App zwar im scratch-dir von PAServer erzeugt, kann aber weder auf iOS-Geräten noch auf Simulatoren ausgeführt werden.

Verwenden Sie außerdem System::UnicodeString und std::wstring nicht gemeinsam, wenn Sie mit C++ eine iOS-Anwendung erstellen. Der Grund dafür ist, dass std::wstring 4-Byte-Zeichen (wchar_t) verwendet und System::UnicodeString 2-Byte-Zeichen (char16_t).

Verwenden eigener Schriftarten in iOS-Apps

Sie können in Ihren iOS-Apps eigene Schriftarten verwenden.

Eigene Schriftarten können in mobilen Anwendungen beispielsweise als Symbole verwendet werden. TrueType-Schriftarten haben gegenüber Rasterbilddateien Vorteile, weil diese Schriftarten schlank und vektorbasiert sind, sodass sie gut in hohe Auflösungen skaliert werden können. Sie können eigene Schriftarten in Ihre System-Schriftartenbibliothek auf Ihrem Entwicklungssystem installieren. Die eigenen Schriftarten sollten dann in der IDE beim Entwurf verfügbar sein.

Wenn Sie aber Ihre App zu diesem Zeitpunkt auf einem Zielgerät bereitstellen, werden die Schriftarten der App nur mit den auf dem Gerät verfügbaren installierten Schriftarten gerendert. Sie müssen Ihrem Projekt die Schriftart mit dem Bereitstellungs-Manager hinzufügen, um sicherzustellen, dass die beim Entwurf in der IDE angezeigten Schriftarten auf das Gerät kopiert werden.

Die grundlegenden Schritte zum Einbeziehen einer eigenen Schriftart in Ihre iOS-App sind:

1. Installieren der eigenen Schriftart auf Ihrem Windows-System.
   • Anleitungen dazu finden Sie unter Windows Hilfe und Support auf Ihrem System.
   • Klicken Sie beispielsweise mit der rechten Maustaste auf die Schriftartdatei, und klicken Sie auf Installieren.
2. Hinzufügen der Schriftartdatei zum Stammverzeichnis Ihres Projekts.
3. Zuweisen der Schriftart zur Eigenschaft Text Settings/Font für die Steuerelemente, die die Schriftart verwenden, im Objektinspektor.
4. Anpassen der Datei info.plist für Ihr iOS-Projekt und Einfügen der folgenden Zeilen in das <dict>-Tag der obersten Ebene:

   <key>UIAppFonts</key>
   <array>
     <string>FontAwesome.ttf</string>
   </array>
   

5. Hinzufügen der Schriftartdatei zu Ihrem Projekt im Bereitstellungs-Manager.

Vollständige Anleitungen und herunterladbare Dateien zum Erstellen eines mobile Projekts, in dem eine eigene installierte Schriftart (Font Awesome (EN)) verwendet wird, finden Sie hier:

• http://community.embarcadero.com/index.php/blogs/entry/true-type-font-iconography-for-android-and-ios-apps (EN)

Um festzustellen, ob eine Schriftart zur Laufzeit auf einem bestimmten Gerät zur Verfügung steht, müssen Sie überprüfen, ob die beim Entwurf verwendete Schriftart auf den Zielgeräten unterstützt wird:

Freigeben von Formularen in iOS-Apps

Im Allgemeinen sollten geräteübergreifende Anwendungen nicht mehrere Formulare gleichzeitig im Arbeitsspeicher halten. Mobile Geräte verfügen nur über begrenzten Arbeitsspeicher, und Formulare sind speicherintensive Objekte.

Gehen Sie folgendermaßen vor: Zeigen Sie das Formular an, und geben Sie das Formular, wenn es nicht mehr sichtbar ist, aus dem Speicher frei (entweder mit der Ereignisbehandlungsroutine OnClose oder durch Setzen von CloseEvent auf caFree oder durch den Aufruf der Methode System.TObject.DisposeOf des Formulars).

Mit einem Register-Steuerelement mit mehreren Seiten können mehrere formularartige Steuerelemente speichereffizienter angezeigt werden.

Verwenden von Frameworks in iOS-Apps

RTL

Einige RTL-Units, die die grundlegende Funktionalität bereitstellen, werden für alle Plattformen verwendet, z. B. System oder System.SysUtils.

Einige RTL-Units können nur für iOS verwendet werden (siehe Objective-C-Frameworks für iOS). Diesen Units wird der Unit-Gültigkeitsbereich iOSapi vorangestellt.

Siehe auch iOS-C-RTL.

FireMonkey

Das FireMonkey-Framework eignet sich ideal für iOS und unterstützt auch viele andere Plattformen. Siehe Plattformvoraussetzungen für FireMonkey.

VCL (nicht verfügbar für iOS oder den Mac)

Die VCL steht nur unter Windows (32 Bit und 64 Bit) zur Verfügung.

Objective-C-Frameworks für iOS (iOSapi)

Die RTL enthält eine Reihe von Units, die Delphi- und C++-Interfaces für iOS-Frameworks in der Sprache Objective-C enthalten. Diesen Units ist der Gültigkeitsbereich iOSapi vorangestellt, und sie befinden sich normalerweise im Verzeichnis /source/rtl Ihrer Produktinstallation:

• iOSapi.AssetsLibrary
• iOSapi.AVFoundation
• iOSapi.CocoaTypes
• iOSapi.CoreAudio
• iOSapi.CoreData
• iOSapi.CoreGraphics
• iOSapi.CoreImage
• iOSapi.CoreLocation
• iOSapi.CoreMedia
• iOSapi.CoreMotion
• iOSapi.CoreTelephony
• iOSapi.CoreText
• iOSapi.CoreVideo
• iOSapi.Foundation
• iOSapi.GLKit
• iOSapi.MediaPlayer
• iOSapi.OpenGLES
• iOSapi.QuartzCore
• iOSapi.UIKit

Das FireMonkey-Framework basiert auf einigen dieser Units.

Dokumentation für iOS-Bibliotheken

Hilfe zu diesen APIs finden Sie in der Apple-Dokumentation unter iOS Developer Library (EN). RAD Studio stellt keine Hilfe für die Bibliotheken bereit, die Sie eventuell für den Mac benötigen.

Sie können sich als iOS-Entwickler (kostenlos) beim iOS Dev Center (EN) registrieren. Als registriertes Mitglied des iOS Developer Program (iOS-Entwicklerprogramm) können Sie Ihre Apps im App Store vertreiben (dies ist eine Voraussetzung unter anderen, wie ein Entwicklerzertifikat und ein Bereitstellungsprofil). Weitere Informationen finden Sie unter http://developer.apple.com/programs/ios/gettingstarted/ (EN).

OpenSSL-Unterstützung

Für Cloud-Komponenten und Indy ist OpenSSL zur Unterstützung von HTTPS erforderlich. Wenn in Ihrer iOS-Anwendung eine dieser Technologien mit HTTPS verwendet wird, müssen Sie Ihr Projekt so konfigurieren, dass die erforderlichen Bibliotheken eingeschlossen sind: libcrypto und libssl.

• Für die Zielplattformen "iOS-Gerät" (iOS-Gerät - 32 Bit und iOS-Gerät - 64 Bit), die keine dynamischen Bibliotheken unterstützen, benötigen Sie eine statische Version dieser Bibliotheksdateien (libcrypto.a und libssl.a). Um diese Bibliotheksdateien zu erhalten, erzeugen Sie sie aus den Quellen. Laden Sie die Quellen aus Github herunter, und befolgen Sie die in Tutorial: Skript zum Erzeugen von OpenSSL für iOS (iPhone/iPad) beschriebenen Schritte, um diese Bibliotheksdateien zu compilieren.

  Kopieren Sie anschließend diese Bibliotheksdateien in einen Ordner, in dem Ihr Projekt nach Bibliotheken sucht, z. B. in den Hauptprojektordner.

• Führen Sie für die Zielplattform iOS-Simulator, die dynamische Bibliotheken unterstützt, einen der folgenden Schritte aus:
  • Setzen Sie mit der Funktion IdOpenSSLSetLibPath() von Indy den Pfad auf den Speicherort auf dem Mac, an dem sich die Bibliotheksdateien (libcrypto.dylib und libssl.dylib) befinden.

    Hinweis: Dass der Mac die OpenSSL-Bibliotheken selbständig findet, funktioniert höchstwahrscheinlich auf der iOS-Simulator-Zielplattform nicht, da sich möglicherweise eine nicht unterstützte Version der OpenSSL-Bibliotheksdateien in den vom Simulator verwendeten Bibliotheksordnern befindet.

  • Kopieren Sie die OpenSSL-Bibliotheksdateien für den iOS-Simulator vom Mac in Ihren Projektquellordner, und stellen Sie sie für den Simulator zusammen mit Ihrer Anwendung bereit.

Um eine funktionierende Anwendung zu erhalten, die die OpenSSL-Bibliothek verwendet, müssen Sie IdSSLOpenSSLHeaders_static allen uses-Klauseln Ihres Projekts hinzufügen.

Wenn Sie eine C++-iOS-Anwendung erstellen, müssen Sie Ihr Projekt so konfigurieren, dass die benötigten Bibliotheken in Ihr Projekt einbezogen werden. Wählen Sie Projekt > Optionen > C++-Linker, und setzen Sie "Mit SSL und Crypto linken" auf True.

Laden und Bereitstellen von Dateien

Wenn Sie bei der Bereitstellung Ihrer Anwendung für die Zielplattform "iOS-Gerät" (iOS-Gerät - 32 Bit oder iOS-Gerät - 64 Bit) Dateien zusammen mit der Anwendung weitergeben und diese zur Laufzeit geladen werden sollen, verwenden Sie den Bereitstellungs-Manager, um diese Dateien während der Bereitstellung in den Ordner StartUp\Documents zu platzieren.

Mit dem folgenden Code können Sie diese Dateien zur Laufzeit ermitteln:

Delphi:

TPath.Combine(TPath.GetDocumentsPath, 'filename')

C++:

System::Ioutils::TPath::Combine(System::Ioutils::TPath::GetDocumentsPath(), L"filename")

filename ist hier der Name Ihrer Datei, wie z. B. dbdemos.gdb im obigen Screenshot. Der Record TPath wird in der Unit System.IOUtils deklariert, daher müssen Sie eine Referenz auf diese Unit hinzufügen.

Schreiben von Code nur für iOS

Sie können mit der bedingten Compilierung Code schreiben, der nur erzeugt wird, wenn es sich bei der Zielplattform um iOS handelt.

In Delphi können Sie die folgenden vordefinierten Bedingungen verwenden:

{$IF Defined(IOS) }
// Code for both iOS devices and iOS simulators.
{$ENDIF}

{$IF Defined(IOS) and Defined(CPUARM) }
// Code for iOS devices only.
{$ENDIF}

{$IF Defined(IOS) and Defined(CPUARM) and not Defined(CPUARM64) }
// Code for 32-bit iOS devices only.
{$ENDIF}

{$IF Defined(IOS) and Defined(CPUARM64) }
// Code for 64-bit iOS devices only.
{$ENDIF}

{$IF Defined(IOS) and Defined(CPUX86) }
// Code for iOS simulators only.
{$ENDIF}

In C++ empfiehlt Apple die Verwendung von Definitionen in der Header-Datei TargetConditionals.h, die von der Header-Datei System.hpp einbezogen wird:

#if (TARGET_OS_IPHONE)
// Code for iOS devices only.
#endif

#if (TARGET_OS_IPHONE) && (__arm__)
// Code for 32-bit iOS devices only.
#endif

#if (TARGET_OS_IPHONE) && (__arm64__)
// Code for 64-bit iOS devices only.
#endif

Eine weitere Möglichkeit ist Verwendung von Definitionen in der Header-Datei sysmac.h, die auch von der Header-Datei System.hpp einbezogen wird. Im Gegensatz zum früheren C++-Code können Sie mit folgendem Code die Überprüfung, ob das Gerät die 32-Bit- oder 64-Bit-Compiler-Architektur unterstützt, vermeiden:

#if (_PLAT_IOS)
// Code for iOS devices only.
#endif

#if (_PLAT_IOS32)
// Code for 32-bit iOS devices only.
#endif

#if (_PLAT_IOS64)
// Code for 64-bit iOS devices only.
#endif

Alternativ können Sie mit Definitionen die iOS-Compiler ermitteln:

• BCCIOSARM-Compiler (32-Bit-iOS-Geräte)
• BCCIOSARM64-Compiler (64-Bit-iOS-Geräte)

Weitere Informationen über plattformspezifische Definitionen finden Sie unter Vordefinierte Makros und Vordefinierte Bedingungen.

Implementieren von iOS-spezifischen Features

In den folgenden Themen wird beschrieben, wie Sie bestimmte iOS-spezifische Features in Ihre Anwendungen implementieren:

• Verwenden des iOS-In-App-Kaufdienstes
• Verwenden des iAd-Dienstes
• Verwenden von nativen iOS-Steuerelementen
• Auswählen des richtigen Standards für Ihre App
• Verwenden von Stilen für iOS

Im FireMonkey-Anwendungshandbuch finden Sie die Dokumentation zu anderen, plattformunabhängigen Features.

Siehe auch

• Plattformvoraussetzungen für FireMonkey
• Regeln für die Benennung von geräteübergreifenden Projekten und Dateien
• Bereitstellen von iOS-Anwendungen für die Ad-hoc-Weitergabe
• Bereitstellen von iOS-Anwendungen für die Übermittlung an den App Store
• Vorlagen für geräteübergreifende Anwendungen
• Mobile iOS-Anwendungsentwicklung
• Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)
  • Mobile-Tutorial: Erstellen einer Anwendung für mobile Plattformen (iOS und Android)
• Erstellen einer FireMonkey-Komponente (Delphi)
• FireMonkey-Anwendungsdesign
• Erstellen einer FireMonkey-Anwendung
• Erstellen einer Android-App
• iOS Dev Center (EN)
• EDN: iOS User Interface Design with Delphi XE4 (EN)

Beispiele

• FireMonkey Device Info (Beispiel)