1. Start Here

• 1.1 For Swift Programmers
• 1.2 For Non-Swift Programmers
• 1.3 Source Code Download
• 1.4 Feedback
• 1.5 Errata

2. Joining the Apple Developer Program FREE CHAPTER

• 2.1 Downloading Xcode 12 and the iOS 14 SDK
• 2.2 Apple Developer Program
• 2.3 When to Enroll in the Apple Developer Program?
• 2.4 Enrolling in the Apple Developer Program
• 2.5 Summary

3. Installing Xcode 12 and the iOS 14 SDK

• 3.1 Identifying Your macOS Version
• 3.2 Installing Xcode 12 and the iOS 14 SDK
• 3.3 Starting Xcode
• 3.4 Adding Your Apple ID to the Xcode Preferences
• 3.5 Developer and Distribution Signing Identities
• 3.6 Summary

4. An Introduction to Xcode 12 Playgrounds

• 4.1 What is a Playground?
• 4.2 Creating a New Playground
• 4.3 A Swift Playground Example
• 4.4 Viewing Results
• 4.5 Adding Rich Text Comments
• 4.6 Working with Playground Pages
• 4.7 Working with SwiftUI and Live View in Playgrounds
• 4.8 Summary

5. Swift Data Types, Constants and Variables

• 5.1 Using a Swift Playground
• 5.2 Swift Data Types
• 5.3 Swift Variables
• 5.4 Swift Constants
• 5.5 Declaring Constants and Variables
• 5.6 Type Annotations and Type Inference
• 5.7 The Swift Tuple
• 5.8 The Swift Optional Type
• 5.9 Type Casting and Type Checking
• 5.10 Summary

6. Swift Operators and Expressions

• 6.1 Expression Syntax in Swift
• 6.2 The Basic Assignment Operator
• 6.3 Swift Arithmetic Operators
• 6.4 Compound Assignment Operators
• 6.5 Comparison Operators
• 6.6 Boolean Logical Operators
• 6.7 Range Operators
• 6.8 The Ternary Operator
• 6.9 Nil Coalescing Operator
• 6.10 Bitwise Operators
• 6.11 Compound Bitwise Operators
• 6.12 Summary

7. Swift Control Flow

• 7.1 Looping Control Flow
• 7.2 The Swift for-in Statement
• 7.3 The repeat ... while loop
• 7.4 Breaking from Loops
• 7.5 The continue Statement
• 7.6 Conditional Control Flow
• 7.7 Using the if Statement
• 7.8 Using if ... else … Statements
• 7.9 Using if ... else if ... Statements
• 7.10 The guard Statement
• 7.11 Summary

8. The Swift Switch Statement

• 8.1 Why Use a switch Statement?
• 8.2 Using the switch Statement Syntax
• 8.3 A Swift switch Statement Example
• 8.4 Combining case Statements
• 8.5 Range Matching in a switch Statement
• 8.6 Using the where statement
• 8.7 Fallthrough
• 8.8 Summary

9. Swift Functions, Methods and Closures

• 9.1 What is a Function?
• 9.2 What is a Method?
• 9.3 How to Declare a Swift Function
• 9.4 Implicit Returns from Single Expressions
• 9.5 Calling a Swift Function
• 9.6 Handling Return Values
• 9.7 Local and External Parameter Names
• 9.8 Declaring Default Function Parameters
• 9.9 Returning Multiple Results from a Function
• 9.10 Variable Numbers of Function Parameters
• 9.11 Parameters as Variables
• 9.12 Working with In-Out Parameters
• 9.13 Functions as Parameters
• 9.14 Closure Expressions
• 9.15 Shorthand Argument Names
• 9.16 Closures in Swift
• 9.17 Summary

10. The Basics of Swift Object-Oriented Programming

• 10.1 What is an Instance?
• 10.2 What is a Class?
• 10.3 Declaring a Swift Class
• 10.4 Adding Instance Properties to a Class
• 10.5 Defining Methods
• 10.6 Declaring and Initializing a Class Instance
• 10.7 Initializing and De-initializing a Class Instance
• 10.8 Calling Methods and Accessing Properties
• 10.9 Stored and Computed Properties
• 10.10 Lazy Stored Properties
• 10.11 Using self in Swift
• 10.12 Understanding Swift Protocols
• 10.13 Opaque Return Types
• 10.14 Summary

11. An Introduction to Swift Subclassing and Extensions

