Cover

Update inside.

Mit unserem kostenlosen Update-Service zum Buch erhalten Sie aktuelle Infos zu den neuen Versionen von Swift, Xcode, macOS, iOS, watchOS und tvOS.

Und so funktioniert es:

1.      Registrieren Sie sich unter:
www.hanser-fachbuch.de/swift-update

2.      Geben Sie diesen Code ein:

Image

Der Update-Service läuft bis Mai 2021. Als registrierter Nutzer werden Sie in diesem Zeitraum persönlich per E-Mail informiert, sobald ein neues Buch-Update zum Download verfügbar ist.

Wenn Sie Fragen haben, wenden Sie sich gerne an: swift-update@hanser.de

Thomas Sillmann

Das Swift-Handbuch

Apps programmieren
für macOS, iOS, watchOS und tvOS

Der Autor:

Thomas Sillmann, Aschaffenburg
www.thomassillmann.de

Alle in diesem Buch enthaltenen Informationen, Verfahren und Darstellungen wurden nach bestem Wissen zusammengestellt und mit Sorgfalt getestet. Dennoch sind Fehler nicht ganz auszuschließen. Aus diesem Grund sind die im vorliegenden Buch enthaltenen Informationen mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Autor und Verlag übernehmen infolgedessen keine juristische Verantwortung und werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Informationen – oder Teilen davon – entsteht.

Ebenso übernehmen Autor und Verlag keine Gewähr dafür, dass beschriebene Verfahren usw. frei von Schutzrechten Dritter sind. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Buch berechtigt deshalb auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.

Bibliografische Information der Deutschen Nationalbibliothek:
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

Dieses Werk ist urheberrechtlich geschützt.
Alle Rechte, auch die der Übersetzung, des Nachdruckes und der Vervielfältigung des Buches, oder Teilen daraus, vorbehalten. Kein Teil des Werkes darf ohne schriftliche Genehmigung des Verlages in irgendeiner Form (Fotokopie, Mikrofilm oder ein anderes Verfahren) – auch nicht für Zwecke der Unterrichtsgestaltung – reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden.

Print-ISBN:       978-3-446-45505-4
E-Book-ISBN:  978-3-446-45730-0
E-Pub-ISBN:    978-3-446-46107-9

Bis zum Mond und wieder zurück haben wir uns lieb.“

 

Für meinen Vater

Wo Du auch bist, Du begleitest mich auf meiner Reise –
bis zu jenem Tag, an dem wir uns wiedersehen
und uns viele Geschichten erzählen werden.

Inhalt

Titelei

Impressum

Inhalt

Vorwort

Teil I: Swift

1 Die Programmiersprache Swift

1.1 Die Geschichte von Swift

1.2 Swift-Updates

1.3 Voraussetzungen für die Nutzung von Swift

1.4 Installation von Swift

1.4.1 macOS

1.4.2 Linux

1.5 Playgrounds

1.5.1 Erstellen eines Playgrounds

1.5.2 Aufbau eines Playgrounds

1.5.3 Pages, Sources und Resources

1.5.4 Playground-Formatierungen

1.5.5 Swift Playgrounds-App für das iPad

2 Grundlagen der Programmierung

2.1 Grundlegendes

2.1.1 Swift Standard Library

2.1.2 print

2.1.3 Befehle und Semikolons

2.1.4 Operatoren

2.2 Variablen und Konstanten

2.2.1 Erstellen von Variablen und Konstanten

2.2.2 Variablen und Konstanten in der Konsole ausgeben

2.2.3 Type Annotation und Type Inference

2.2.4 Gleichzeitiges Erstellen und Deklarieren mehrerer Variablen und Konstanten

2.2.5 Namensrichtlinien

2.3 Kommentare

3 Schleifen und Abfragen

3.1 Schleifen

3.1.1 for-in

3.1.2 while

3.1.3 repeat-while

3.2 Abfragen

3.2.1 if

3.2.2 switch

3.2.3 guard

3.3 Control Transfer Statements

3.3.1 Anstoßen eines neuen Schleifendurchlaufs mit continue

3.3.2 Verlassen der kompletten Schleife mit break

3.3.3 Labeled Statements

4 Typen in Swift

4.1 Integer

4.2 Fließkommazahlen

4.3 Bool

4.4 String

4.4.1 Erstellen eines Strings

4.4.2 Zusammenfügen von Strings

4.4.3 Character auslesen

4.4.4 Character mittels Index auslesen

4.4.5 Character entfernen und hinzufügen

4.4.6 Anzahl der Character zählen

4.4.7 Präfix und Suffix prüfen

