Entwicklung für iOS

iOS verlangt, dass jede App, die du erstellst und auf deinem Telefon oder Tablet ausführen möchtest, mit einem von Apple ausgestellten Zertifikat und Bereitstellungsprofil (provisioning profile) signiert werden muss. Dieses Handbuch erläutert die Schritte zur Erstellung eines Bundles deines Spiels für iOS. Während der Entwicklung ist es oft vorzuziehen, dein Spiel über die Entwicklungs-App auszuführen, da du damit Inhalte und Code per Hot Reload direkt auf dein Gerät laden kannst.

Apples Verfahren zur Codesignierung

Die Sicherheit von iOS-Apps setzt sich aus mehreren Bestandteilen zusammen. Zugang zu den benötigten Werkzeugen erhältst du, indem du dich für das iOS Developer Program von Apple anmeldest. Rufe nach deiner Anmeldung das Developer Member Center von Apple auf.

Der Bereich Certificates, Identifiers & Profiles enthält alle Werkzeuge, die du benötigst. Hier kannst du Folgendes erstellen, löschen und bearbeiten:

Certificates

Von Apple ausgestellte kryptografische Zertifikate, die dich als Entwickler identifizieren. Du kannst Entwicklungs- oder Produktionszertifikate erstellen. Mit Entwicklungszertifikaten kannst du bestimmte Funktionen wie den Mechanismus für In-App-Käufe in einer Sandbox-Testumgebung testen. Produktionszertifikate werden verwendet, um die fertige App für das Hochladen in den App Store zu signieren. Du benötigst ein Zertifikat, um Apps zu signieren, bevor du sie zum Testen auf dein Gerät übertragen kannst.

Identifiers

Kennungen für verschiedene Verwendungszwecke. Du kannst Kennungen mit Platzhaltern registrieren (z. B. some.prefix.*), die sich für mehrere Apps verwenden lassen. App-IDs können Informationen zu Anwendungsdiensten enthalten, etwa dazu, ob die App die Integration von Passbook, Game Center usw. aktiviert. Solche App-IDs können keine Kennungen mit Platzhaltern sein. Damit Anwendungsdienste funktionieren, muss die Bundle-ID deiner Anwendung mit der App-ID übereinstimmen.

Devices

Jedes Entwicklungsgerät muss mit seiner UDID (Unique Device IDentifier, siehe unten) registriert werden.

Provisioning Profiles

Bereitstellungsprofile verknüpfen Zertifikate mit App-IDs und einer Liste von Geräten. Sie legen fest, welche App von welchem Entwickler auf welchen Geräten vorhanden sein darf.

Zum Signieren deiner Spiele und Apps in Defold benötigst du ein gültiges Zertifikat und ein gültiges Bereitstellungsprofil.

Gerätekennung (UDID)

Die UDID eines iOS-Geräts findest du, indem du das Gerät per WLAN oder Kabel mit einem Computer verbindest. Öffne Xcode und wähle Window ▸ Devices and Simulators. Wenn du dein Gerät auswählst, werden die Seriennummer und die Kennung angezeigt.

Wenn du Xcode nicht installiert hast, kannst du die Kennung in iTunes finden. Klicke auf das Gerätesymbol und wähle dein Gerät aus.

1. Suche auf der Seite Summary nach Serial Number.
2. Klicke einmal auf Serial Number, damit das Feld zu UDID wechselt. Wenn du wiederholt klickst, werden verschiedene Informationen zum Gerät angezeigt. Klicke einfach weiter, bis UDID erscheint.
3. Klicke mit der rechten Maustaste auf die lange UDID-Zeichenfolge und wähle Copy, um die Kennung in die Zwischenablage zu kopieren. So kannst du sie bei der Registrierung des Geräts im Developer Member Center von Apple bequem in das UDID-Feld einfügen.

Mit einem kostenlosen Apple-Entwicklerkonto entwickeln

Seit Xcode 7 kann jeder Xcode installieren und kostenlos direkt auf einem Gerät entwickeln. Du musst dich nicht für das iOS Developer Program anmelden. Stattdessen stellt Xcode automatisch ein Zertifikat für dich als Entwickler (1 Jahr gültig) und ein Bereitstellungsprofil für deine App (eine Woche gültig) auf deinem jeweiligen Gerät aus.