• 11.1 Inheritance, Classes and Subclasses
• 11.2 A Swift Inheritance Example
• 11.3 Extending the Functionality of a Subclass
• 11.4 Overriding Inherited Methods
• 11.5 Initializing the Subclass
• 11.6 Using the SavingsAccount Class
• 11.7 Swift Class Extensions
• 11.8 Summary

12. An Introduction to Swift Structures and Enumerations

• 12.1 An Overview of Swift Structures
• 12.2 Value Types vs. Reference Types
• 12.3 When to Use Structures or Classes
• 12.4 An Overview of Enumerations
• 12.5 Summary

13. An Introduction to Swift Property Wrappers

• 13.1 Understanding Property Wrappers
• 13.2 A Simple Property Wrapper Example
• 13.3 Supporting Multiple Variables and Types
• 13.4 Summary

14. Working with Array and Dictionary Collections in Swift

• 14.1 Mutable and Immutable Collections
• 14.2 Swift Array Initialization
• 14.3 Working with Arrays in Swift
• 14.4 Random Items and Shuffling
• 14.5 Appending Items to an Array
• 14.6 Array Iteration
• 14.7 Creating Mixed Type Arrays
• 14.8 Swift Dictionary Collections
• 14.9 Swift Dictionary Initialization
• 14.10 Sequence-based Dictionary Initialization
• 14.11 Dictionary Item Count
• 14.12 Accessing and Updating Dictionary Items
• 14.13 Adding and Removing Dictionary Entries
• 14.14 Dictionary Iteration
• 14.15 Summary

15. Understanding Error Handling in Swift 5

• 15.1 Understanding Error Handling
• 15.2 Declaring Error Types
• 15.3 Throwing an Error
• 15.4 Calling Throwing Methods and Functions
• 15.5 Accessing the Error Object
• 15.6 Disabling Error Catching
• 15.7 Using the defer Statement
• 15.8 Summary

16. An Overview of SwiftUI

• 16.1 UIKit and Interface Builder
• 16.2 SwiftUI Declarative Syntax
• 16.3 SwiftUI is Data Driven
• 16.4 SwiftUI vs. UIKit
• 16.5 Summary

17. Using Xcode in SwiftUI Mode

• 17.1 Starting Xcode 12
• 17.2 Creating a SwiftUI Project
• 17.3 Xcode in SwiftUI Mode
• 17.4 The Preview Canvas
• 17.5 Preview Pinning
• 17.6 The Preview Toolbar
• 17.7 Modifying the Design
• 17.8 Editor Context Menu
• 17.9 Previewing on Multiple Device Configurations
• 17.10 Running the App on a Simulator
• 17.11 Running the App on a Physical iOS Device
• 17.12 Managing Devices and Simulators
• 17.13 Enabling Network Testing
• 17.14 Dealing with Build Errors
• 17.15 Monitoring Application Performance
• 17.16 Exploring the User Interface Layout Hierarchy
• 17.17 Summary

18. SwiftUI Architecture

• 18.1 SwiftUI App Hierarchy
• 18.2 App
• 18.3 Scenes
• 18.4 Views
• 18.5 Summary

19. The Anatomy of a Basic SwiftUI Project

• 19.1 Creating an Example Project
• 19.2 Project Folders
• 19.3 The DemoProjectApp.swift File
• 19.4 The ContentView.swift File
• 19.5 Assets.xcassets
• 19.6 Info.plist
• 19.7 Summary

20. Creating Custom Views with SwiftUI

• 20.1 SwiftUI Views
• 20.2 Creating a Basic View
• 20.3 Adding Additional Views
• 20.4 Working with Subviews
• 20.5 Views as Properties
• 20.6 Modifying Views
• 20.7 Working with Text Styles
• 20.8 Modifier Ordering
• 20.9 Custom Modifiers
• 20.10 Basic Event Handling
• 20.11 Building Custom Container Views
• 20.12 Working with the Label View
• 20.13 Summary

21. SwiftUI Stacks and Frames

• 21.1 SwiftUI Stacks
• 21.2 Spacers, Alignment and Padding
• 21.3 Container Child Limit
• 21.4 Text Line Limits and Layout Priority
• 21.5 Traditional vs. Lazy Stacks
• 21.6 SwiftUI Frames
• 21.7 Frames and the Geometry Reader
• 21.8 Summary

22. SwiftUI State Properties, Observable, State and Environment Objects

• 22.1 State Properties
• 22.2 State Binding
• 22.3 Observable Objects
• 22.4 State Objects
• 22.5 Environment Objects
• 22.6 Summary

23. A SwiftUI Example Tutorial