4.4.8 String Interpolation

4.5 Array

4.5.1 Erstellen eines Arrays

4.5.2 Zusammenfügen von Arrays

4.5.3 Inhalte eines Arrays leeren

4.5.4 Prüfen, ob ein Array leer ist

4.5.5 Anzahl der Elemente eines Arrays zählen

4.5.6 Zugriff auf die Elemente eines Arrays

4.5.7 Neue Elemente zu einem Array hinzufügen

4.5.8 Bestehende Elemente aus einem Array entfernen

4.5.9 Bestehende Elemente eines Arrays ersetzen

4.5.10 Alle Elemente eines Arrays auslesen und durchlaufen

4.6 Set

4.6.1 Erstellen eines Sets

4.6.2 Inhalte eines bestehenden Sets leeren

4.6.3 Prüfen, ob ein Set leer ist

4.6.4 Anzahl der Elemente eines Sets zählen

4.6.5 Element zu einem Set hinzufügen

4.6.6 Element aus einem Set entfernen

4.6.7 Prüfen, ob ein bestimmtes Element in einem Set vorhanden ist

4.6.8 Alle Elemente eines Sets auslesen und durchlaufen

4.6.9 Sets miteinander vergleichen

4.6.10 Neue Sets aus bestehenden Sets erstellen

4.7 Dictionary

4.7.1 Erstellen eines Dictionaries

4.7.2 Prüfen, ob ein Dictionary leer ist

4.7.3 Anzahl der Schlüssel-Wert-Paare eines Dictionaries zählen

4.7.4 Wert zu einem Schlüssel eines Dictionaries auslesen

4.7.5 Neues Schlüssel-Wert-Paar zu Dictionary hinzufügen

4.7.6 Bestehendes Schlüssel-Wert-Paar aus Dictionary entfernen

4.7.7 Bestehendes Schlüssel-Wert-Paar aus Dictionary verändern

4.7.8 Alle Schlüssel-Wert-Paare eines Dictionaries auslesen und durchlaufen

4.8 Tuple

4.8.1 Zugriff auf die einzelnen Elemente eines Tuples

4.8.2 Tuple und switch

4.9 Optional

4.9.1 Deklaration eines Optionals

4.9.2 Zugriff auf den Wert eines Optionals

4.9.3 Optional Binding

4.9.4 Implicitly Unwrapped Optional

4.9.5 Optional Chaining

4.9.6 Optional Chaining über mehrere Eigenschaften und Funktionen

4.10 Any und AnyObject

4.11 Type Alias

4.12 Value Type versus Reference Type

4.12.1 Reference Types auf Gleichheit prüfen

5 Funktionen

5.1 Funktionen mit Parametern

5.1.1 Argument Labels und Parameter Names

5.1.2 Default Value für Parameter

5.1.3 Variadic Parameter

5.1.4 In-Out-Parameter

5.2 Funktionen mit Rückgabewert

5.3 Function Types

5.3.1 Funktionen als Variablen und Konstanten

5.4 Verschachtelte Funktionen

5.5 Closures

5.5.1 Closures als Parameter von Funktionen

5.5.2 Trailing Closures

5.5.3 Autoclosures

6 Enumerations, Structures und Classes

6.1 Enumerations

6.1.1 Enumerations und switch

6.1.2 Associated Values

6.1.3 Raw Values

6.2 Structures

6.2.1 Erstellen von Structures und Instanzen

6.2.2 Eigenschaften und Funktionen

6.3 Classes

6.3.1 Erstellen von Klassen und Instanzen

6.3.2 Eigenschaften und Funktionen

6.4 Enumeration vs. Structure vs. Class

6.4.1 Gemeinsamkeiten und Unterschiede

6.4.2 Wann nimmt man was?

6.5 self

7 Eigenschaften und Funktionen von Typen

7.1 Properties

7.1.1 Stored Property

7.1.2 Lazy Stored Property

7.1.3 Computed Property

7.1.4 Read-Only Computed Property

7.1.5 Property Observer

7.1.6 Type Property

7.2 Globale und lokale Variablen

7.3 Methoden

7.3.1 Instance Methods

7.3.2 Type Methods

7.4 Subscripts

8 Initialisierung

8.1 Aufgabe der Initialisierung

8.2 Erstellen eigener Initializer

8.3 Initializer Delegation

8.3.1 Initializer Delegation bei Value Types

8.3.2 Initializer Delegation bei Reference Types

8.4 Failable Initializer

8.5 Required Initializer

8.6 Deinitialisierung

9 Vererbung