1. Verbinde dein Gerät.
2. Installiere Xcode.
3. Füge Xcode ein neues Konto hinzu und melde dich mit deiner Apple-ID an.
4. Erstelle ein neues Projekt. Die einfachste Vorlage Single View App eignet sich dafür.
5. Wähle dein Team (wird automatisch für dich erstellt) und gib der App eine Bundle-ID.

1. Stelle sicher, dass Xcode ein Provisioning Profile und ein Signing Certificate für die App erstellt hat.

   

2. Erstelle den Build der App auf deinem Gerät. Beim ersten Mal fordert Xcode dich auf, den Entwicklermodus zu aktivieren, und bereitet das Gerät mit Debugger-Unterstützung vor. Dies kann eine Weile dauern.

3. Wenn du geprüft hast, dass die App funktioniert, suche sie auf deinem Datenträger. Den Speicherort des Builds findest du im Build-Bericht im Report Navigator.

   

4. Suche die App, klicke mit der rechten Maustaste darauf und wähle Show Package Contents.

   

5. Kopiere die Datei embedded.mobileprovision an einen Ort auf deinem Laufwerk, an dem du sie wiederfindest.

Mit dieser Bereitstellungsdatei und deiner Identität für die Codesignierung kannst du eine Woche lang Apps in Defold signieren.

Wenn die Gültigkeit des Bereitstellungsprofils abläuft, musst du den Build der App erneut in Xcode erstellen und dir wie oben beschrieben eine neue temporäre Bereitstellungsdatei beschaffen.

Ein iOS-Anwendungsbundle erstellen

Sobald du die Identität für die Codesignierung und das Bereitstellungsprofil hast, kannst du im Editor ein eigenständiges Anwendungsbundle für dein Spiel erstellen. Wähle dazu im Menü Project ▸ Bundle... ▸ iOS Application....

Wähle deine Identität für die Codesignierung, suche deine mobile Bereitstellungsdatei und wähle die Variante (Debug oder Release). Du kannst optional das Kontrollkästchen Sign application deaktivieren, um die Signierung zu überspringen und später manuell zu signieren. Aktiviere Simulator, um ein arm64_sim-ios-Bundle für den iOS-Simulator anstelle eines Gerätebundles zu erstellen.

Klicke auf Create Bundle. Anschließend wirst du aufgefordert, den Speicherort auf deinem Computer anzugeben, an dem das Bundle erstellt werden soll.

Das Symbol für die App, das Storyboard für den Startbildschirm und weitere Angaben legst du in der Projekteinstellungsdatei game.project im Abschnitt iOS fest.

Benutzerdefinierte Info.plist und Erkennung lokaler Ziele

Die integrierte iOS-Datei Info.plist enthält den Bonjour-Dienst und die Beschreibung der Nutzung des lokalen Netzwerks, die für die automatische Zielerkennung im Editor bei Builds erforderlich sind, die keine Release-Builds sind. Eine benutzerdefinierte Info.plist ersetzt dieses integrierte Basismanifest. Wenn du für einen Debug-Build ein benutzerdefiniertes Manifest verwendest und Zielerkennung, Profiling, Hot Reload oder die Übertragung von Protokollen über das lokale Netzwerk benötigst, füge diese Einträge hinzu:

{{^variant_release}}
<key>NSBonjourServices</key>
<array>
    <string>_defold._tcp</string>
</array>
<key>NSLocalNetworkUsageDescription</key>
<string>Discover Defold targets on the local network.</string>
{{/variant_release}}

Die Mustache-Bedingung verhindert, dass die Einträge zur Erkennung in Release-Bundles enthalten sind. iOS zeigt den Text zur Beschreibung der Nutzung dem Benutzer an; du kannst ihn anpassen oder lokalisieren. Entferne die Bedingung nur, wenn die Release-Anwendung selbst denselben Bonjour-Dienst und dieselbe Funktionalität im lokalen Netzwerk verwendet.

Build-Varianten

Wenn du ein Bundle für ein Spiel erstellst, musst du auswählen, welche Art von Engine du verwenden möchtest. Du hast drei grundlegende Optionen:

• Debug
• Release
• Headless

Diese verschiedenen Versionen werden auch als Build-Varianten (Build variants) bezeichnet.

Debug