• 23.1 Creating the Example Project
• 23.2 Reviewing the Project
• 23.3 Adding a VStack to the Layout
• 23.4 Adding a Slider View to the Stack
• 23.5 Adding a State Property
• 23.6 Adding Modifiers to the Text View
• 23.7 Adding Rotation and Animation
• 23.8 Adding a TextField to the Stack
• 23.9 Adding a Color Picker
• 23.10 Tidying the Layout
• 23.11 Summary

24. SwiftUI Lifecycle Event Modifiers

• 24.1 Creating the LifecycleDemo Project
• 24.2 Designing the App
• 24.3 The onAppear and onDisappear Modifiers
• 24.4 The onChange Modifier
• 24.5 ScenePhase and the onChange Modifier
• 24.6 Summary

25. SwiftUI Observable and Environment Objects – A Tutorial

• 25.1 About the ObservableDemo Project
• 25.2 Creating the Project
• 25.3 Adding the Observable Object
• 25.4 Designing the ContentView Layout
• 25.5 Adding the Second View
• 25.6 Adding Navigation
• 25.7 Using an Environment Object
• 25.8 Summary

26. SwiftUI Data Persistence using AppStorage and SceneStorage

• 26.1 The @SceneStorage Property Wrapper
• 26.2 The @AppStorage Property Wrapper
• 26.3 Creating and Preparing the StorageDemo Project
• 26.4 Using Scene Storage
• 26.5 Using App Storage
• 26.6 Storing Custom Types
• 26.7 Summary

27. SwiftUI Stack Alignment and Alignment Guides

• 27.1 Container Alignment
• 27.2 Alignment Guides
• 27.3 Using the Alignment Guides Tool
• 27.4 Custom Alignment Types
• 27.5 Cross Stack Alignment
• 27.6 ZStack Custom Alignment
• 27.7 Summary

28. SwiftUI Lists and Navigation

• 28.1 SwiftUI Lists
• 28.2 SwiftUI Dynamic Lists
• 28.3 SwiftUI NavigationView and NavigationLink
• 28.4 Making the List Editable
• 28.5 Hierarchical Lists
• 28.6 Summary

29. A SwiftUI List and Navigation Tutorial

• 29.1 About the ListNavDemo Project
• 29.2 Creating the ListNavDemo Project
• 29.3 Preparing the Project
• 29.4 Adding the Car Structure
• 29.5 Loading the JSON Data
• 29.6 Adding the Data Store
• 29.7 Designing the Content View
• 29.8 Designing the Detail View
• 29.9 Adding Navigation to the List
• 29.10 Designing the Add Car View
• 29.11 Implementing Add and Edit Buttons
• 29.12 Adding the Edit Button Methods
• 29.13 Summary

30. An Overview of List, OutlineGroup and DisclosureGroup

• 30.1 Hierarchical Data and Disclosures
• 30.2 Hierarchies and Disclosure in SwiftUI Lists
• 30.3 Using OutlineGroup
• 30.4 Using DisclosureGroup
• 30.5 Summary

31. A SwiftUI List, OutlineGroup and DisclosureGroup Tutorial

• 31.1 About the Example Project
• 31.2 Creating the OutlineGroupDemo Project
• 31.3 Adding the Data Structure
• 31.4 Adding the List View
• 31.5 Testing the Project
• 31.6 Using the Sidebar List Style
• 31.7 Using OutlineGroup
• 31.8 Working with DisclosureGroups
• 31.9 Summary

32. Building SwiftUI Grids with LazyVGrid and LazyHGrid

• 32.1 SwiftUI Grids
• 32.2 GridItems
• 32.3 Creating the GridDemo Project
• 32.4 Working with Flexible GridItems
• 32.5 Adding Scrolling Support to a Grid
• 32.6 Working with Adaptive GridItems
• 32.7 Working with Fixed GridItems
• 32.8 Using the LazyHGrid View
• 32.9 Summary

33. Building Tabbed and Paged Views in SwiftUI

• 33.1 An Overview of SwiftUI TabView
• 33.2 Creating the TabViewDemo App
• 33.3 Adding the TabView Container
• 33.4 Adding the Content Views
• 33.5 Adding View Paging
• 33.6 Adding the Tab Items
• 33.7 Adding Tab Item Tags
• 33.8 Summary

34. Building Context Menus in SwiftUI

• 34.1 Creating the ContextMenuDemo Project
• 34.2 Preparing the Content View
• 34.3 Adding the Context Menu
• 34.4 Testing the Context Menu
• 34.5 Summary