9.1 Überschreiben von Eigenschaften und Funktionen einer Klasse

9.2 Überschreiben von Eigenschaften und Funktionen einer Klasse verhindern

9.3 Zugriff auf die Superklasse

9.4 Initialisierung und Vererbung

9.4.1 Zwei-Phasen-Initialisierung

9.4.2 Überschreiben von Initializern

9.4.3 Vererbung von Initializern

9.4.4 Required Initializer

10 Speicherverwaltung mit ARC

10.1 Strong Reference Cycles

10.1.1 Weak References

10.1.2 Unowned References

10.1.3 Weak Reference vs. Unowned Reference

11 Weiterführende Sprachmerkmale von Swift

11.1 Nested Types

11.2 Extensions

11.2.1 Computed Properties

11.2.2 Methoden

11.2.3 Initializer

11.2.4 Subscripts

11.2.5 Nested Types

11.3 Protokolle

11.3.1 Deklaration von Eigenschaften und Funktionen

11.3.2 Der Typ eines Protokolls

11.3.3 Protokolle und Extensions

11.3.4 Vererbung in Protokollen

11.3.5 Class-only-Protokolle

11.3.6 Optionale Eigenschaften und Funktionen

11.3.7 Protocol Composition

11.3.8 Delegation

12 Type Checking und Type Casting

12.1 Type Checking mit „is“

12.2 Type Casting mit „as“

13 Error Handling

13.1 Deklaration und Feuern eines Fehlers

13.2 Reaktion auf einen Fehler

13.2.1 Mögliche Fehler mittels do-catch auswerten

13.2.2 Mögliche Fehler in Optionals umwandeln

13.2.3 Mögliche Fehler weitergeben

13.2.4 Mögliche Fehler ignorieren

14 Generics

14.1 Generic Functions

14.2 Generic Types

14.3 Type Constraints

14.4 Associated Types

15 Dateien und Interfaces

15.1 Modules und Source Files

15.2 Access Control

15.2.1 Access Level

15.2.2 Explizite und implizite Zuweisung eines Access Levels

15.2.3 Besonderheiten

Teil II: Xcode

16 Grundlagen, Aufbau und Einstellungen von Xcode

16.1 Über Xcode

16.2 Arbeiten mit Xcode

16.2.1 Dateien und Formate eines Xcode-Projekts

16.2.2 Umgang mit Dateien und Ordnern

16.3 Der Aufbau von Xcode

16.3.1 Toolbar

16.3.2 Navigator

16.3.3 Editor

16.3.4 Inspectors

16.3.5 Debug Area

16.4 Einstellungen

16.4.1 General

16.4.2 Accounts

16.4.3 Behaviors

16.4.4 Navigation

16.4.5 Fonts & Colors

16.4.6 Text Editing

16.4.7 Key Bindings

16.4.8 Source Control

16.4.9 Components

16.4.10 Locations

16.4.11 Server & Bots

16.5 Projekteinstellungen

16.5.1 Einstellungen am Projekt

16.5.2 Einstellungen am Target

16.5.3 Einstellungen am Scheme

17 Arbeiten mit dem Interface Builder

17.1 Grundlegende Nutzung des Interface Builders

17.2 Interfaces mithilfe der Inspectors optimieren

17.2.1 Identity Inspector

17.2.2 Attributes Inspector

17.2.3 Size Inspector

17.2.4 Connections Inspector

17.3 Interface und Code koppeln

17.4 Arten von Interface-Dateien

17.4.1 Storyboards

17.4.2 XIB-Files

17.4.3 Neue Interface-Dateien erstellen

18 Dokumentation, Devices und Organizer

18.1 Dokumentation

18.1.1 Aufbau und Funktionsweise

18.1.2 Direktzugriff im Editor

18.2 Devices und Simulatoren

18.2.1 Simulatoren

18.2.2 Devices

18.3 Organizer

19 Debugging und Refactoring

19.1 Debugging

19.1.1 Konsolenausgaben

19.1.2 Arbeiten mit Breakpoints

19.1.3 Debug Navigator

19.2 Refactoring

19.3 Instruments

20 Tipps und Tricks für das effiziente Arbeiten mit Xcode

20.1 Code Snippets

20.2 Open Quickly

20.3 Related Items

20.4 Navigation über die Jump Bar

20.5 MARK, TODO und FIXME

20.6 Shortcuts für den Navigator

20.7 Clean Build

Teil III: Apple-Plattformen

21 macOS – Grundlagen

21.1 Über macOS

21.2 Funktionsweise einer macOS-App

21.2.1 Bestandteile einer macOS-App

21.2.2 App-Start