Diese Art von ausführbarer Datei wird üblicherweise während der Entwicklung eines Spiels verwendet, da sie mehrere nützliche Debugging-Funktionen enthält:

• Profiler - Dient zum Erfassen von Leistungs- und Nutzungszählern. Wie du den Profiler verwendest, erfährst du im Profiling-Handbuch.
• Protokollierung - Die Engine protokolliert Systeminformationen, Warnungen und Fehler, wenn die Protokollierung aktiviert ist. Die Engine gibt außerdem Protokollmeldungen der Lua-Funktion print() sowie von nativen Erweiterungen (native extensions) aus, die mit dmLogInfo(), dmLogError() und ähnlichen Funktionen protokollieren. Wie du diese Protokolle liest, erfährst du im Handbuch zu Spiel- und Systemprotokollen.
• Hot Reload - Hot Reload ist eine leistungsfähige Funktion, mit der du während der Entwicklung Ressourcen (resources) neu laden kannst, während das Spiel läuft. Wie du diese Funktion verwendest, erfährst du im Hot-Reload-Handbuch.
• Engine-Dienste - Du kannst über verschiedene offene TCP-Ports und Dienste eine Verbindung zu einer Debug-Version eines Spiels herstellen und mit ihr interagieren. Zu diesen Diensten gehören die Hot-Reload-Funktion, der Fernzugriff auf Protokolle und der oben erwähnte Profiler, aber auch weitere Dienste zur Ferninteraktion mit der Engine. Mehr über die Engine-Dienste erfährst du in der Entwicklerdokumentation.

Release

Bei dieser Variante sind die Debugging-Funktionen deaktiviert. Du solltest diese Option wählen, wenn das Spiel zur Veröffentlichung im App Store oder zur Weitergabe an Spieler auf anderem Wege bereit ist. Aus mehreren Gründen wird davon abgeraten, ein Spiel mit aktivierten Debugging-Funktionen zu veröffentlichen:

• Die Debugging-Funktionen beanspruchen etwas Platz in der Binärdatei, und es ist bewährte Praxis, die Binärdatei eines veröffentlichten Spiels so klein wie möglich zu halten.
• Die Debugging-Funktionen beanspruchen auch etwas CPU-Zeit. Das kann die Leistung des Spiels beeinträchtigen, wenn ein Nutzer leistungsschwache Hardware verwendet. Auf Mobiltelefonen trägt die erhöhte CPU-Auslastung außerdem zur Erwärmung und zum Akkuverbrauch bei.
• Die Debugging-Funktionen können Informationen über das Spiel offenlegen, die nicht für die Augen der Spieler bestimmt sind, sei es im Hinblick auf Sicherheit, Schummeln oder Betrug.

Headless

Diese ausführbare Datei läuft ohne Grafik und Ton. Das bedeutet, dass du die Unit- und Smoke-Tests des Spiels auf einem CI-Server ausführen oder das Spiel sogar als Spielserver in der Cloud betreiben kannst.

Ein Bundle auf einem verbundenen iPhone installieren und starten

Du kannst das erstellte Bundle mit den Kontrollkästchen Install on connected device und Launch installed app im Bundle-Dialogfeld des Editors installieren und starten:

Damit diese Funktion verfügbar ist, muss das Kommandozeilenwerkzeug ios-deploy installiert sein. Am einfachsten installierst du es mit Homebrew:

$ brew install ios-deploy

Wenn der Editor den Installationsort des Werkzeugs ios-deploy nicht erkennen kann, musst du ihn in den Editoreinstellungen angeben.

Ein Storyboard erstellen

Eine Storyboard-Datei erstellst du mit Xcode. Starte Xcode und erstelle ein neues Projekt. Wähle iOS und Single View App:

Klicke auf Next und fahre mit der Konfiguration deines Projekts fort. Gib einen Product Name ein:

Klicke auf Create, um den Vorgang abzuschließen. Dein Projekt ist nun erstellt, und wir können mit der Erstellung des Storyboards fortfahren:

Ziehe ein Bild in das Projekt und lege es dort ab, um es zu importieren. Wähle anschließend Assets.xcassets und lege das Bild in Assets.xcassets ab:

Öffne LaunchScreen.storyboard und klicke auf die Plus-Schaltfläche (+). Gib imageview in das Dialogfeld ein, um die ImageView-Komponente zu finden.