35. Basic SwiftUI Graphics Drawing

• 35.1 Creating the DrawDemo Project
• 35.2 SwiftUI Shapes
• 35.3 Using Overlays
• 35.4 Drawing Custom Paths and Shapes
• 35.5 Drawing Gradients
• 35.6 Summary

36. SwiftUI Animation and Transitions

• 36.1 Creating the AnimationDemo Example Project
• 36.2 Implicit Animation
• 36.3 Repeating an Animation
• 36.4 Explicit Animation
• 36.5 Animation and State Bindings
• 36.6 Automatically Starting an Animation
• 36.7 SwiftUI Transitions
• 36.8 Combining Transitions
• 36.9 Asymmetrical Transitions
• 36.10 Summary

37. Working with Gesture Recognizers in SwiftUI

• 37.1 Creating the GestureDemo Example Project
• 37.2 Basic Gestures
• 37.3 The onChange Action Callback
• 37.4 The updating Callback Action
• 37.5 Composing Gestures
• 37.6 Summary

38. Creating a Customized SwiftUI ProgressView

• 38.1 ProgressView Styles
• 38.2 Creating the ProgressViewDemo Project
• 38.3 Adding a ProgressView
• 38.4 Using the Circular ProgressView Style
• 38.5 Declaring an Indeterminate ProgressView
• 38.6 ProgressView Customization
• 38.7 Summary

39. An Overview of SwiftUI DocumentGroup Scenes

• 39.1 Documents in Apps
• 39.2 Creating the DocDemo App
• 39.3 The DocumentGroup Scene
• 39.4 Declaring File Type Support
• 39.5 Configuring File Type Support in Xcode
• 39.6 The Document Structure
• 39.7 The Content View
• 39.8 Running the Example App
• 39.9 Summary

40. A SwiftUI DocumentGroup Tutorial

• 40.1 Creating the ImageDocDemo Project
• 40.2 Modifying the Info.plist File
• 40.3 Adding an Image Asset
• 40.4 Modifying the ImageDocDemoDocument.swift File
• 40.5 Designing the Content View
• 40.6 Filtering the Image
• 40.7 Testing the App
• 40.8 Summary

41. An Introduction to SiriKit

• 41.1 Siri and SiriKit
• 41.2 SiriKit Domains
• 41.3 Siri Shortcuts
• 41.4 SiriKit Intents
• 41.5 How SiriKit Integration Works
• 41.6 Resolving Intent Parameters
• 41.7 The Confirm Method
• 41.8 The Handle Method
• 41.9 Custom Vocabulary
• 41.10 The Siri User Interface
• 41.11 Summary

42. A SwiftUI SiriKit Messaging Extension Tutorial

• 42.1 Creating the Example Project
• 42.2 Enabling the Siri Entitlement
• 42.3 Seeking Siri Authorization
• 42.4 Adding the Intents Extension
• 42.5 Supported Intents
• 42.6 Trying the Example
• 42.7 Specifying a Default Phrase
• 42.8 Reviewing the Intent Handler
• 42.9 Summary

43. Customizing the SiriKit Intent User Interface

• 43.1 Adding the Intents UI Extension
• 43.2 Modifying the UI Extension
• 43.3 Using the configure Method
• 43.4 Using the configureView Method
• 43.5 Designing the Siri Snippet
• 43.6 Implementing a configureView Method
• 43.7 Testing the Extension
• 43.8 Summary

44. A SwiftUI SiriKit NSUserActivity Tutorial

• 44.1 About the SiriKit Photo Search Project
• 44.2 Creating the SiriPhoto Project
• 44.3 Enabling the Siri Entitlement
• 44.4 Seeking Siri Authorization
• 44.5 Adding an Image Asset
• 44.6 Adding the Intents Extension to the Project
• 44.7 Reviewing the Default Intents Extension
• 44.8 Modifying the Supported Intents
• 44.9 Modifying the IntentHandler Implementation
• 44.10 Implementing the Resolve Methods
• 44.11 Implementing the Confirmation Method
• 44.12 Handling the Intent
• 44.13 Testing the App
• 44.14 Adding a Data Class to SiriPhoto
• 44.15 Designing the Content View
• 44.16 Adding Supported Activity Types to SiriPhoto
• 44.17 Handling the NSUserActivity Object
• 44.18 Testing the Completed App
• 44.19 Summary

45. An Overview of Siri Shortcut App Integration