21.2.3 Das AppKit-Framework

21.2.4 Arten von macOS-Apps

21.3 Ein erstes macOS-Projekt

21.3.1 Auswahl einer Template-Vorlage

21.3.2 Rundgang durch die erstellten Dateien

21.3.3 Hello World

21.4 Der NSApplicationDelegate

21.5 NSWindow und NSWindowController im Detail

21.5.1 NSWindow

21.5.2 NSWindowController

21.5.3 Zusammenspiel

21.6 NSViewController im Detail

21.6.1 View life cycle

21.6.2 Einblenden neuer View-Controller

21.6.3 Ausblenden eines View-Controllers

21.6.4 Verknüpfen von View-Controllern mittels Segue

21.7 Oberflächen gestalten mit NSView

21.7.1 View-Hierarchien

21.7.2 Anpassen von Views im Attributes Inspector

21.7.3 Verfügbare NSView-Subklassen

21.7.4 Views und Actions

21.8 App-Icon

21.9 Target-Einstellungen

22 macOS – App-Entwicklung

22.1 Tabellen erstellen

22.1.1 Grundlegende Infos

22.1.2 Erstellen und Konfigurieren einer Table-View

22.1.3 Erstellen von Zellen

22.1.4 Zellen hinzufügen und entfernen

22.1.5 Auf Doppelklick reagieren

22.2 Menü anpassen

22.2.1 Hauptmenü über das Storyboard aktualisieren

22.2.2 Menüs im Code anpassen und aktualisieren

22.2.3 Tooltip definieren

22.2.4 Kontextmenü umsetzen

22.3 Alerts einblenden

22.3.1 Action-Buttons ergänzen

22.3.2 Hilfe-Button einbinden

22.3.3 Zusätzliche View in Alert einbinden

22.4 Touch Bar verwenden

22.4.1 Programmatische Bestandteile der Touch Bar

22.4.2 Touch Bar anpassen

22.4.3 Konfigurationsmöglichkeiten der Touch Bar

22.4.4 Touch Bar Items im Detail

22.4.5 Touch Bar im Interface Builder erzeugen

22.4.6 Prototyping im Playground

23 iOS – Grundlagen

23.1 Über iOS

23.2 Funktionsweise einer iOS-App

23.2.1 Bestandteile einer iOS-App

23.2.2 App-Start

23.2.3 Das UIKit-Framework

23.3 Ein erstes iOS-Projekt

23.3.1 Auswahl einer Template-Vorlage

23.3.2 Rundgang durch die erstellten Dateien

23.3.3 Hello World

23.4 Der UIApplicationDelegate

23.4.1 Lebenszyklus einer iOS-App

23.4.2 Die window-Property

23.4.3 Einsatzzweck des App Delegate

23.5 UIViewController im Detail

23.5.1 Aufbau

23.5.2 Ansicht eines View-Controllers anpassen

23.5.3 Verbindung zwischen Interface und Code

23.5.4 Lebenszyklus eines View-Controllers

23.5.5 Neuen View-Controller einblenden

23.6 Oberflächen gestalten mit UIView

23.6.1 Aufbau von Views

23.6.2 Erstellen von Views

23.6.3 Grundlegende Eigenschaften aller Views

23.6.4 Verfügbare UIView-Subklassen

23.6.5 Views mit Actions verbinden

23.7 Arbeit mit dem Simulator

23.7.1 Ausführen von Apps im Simulator

23.7.2 Arbeiten mit dem Simulator

23.7.3 Verwalten der Simulatoren

23.7.4 Einschränkungen des Simulators

23.8 App-Icon

23.9 Target-Einstellungen

24 iOS – App-Entwicklung

24.1 Aufbau einer Navigationsstruktur

24.1.1 UINavigationController im Code erstellen

24.1.2 UINavigationController im Storyboard erstellen

24.2 Erstellen einer Tab-Bar

24.2.1 Erstellen einer Tab-Bar im Code

24.2.2 Erstellen einer Tab-Bar im Storyboard

24.2.3 Der More-Tab

24.2.4 Zugriff auf zugrunde liegenden Tab-Bar-Controller

24.3 Erstellen von Tabellen

24.3.1 Funktionsweise einer Table-View

24.3.2 Hinzufügen einer Tabelle zu einem View-Controller

24.3.3 Erstellen von Zellen für eine Tabelle

24.3.4 Implementieren des Data Source

24.3.5 Wiederverwendung von Zellen

24.3.6 Table-View um weitere Bereiche ergänzen

24.3.7 Style einer Table-View verändern

24.3.8 Zellen im Storyboard gestalten