Ziehe die Komponente Image View auf das Storyboard:

Wähle aus der Auswahlliste Image das Bild aus, das du zuvor zu Assets.xcassets hinzugefügt hast:

Positioniere das Bild und nimm alle weiteren gewünschten Anpassungen vor. Füge beispielsweise ein Label oder ein anderes UI-Element hinzu. Wenn du fertig bist, setze das aktive Schema auf Any iOS Device (arm64) (oder Generic iOS Device) und wähle Product ▸ Build. Defold unterstützt iOS 15.0 und neuer auf 64-Bit-Geräten. Belasse daher das Bereitstellungsziel bei 15.0 oder neuer. Warte, bis der Build-Vorgang abgeschlossen ist.

Wenn du Bilder im Storyboard verwendest, werden sie nicht automatisch in deine LaunchScreen.storyboardc aufgenommen. Verwende das Feld Bundle Resources in game.project, um Ressourcen einzuschließen. Erstelle beispielsweise den Ordner LaunchScreen im Defold-Projekt und darin den Ordner ios (der Ordner ios ist erforderlich, damit diese Dateien nur in iOS-Bundles enthalten sind). Lege deine Dateien dann in LaunchScreen/ios/ ab. Füge diesen Pfad in Bundle Resources hinzu.

Im letzten Schritt kopierst du die kompilierte Datei LaunchScreen.storyboardc in dein Defold-Projekt. Öffne im Finder den folgenden Speicherort und kopiere die Datei LaunchScreen.storyboardc in dein Defold-Projekt:

/Library/Developer/Xcode/DerivedData/YOUR-PRODUCT-NAME-cbqnwzfisotwygbybxohrhambkjy/Build/Intermediates.noindex/YOUR-PRODUCT-NAME.build/Debug-iphonesimulator/YOUR-PRODUCT-NAME.build/Base.lproj/LaunchScreen.storyboardc

Sobald du die Storyboard-Datei hast, kannst du in game.project darauf verweisen.

Einen Asset-Katalog für Symbole erstellen

Ein Asset-Katalog ist Apples bevorzugte Methode zur Verwaltung der Symbole deiner Anwendung. Tatsächlich ist dies die einzige Möglichkeit, das im App-Store-Eintrag verwendete Symbol bereitzustellen. Du erstellst einen Asset-Katalog genauso wie ein Storyboard mit Xcode. Starte Xcode und erstelle ein neues Projekt. Wähle iOS und Single View App:

Klicke auf Next und fahre mit der Konfiguration deines Projekts fort. Gib einen Product Name ein:

Klicke auf Create, um den Vorgang abzuschließen. Dein Projekt ist nun erstellt, und wir können mit der Erstellung des Asset-Katalogs fortfahren:

Ziehe Bilder in die leeren Felder für die verschiedenen unterstützten Symbolgrößen und lege sie dort ab:

Wenn du fertig bist, setze das aktive Schema auf Build -> Any iOS Device (arm64) (oder Generic iOS Device) und wähle Product -> Build. Warte, bis der Build-Vorgang abgeschlossen ist.

Im letzten Schritt kopierst du die kompilierte Datei Assets.car in dein Defold-Projekt. Öffne im Finder den folgenden Speicherort und kopiere die Datei Assets.car in dein Defold-Projekt:

/Library/Developer/Xcode/DerivedData/YOUR-PRODUCT-NAME-cbqnwzfisotwygbybxohrhambkjy/Build/Products/Debug-iphoneos/Icons.app/Assets.car

Sobald du die Asset-Katalogdatei hast, kannst du in game.project auf sie und die Symbole verweisen:

Ein iOS-Anwendungsbundle installieren

Der Editor schreibt eine Datei mit der Erweiterung .ipa, die ein iOS-Anwendungsbundle ist. Um die Datei auf deinem Gerät zu installieren, kannst du eines der folgenden Werkzeuge verwenden:

• Xcode über das Fenster Devices and Simulators
• das Kommandozeilenwerkzeug ios-deploy
• Apple Configurator 2 aus dem macOS App Store
• iTunes

Du kannst auch das Kommandozeilenwerkzeug xcrun simctl verwenden, um mit den über Xcode verfügbaren iOS-Simulatoren zu arbeiten:

# show a list of available devices
xcrun simctl list

# boot an iPhone X simulator
xcrun simctl boot "iPhone X"

# install your.app to a booted simulator
xcrun simctl install booted your.app

# launch the simulator
open /Applications/Xcode.app/Contents/Developer/Applications/Simulator.app

Datenschutzmanifest von Apple

Das Datenschutzmanifest ist eine Eigenschaftsliste, die die von deiner App oder einem SDK eines Drittanbieters erfassten Datenarten sowie die von deiner App oder dem SDK verwendeten APIs auflistet, deren Nutzung eine Begründung erfordert. Für jede erfasste Datenart und jede verwendete Kategorie solcher APIs muss deine App oder das SDK eines Drittanbieters die Gründe in der im Bundle enthaltenen Datenschutzmanifestdatei festhalten.

Defold stellt über das Feld Privacy Manifest in der Datei game.project ein standardmäßiges Datenschutzmanifest bereit. Beim Erstellen eines Anwendungsbundles wird das Datenschutzmanifest mit allen Datenschutzmanifesten in den Projektabhängigkeiten zusammengeführt und in das Anwendungsbundle aufgenommen.

Weitere Informationen zu Datenschutzmanifesten findest du in der offiziellen Dokumentation von Apple.

Angaben zur Einhaltung von Exportvorschriften

Wenn du dein Spiel beim App Store einreichst, wirst du aufgefordert, Angaben zur Einhaltung von Exportvorschriften im Hinblick auf die Verwendung von Verschlüsselung in deinem Spiel zu machen. Apple erklärt, warum dies erforderlich ist:

„Wenn du deine App bei TestFlight oder dem App Store einreichst, lädst du sie auf einen Server in den Vereinigten Staaten hoch. Wenn du deine App außerhalb der USA oder Kanadas vertreibst, unterliegt sie den US-Exportgesetzen, unabhängig davon, wo deine juristische Person ihren Sitz hat. Wenn deine App Verschlüsselung verwendet, darauf zugreift, sie enthält, implementiert oder integriert, gilt dies als Export von Verschlüsselungssoftware. Damit unterliegt deine App den US-Exportvorschriften sowie den Einfuhrvorschriften der Länder, in denen du deine App vertreibst.“

Die Defold-Game-Engine verwendet Verschlüsselung für die folgenden Zwecke:

• Aufrufe über sichere Kanäle (z. B. HTTPS und SSL)
• Urheberrechtlicher Schutz von Lua-Code (um eine Vervielfältigung zu verhindern)

Diese Verwendungen von Verschlüsselung in der Defold-Engine sind nach dem Recht der Vereinigten Staaten und der Europäischen Union von der Pflicht zur Vorlage von Dokumenten zur Einhaltung von Exportvorschriften ausgenommen. Die meisten Defold-Projekte bleiben davon ausgenommen. Durch das Hinzufügen anderer kryptografischer Verfahren kann sich dieser Status jedoch ändern. Es liegt in deiner Verantwortung, sicherzustellen, dass dein Projekt die Anforderungen dieser Gesetze und die Regeln des App Store erfüllt. Weitere Informationen findest du in Apples Übersicht zur Einhaltung von Exportvorschriften.

Wenn du davon ausgehst, dass dein Projekt ausgenommen ist, setze den Schlüssel ITSAppUsesNonExemptEncryption in der Datei Info.plist des Projekts auf False. Weitere Einzelheiten findest du unter Anwendungsmanifeste.

FAQ

Q: Ich kann mein Defold-Spiel mit einem kostenlosen Konto bei Apple Developer nicht installieren.

A: Stelle sicher, dass die Bundle-ID in deinem Defold-Projekt mit der Bundle-ID übereinstimmt, die du im Xcode-Projekt beim Erstellen des mobilen Bereitstellungsprofils verwendet hast.

Q: Wie kann ich die Berechtigungen einer als Bundle erstellten Anwendung prüfen?

A: Aus Berechtigungen einer erstellten App prüfen:

codesign -d --ent :- /path/to/the.app

Q: Wie kann ich die Berechtigungen eines Bereitstellungsprofils prüfen

A: Aus Berechtigungen eines Profils prüfen:

security cms -D -i /path/to/iOSTeamProfile.mobileprovision