• 45.1 An Overview of Siri Shortcuts
• 45.2 An Introduction to the Intent Definition File
• 45.3 Automatically Generated Classes
• 45.4 Donating Shortcuts
• 45.5 The Add to Siri Button
• 45.6 Summary

46. A SwiftUI Siri Shortcut Tutorial

• 46.1 About the Example App
• 46.2 App Groups and UserDefaults
• 46.3 Preparing the Project
• 46.4 Running the App
• 46.5 Enabling Siri Support
• 46.6 Seeking Siri Authorization
• 46.7 Adding the Intents Extension
• 46.8 Adding the SiriKit Intent Definition File
• 46.9 Adding the Intent to the App Group
• 46.10 Configuring the SiriKit Intent Definition File
• 46.11 Adding Intent Parameters
• 46.12 Declaring Shortcut Combinations
• 46.13 Configuring the Intent Response
• 46.14 Configuring Target Membership
• 46.15 Modifying the Intent Handler Code
• 46.16 Adding the Confirm Method
• 46.17 Donating Shortcuts to Siri
• 46.18 Testing the Shortcuts
• 46.19 Designing the Intent UI
• 46.20 Summary

47. Building Widgets with SwiftUI and WidgetKit

• 47.1 An Overview of Widgets
• 47.2 The Widget Extension
• 47.3 Widget Configuration Types
• 47.4 Widget Entry View
• 47.5 Widget Timeline Entries
• 47.6 Widget Timeline
• 47.7 Widget Provider
• 47.8 Reload Policy
• 47.9 Relevance
• 47.10 Forcing a Timeline Reload
• 47.11 Widget Sizes
• 47.12 Widget Placeholder
• 47.13 Summary

48. A SwiftUI WidgetKit Tutorial

• 48.1 About the WidgetDemo Project
• 48.2 Creating the WidgetDemo Project
• 48.3 Building the App
• 48.4 Adding the Widget Extension
• 48.5 Adding the Widget Data
• 48.6 Creating Sample Timelines
• 48.7 Adding Image and Color Assets
• 48.8 Designing the Widget View
• 48.9 Modifying the Widget Provider
• 48.10 Configuring the Placeholder View
• 48.11 Previewing the Widget
• 48.12 Summary

49. Supporting WidgetKit Size Families

• 49.1 Supporting Multiple Size Families
• 49.2 Adding Size Support to the Widget View
• 49.3 Summary

50. A SwiftUI WidgetKit Deep Link Tutorial

• 50.1 Adding Deep Link Support to the Widget
• 50.2 Adding Deep Link Support to the App
• 50.3 Testing the Widget
• 50.4 Summary

51. Adding Configuration Options to a WidgetKit Widget

• 51.1 Modifying the Weather Data
• 51.2 Configuring the Intent Definition
• 51.3 Modifying the Widget
• 51.4 Testing Widget Configuration
• 51.5 Customizing the Configuration Intent UI
• 51.6 Summary

52. Integrating UIViews with SwiftUI

• 52.1 SwiftUI and UIKit Integration
• 52.2 Integrating UIViews into SwiftUI
• 52.3 Adding a Coordinator
• 52.4 Handling UIKit Delegation and Data Sources
• 52.5 An Example Project
• 52.6 Wrapping the UIScrolledView
• 52.7 Implementing the Coordinator
• 52.8 Using MyScrollView
• 52.9 Summary

53. Integrating UIViewControllers with SwiftUI

• 53.1 UIViewControllers and SwiftUI
• 53.2 Creating the ViewControllerDemo project
• 53.3 Wrapping the UIImagePickerController
• 53.4 Designing the Content View
• 53.5 Completing MyImagePicker
• 53.6 Completing the Content View
• 53.7 Testing the App
• 53.8 Summary

54. Integrating SwiftUI with UIKit

• 54.1 An Overview of the Hosting Controller
• 54.2 A UIHostingController Example Project
• 54.3 Adding the SwiftUI Content View
• 54.4 Preparing the Storyboard
• 54.5 Adding a Hosting Controller
• 54.6 Configuring the Segue Action
• 54.7 Embedding a Container View
• 54.8 Embedding SwiftUI in Code
• 54.9 Summary

55. Preparing and Submitting an iOS 14 Application to the App Store

• 55.1 Verifying the iOS Distribution Certificate
• 55.2 Adding App Icons
• 55.3 Assign the Project to a Team
• 55.4 Archiving the Application for Distribution
• 55.5 Configuring the Application in App Store Connect
• 55.6 Validating and Submitting the Application
• 55.7 Configuring and Submitting the App for Review

Index