24.3.9 Größe einer Zelle verändern

24.3.10 Auf Auswahl einer Zelle reagieren

24.3.11 Der UITableViewController

24.3.12 Statische Tabellen im Storyboard erstellen

24.4 Eingabe von Text

24.4.1 Text eingeben über einfache Textfelder

24.4.2 Text eingeben und verwalten über umfangreiche Textansichten

24.4.3 Auf Ein- und Ausblenden des Keyboards reagieren

24.5 Einblenden von Alerts

24.5.1 Alert um Aktionen ergänzen

24.5.2 Alert um Textfelder ergänzen

24.6 Zugriff auf die Kamera und Fotos

24.6.1 Aufnahme und Auswahl auswerten

24.6.2 Videos aufnehmen und wiedergeben

24.6.3 Foto- und Videoaufnahme parallel erlauben

24.7 Erkennen von Gesten

24.7.1 UITapGestureRecognizer

24.7.2 UIPinchGestureRecognizer

24.7.3 UISwipeGestureRecognizer

24.7.4 UIPanGestureRecognizer

24.7.5 UILongPressGestureRecognizer

24.7.6 Weitere Gesture Recognizer

24.7.7 Erstellung im Code

25 watchOS – Grundlagen

25.1 Über watchOS

25.2 Funktionsweise einer watchOS-App

25.2.1 Bestandteile einer watchOS-App

25.2.2 App-Start

25.2.3 Das WatchKit-Framework

25.3 Ein erstes watchOS-Projekt

25.4 Die WatchKit App

25.4.1 Grundlegende Interface-Elemente

25.4.2 Oberflächen gestalten

25.4.3 Die Klasse WKInterfaceObject

25.5 Die WatchKit Extension

25.5.1 Der WKExtensionDelegate

25.5.2 Der WKInterfaceController

25.6 Grundlagen der App-Entwicklung

25.6.1 Interface und Code koppeln

25.6.2 Neuen Interface-Controller einblenden

25.6.3 context-Parameter

25.6.4 Aktuellen Interface-Controller ausblenden

25.6.5 Einschränkungen

25.7 App-Icon

26 watchOS – App-Entwicklung

26.1 Navigationsstruktur umsetzen

26.2 Alerts erstellen und anzeigen

26.3 Kontextmenü umsetzen

26.3.1 Kontextmenü im Storyboard umsetzen

26.3.2 Kontextmenü im Code umsetzen

26.3.3 Menu Items in Storyboard und Code mischen

26.3.4 Typische Einsatzzwecke von Kontextmenüs

26.4 Tabellen erstellen

26.4.1 Aufbau einer Tabelle

26.4.2 Row Controller-Klasse erstellen

26.4.3 Zellen erstellen und laden

26.4.4 Zellen konfigurieren

26.4.5 Tabelle mit verschiedenen Row Controllern umsetzen

26.4.6 Auf Zellenauswahl reagieren

26.4.7 Zellen hinzufügen und entfernen

26.4.8 Item Pagination

26.5 Text eingeben

26.5.1 Emojis in Texten verwenden

26.5.2 Mehrsprachige Empfehlungen umsetzen

26.6 Audio und Video wiedergeben

26.6.1 Medienwiedergabe über Interface-Element umsetzen

26.6.2 Medienwiedergabe ohne modales Interface umsetzen

26.7 Audio aufnehmen

26.8 Drehen der Digital Crown abfangen

26.9 Animationen durchführen

26.10 Komplikationen erstellen

26.10.1 Technische Funktionsweise von Komplikationen

26.10.2 Complication Families und Templates

26.10.3 Bestehendes Projekt um Complication-Support ergänzen

26.10.4 Neues watchOS-Projekt inklusive Complication-Support erstellen

26.10.5 Komplikationen für verschiedene Zeitpunkte konfigurieren

26.10.6 Data Provider

26.10.7 Privatsphäre für Komplikationen definieren

27 tvOS – Grundlagen und App-Entwicklung

27.1 Über tvOS

27.2 Funktionsweise einer tvOS-App

27.3 Ein erstes tvOS-Projekt

27.3.1 Auswahl einer Template-Vorlage

27.3.2 Rundgang durch die erstellten Dateien

27.3.3 Hello World

27.4 App Delegate, View-Controller und Views

27.5 Die Focus Engine im Detail

27.5.1 Zu fokussierende View selbst definieren

27.5.2 Fokus-Aktualisierung anstoßen

27.6 Arbeiten mit dem Simulator

27.7 App-Icon und Top Shelf Image

28 Cross-Platform

28.1 Das Foundation-Framework

28.1.1 NSObject

28.1.2 NSString

28.1.3 NSNumber

28.1.4 NSArray

28.1.5 NSSet

28.1.6 NSDictionary

28.1.7 Mutable-Klassen

28.2 MVC

28.2.1 MVC in der Praxis

28.2.2 Kommunikation zwischen Model und Controller

28.2.3 Kommunikation zwischen View und Controller

28.3 Auto Layout

28.3.1 Grundlagen

28.3.2 Constraints über Menü setzen

28.3.3 Constraints durch Ziehen mit der Maus setzen

28.3.4 Bestehende Constraints einsehen und bearbeiten

28.3.5 Vorschau in Xcode anzeigen lassen

28.3.6 Auto Layout deaktivieren

28.4 Lokalisierung von Apps

28.4.1 Grundlagen

28.4.2 Interfaces übersetzen

28.4.3 Verschiedene Sprachen einer App testen

28.5 Asset Catalogs

28.6 Nutzereinstellungen

Teil IV: Frameworks und Technologien

29 Authentifizierung

29.1 Funktionsweise

29.2 Verfügbare Authentifizierungstechniken

29.3 Lokalisierung der Schaltflächen

29.4 Zeitintervall zur Wiederverwendung von Touch ID

29.5 Informationen zur Veränderung der biometrischen Nutzerdaten

29.6 Authentifizierung abbrechen

29.7 Mögliche Fehlercodes

29.8 Tests im Simulator

30 iCloud

30.1 Nutzungsmöglichkeiten der iCloud

30.2 Vorbereitung

30.3 Nutzereinstellungen in der iCloud

30.3.1 Nutzereinstellungen speichern und laden

30.3.2 Auf Änderungen reagieren

30.4 Zugriff auf iCloud Drive

30.4.1 Container-Ordner in iCloud Drive erzeugen

30.5 CloudKit

30.5.1 Funktionsweise und Begrifflichkeiten

30.5.2 Das CloudKit Dashboard

30.5.3 Arbeiten mit dem CloudKit-Framework

31 Siri

31.1 Funktionsweise und Einschränkungen

31.2 Siri-Support vorbereiten

31.2.1 Siri-Capability aktivieren

31.2.2 Info.plist aktualisieren

31.2.3 Zugriff auf Siri erfragen

31.3 Intents Extension

31.3.1 Funktionsweise

31.3.2 Unterstützte Intents definieren

31.3.3 Intents implementieren

31.3.4 Intents testen

31.4 Intents UI Extension

31.5 Siri Shortcuts

31.5.1 Funktionsweise

31.5.2 Siri Shortcuts mit NSUserActivity

31.5.3 Siri Shortcuts mit Intents

31.5.4 Shortcuts testen

31.5.5 Shortcuts löschen

Teil V: Source Control und Testing

32 Source Control

32.1 Basisfunktionen und -begriffe der Source Control

32.2 Source Control in Xcode

32.2.1 Bestehendes Projekt klonen

32.2.2 Lokale Änderungen committen

32.2.3 Lokale Änderungen verwerfen

32.2.4 Pull und Push

32.2.5 Aktuelle Branches vom Repository laden

32.2.6 Git-Repository mit neuem Xcode-Projekt erzeugen

32.2.7 Optische Source Control-Hervorhebungen im Editor

32.2.8 Zugriff auf GitHub, GitLab und Bitbucket

32.3 Version Editor

33 Testing

33.1 Unit-Tests

33.1.1 Aufbau und Funktionsweise von Unit-Tests

33.1.2 Aufbau einer Test-Case-Klasse

33.1.3 Neue Test-Case-Klasse erstellen

33.1.4 Ausführen von Unit-Tests

33.1.5 Was sollte ich eigentlich testen?

33.2 Performance-Tests

33.3 UI-Tests

33.3.1 Klassen für UI-Tests

33.3.2 Aufbau von UI-Test-Klassen

33.3.3 Automatisches Erstellen von UI-Tests

33.3.4 Einsatz von UI-Tests

Teil VI: Veröffentlichung von Apps

34 Veröffentlichung im App Store

34.1 Das Apple Developer Portal

34.1.1 Zertifikate, App IDs und Provisioning Profiles

34.1.2 Code Signing

34.2 App Store Connect

34.2.1 Apps für den App Store vorbereiten und verwalten

34.2.2 Apps erstellen, hochladen und einreichen

34.3 App Store Review Guidelines

35 Das Business Model für Ihre App

35.1 Geschäftsmodelle

35.1.1 Free Model

35.1.2 Freemium Model

35.1.3 Subscription Model

35.1.4 Paid Model

35.1.5 Paymium Model

35.2 App Bundles

35.3 Universal Purchase für iOS und tvOS

35.4 Veröffentlichung außerhalb des App Store

35.4.1 Das Apple Developer Enterprise Program

36 TestFlight

36.1 TestFlight in App Store Connect

36.2 TestFlight im App Store

Vorwort

Liebe Leserin, lieber Leser,

als Apple auf der World Wide Developers Conference im Juni 2014 für alle Welt überraschend eine komplett neue Programmiersprache vorstellte, war das etwas ganz Besonderes für mich und meine Entwicklerkollegen. Bis zu diesem Zeitpunkt war Objective-C die Sprache der Wahl, wenn es um die Programmierung für Apple-Plattformen ging. Das war weiß Gott nichts Schlechtes, aber man merkt Objective-C nun einmal sowohl ein gewisses Alter wie auch diverse Eigenheiten an.

Swift ist da ganz anders. Schon beim Starten in die Programmierung mit Swift merkt man schnell, wie einfach und verständlich doch vieles von der Hand geht. Dazu kommen clevere Konzepte wie die Optionals und das Error Handling (über die Sie noch ausführlich in diesem Buch lesen werden), die Swift zu einer sehr sicheren Sprache machen, mit der man gerne programmiert. So zumindest geht es den meisten, die entweder den Sprung gewagt und sich von Objective-C kommend Swift zugewandt haben oder die frisch in die Entwicklung für Apple-Plattformen mit Swift eingestiegen sind.

Für Apple ist Swift heute ein immens wichtiger Baustein der Anwendungsentwicklung. Swift ist inzwischen Open Source und bereits bei Version 5 angekommen. Auf Apples Entwicklerkonferenzen sieht man ausschließlich Code-Beispiele, die in Swift geschrieben sind. Und Apple hat sogar manche der eigenen Apps in Swift komplett neu entwickelt. Der Weg scheint klar: Swift gehört die Zukunft.

Mit diesem Buch möchte ich Ihnen, liebe Leserin, lieber Leser, das notwendige Wissen vermitteln, um selbst eigene Apps mit Swift für iOS, macOS und Co. entwickeln und über den App Store vertreiben zu können. Hierbei ist es mir wichtig, Sie nicht mit einer Vielzahl von fertigen Beispielprojekten zu erschlagen und Ihnen zu erklären, wie Sie diese nachprogrammieren. Stattdessen möchte ich Ihnen einen möglichst umfangreichen und vielseitigen Überblick darüber geben, was Sie alles für spannende Funktionen in Apps für iPhone, iPad, Mac, Apple Watch und Apple TV umsetzen können und Ihnen ausführlich erklären, wie Sie dabei vorzugehen haben und worauf Sie achten müssen. Das Buch soll Ihnen sowohl als Neuling beim Lernen helfen, wie auch alten Hasen noch das ein oder andere Detail vor Augen führen, das einem bisher möglicherweise entgangen war.

Anhand dieser Prämisse ist auch der grundlegende Aufbau des Buches entstanden, der sich in insgesamt sechs verschiedene Teile untergliedert. Ganz zu Beginn steht die titelgebende Programmiersprache Swift. Im ersten Teil erfahren Sie in insgesamt fünfzehn Kapiteln alles, um eigenen Swift-Code schreiben und die vielen spannenden Facetten dieser Sprache wie Generics und die bereits erwähnten Optionals optimal einsetzen zu können. In diesen Kapiteln geht es nur um Swift und nichts anderes.

Im zweiten Teil geht es weiter mit Xcode, der Entwicklungsumgebung von Apple. Sie erfahren, wie Sie die IDE installieren, wie sie aufgebaut ist und wie Sie durch Projekte navigieren und sich darin zurechtfinden.

In Teil III geht es schließlich um die Betrachtung der verschiedenen Plattformen von Apple und darum, wie Sie Apps für diese entwickeln. Jedes Betriebssystem – macOS, iOS, watchOS und tvOS – verfügt in Teil 3 über wenigstens ein Kapitel, in dem Sie alles über die grundlegende Architektur der jeweiligen Plattform sowie über die Besonderheiten bei der App-Entwicklung erfahren. Auch gebe ich Ihnen eine Einschätzung, für welche Arten von Apps die verschiedenen Betriebssysteme gedacht sind – und für welche nicht. In einem abschließenden Cross-Platform-Kapitel stelle ich Ihnen außerdem einige spannende Funktionen vor, die für alle Plattformen von Apple gleichermaßen relevant sind.

Mir war es wichtig, darauf zu achten, alle Kapitel des dritten Teils möglichst unabhängig voneinander zu gestalten. Sie haben bereits grundlegende Erfahrung mit der iOS-Entwicklung? Dann steigen Sie direkt in das zugehörige Kapitel zur App-Entwicklung ein und überspringen Sie die Basics! Dafür ist Ihnen die Programmierung für macOS noch vollkommen fremd? Kein Problem, das Grundlagenkapitel zur macOS-Entwicklung nimmt Sie an die Hand und zeigt Ihnen, wie die Plattform aus Sicht eines App-Entwicklers funktioniert. Auch die Themen, die in den einzelnen Kapiteln behandelt werden, sind so geschrieben, dass Sie direkt mit einer bestimmten Funktion (beispielsweise dem Erstellen von Tabellen unter iOS) einsteigen können, ohne vorher die anderen Kapitel zwingend lesen zu müssen.

Nach der Betrachtung der verschiedenen Plattformen von Apple geht es im vierten Teil des Buches um einige spezielle Frameworks und Technologien, mit denen Sie die Funktionalität Ihrer Apps erweitern können. Dazu gehören unter anderem Themen wie iCloud, Siri oder die Implementierung von Touch ID beziehungsweise Face ID.

In Teil V stelle ich Ihnen die Source Control-Möglichkeiten von Xcode vor und zeige Ihnen, wie Sie Unit-, UI- und Performance-Tests für Ihre Apps schreiben und ausführen. Im sechsten und letzten Teil erfahren Sie schließlich alles zur Veröffentlichung Ihrer Anwendungen im App Store, welche Geschäftsmodelle sich umsetzen lassen und wie Sie Apps für Beta-Tests mittels TestFlight verteilen.

Bekanntermaßen lebt die digitale Welt vom ständigen Wandel und Fortschritt. Das betrifft auch die Arbeit von App-Entwicklern. Jedes Jahr werden auf Apples Entwicklerkonferenz WWDC Neuerungen und Änderungen in Bezug auf iOS, macOS und Co. vorgestellt. Auch die Programmiersprache Swift entwickelt sich stetig weiter. Um diesem Wandel Rechnung zu tragen, erhalten Sie für zwei Jahre nach Erscheinen des Swift-Handbuchs (also bis Mai 2021) kostenlose Buch-Updates in PDF-Form. Sie werden persönlich von uns benachrichtigt, wenn neue Updates zum Download zur Verfügung stehen. Registrieren Sie sich dazu einfach unter www.hanser-fachbuch.de/swift-update mit dem Passwort von Seite II.

Die kommenden Updates berücksichtigen Änderungen an bestehenden Funktionen, neue Features für die verschiedenen Betriebssysteme von Apple und für die Entwicklungsumgebung Xcode sowie Aktualisierungen von Swift. Darüber hinaus finden Sie aktuelle Artikel zur Programmierung sowie ergänzende Lehrvideos auf meiner Entwickler-Website unter letscode.thomassillmann.de.

Für mich persönlich ist die Programmierung mit Swift für die unterschiedlichen Apple-Systeme eine sehr erfüllende Aufgabe und mir war es wichtig, all meine Begeisterung für diese Thematik in dieses Buch einfließen zu lassen. Ich hoffe von Herzen, dass Sie Ihre Freude mit dem Werk haben werden, ganz gleich, ob Sie entweder frisch in die spannende Welt der Swift-Programmierung einsteigen oder als alter Hase noch das ein oder andere Neue lernen, das Ihnen bei zukünftigen Projekten nützlich ist.

Herzlichst,

Ihr Thomas Sillmann

Aschaffenburg, Januar 2019

Teil I: Swift
Image

Image       Kapitel 1: Die Programmiersprache Swift

Image       Kapitel 2: Grundlagen der Programmierung

Image       Kapitel 3: Schleifen und Abfragen

Image       Kapitel 4: Typen in Swift

Image       Kapitel 5: Funktionen

Image       Kapitel 6: Enumerations, Structures und Classes

Image       Kapitel 7: Eigenschaften und Funktionen von Typen

Image       Kapitel 8: Initialisierung

Image       Kapitel 9: Vererbung

Image       Kapitel 10: Speicherverwaltung mit ARC

Image       Kapitel 11: Weiterführende Sprachmerkmale von Swift

Image       Kapitel 12: Type Checking und Type Casting

Image       Kapitel 13: Error-Handling

Image       Kapitel 14: Generics

Image       Kapitel 15: Dateien und Interfaces

Image

1 Die Programmiersprache Swift