SwiftUI Essentials - iOS 15 Edition: Learn to Develop iOS Apps Using SwiftUI, Swift 5.5 and Xcode 13

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
2.1 Downloading Xcode 13 and the iOS 15 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 13 and the iOS 15 SDK
3.1 Identifying Your macOS Version
3.2 Installing Xcode 13 and the iOS 15 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 13 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.2.1 Integer Data Types
5.2.2 Floating Point Data Types
5.2.3 Bool Data Type
5.2.4 Character Data Type
5.2.5 String Data Type
5.2.6 Special Characters/Escape Sequences
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.10.1 Bitwise NOT
6.10.2 Bitwise AND
6.10.3 Bitwise OR
6.10.4 Bitwise XOR
6.10.5 Bitwise Left Shift
6.10.6 Bitwise Right Shift
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.2.1 The while Loop
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.3.1 Array Item Count
14.3.2 Accessing Array Items
14.3.3 Random Items and Shuffling
14.3.4 Appending Items to an Array
14.3.5 Inserting and Deleting Array Items
14.3.6 Array Iteration
14.4 Creating Mixed Type Arrays
14.5 Swift Dictionary Collections
14.6 Swift Dictionary Initialization
14.7 Sequence-based Dictionary Initialization
14.8 Dictionary Item Count
14.9 Accessing and Updating Dictionary Items
14.10 Adding and Removing Dictionary Entries
14.11 Dictionary Iteration
14.12 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 13
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 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. An Overview of Swift Structured Concurrency
24.1 An Overview of Threads
24.2 The Application Main Thread
24.3 Completion Handlers
24.4 Structured Concurrency
24.5 Preparing the Project
24.6 Non-Concurrent Code
24.7 Introducing async/await Concurrency
24.8 Asynchronous Calls from Synchronous Functions
24.9 The await Keyword
24.10 Using async-let Bindings
24.11 Handling Errors
24.12 Understanding Tasks
24.13 Unstructured Concurrency
24.14 Detached Tasks
24.15 Task Management
24.16 Working with Task Groups
24.17 Avoiding Data Races
24.18 The for-await Loop
24.19 Asynchronous Properties
24.20 Summary
25. An Introduction to Swift Actors
25.1 An Overview of Actors
25.2 Declaring an Actor
25.3 Understanding Data Isolation
25.4 A Swift Actor Example
25.5 Introducing the MainActor
25.6 Summary
26. SwiftUI Concurrency and Lifecycle Event Modifiers
26.1 Creating the LifecycleDemo Project
26.2 Designing the App
26.3 The onAppear and onDisappear Modifiers
26.4 The onChange Modifier
26.5 ScenePhase and the onChange Modifier
26.6 Launching Concurrent Tasks
26.7 Summary
27. SwiftUI Observable and Environment Objects – A Tutorial
27.1 About the ObservableDemo Project
27.2 Creating the Project
27.3 Adding the Observable Object
27.4 Designing the ContentView Layout
27.5 Adding the Second View
27.6 Adding Navigation
27.7 Using an Environment Object
27.8 Summary
28. SwiftUI Data Persistence using AppStorage and SceneStorage
28.1 The @SceneStorage Property Wrapper
28.2 The @AppStorage Property Wrapper
28.3 Creating and Preparing the StorageDemo Project
28.4 Using Scene Storage
28.5 Using App Storage
28.6 Storing Custom Types
28.7 Summary
29. SwiftUI Stack Alignment and Alignment Guides
29.1 Container Alignment
29.2 Alignment Guides
29.3 Using the Alignment Guides Tool
29.4 Custom Alignment Types
29.5 Cross Stack Alignment
29.6 ZStack Custom Alignment
29.7 Summary
30. SwiftUI Lists and Navigation
30.1 SwiftUI Lists
30.2 Modifying List Separators and Rows
30.3 SwiftUI Dynamic Lists
30.4 Creating a Refreshable List
30.5 SwiftUI NavigationView and NavigationLink
30.6 Making the List Editable
30.7 Hierarchical Lists
30.8 Summary
31. A SwiftUI List and Navigation Tutorial
31.1 About the ListNavDemo Project
31.2 Creating the ListNavDemo Project
31.3 Preparing the Project
31.4 Adding the Car Structure
31.5 Loading the JSON Data
31.6 Adding the Data Store
31.7 Designing the Content View
31.8 Designing the Detail View
31.9 Adding Navigation to the List
31.10 Designing the Add Car View
31.11 Implementing Add and Edit Buttons
31.12 Adding the Edit Button Methods
31.13 Summary
32. An Overview of List, OutlineGroup and DisclosureGroup
32.1 Hierarchical Data and Disclosures
32.2 Hierarchies and Disclosure in SwiftUI Lists
32.3 Using OutlineGroup
32.4 Using DisclosureGroup
32.5 Summary
33. A SwiftUI List, OutlineGroup and DisclosureGroup Tutorial
33.1 About the Example Project
33.2 Creating the OutlineGroupDemo Project
33.3 Adding the Data Structure
33.4 Adding the List View
33.5 Testing the Project
33.6 Using the Sidebar List Style
33.7 Using OutlineGroup
33.8 Working with DisclosureGroups
33.9 Summary
34. Building SwiftUI Grids with LazyVGrid and LazyHGrid
34.1 SwiftUI Grids
34.2 GridItems
34.3 Creating the GridDemo Project
34.4 Working with Flexible GridItems
34.5 Adding Scrolling Support to a Grid
34.6 Working with Adaptive GridItems
34.7 Working with Fixed GridItems
34.8 Using the LazyHGrid View
34.9 Summary
35. Building Tabbed and Paged Views in SwiftUI
35.1 An Overview of SwiftUI TabView
35.2 Creating the TabViewDemo App
35.3 Adding the TabView Container
35.4 Adding the Content Views
35.5 Adding View Paging
35.6 Adding the Tab Items
35.7 Adding Tab Item Tags
35.8 Summary
36. Building Context Menus in SwiftUI
36.1 Creating the ContextMenuDemo Project
36.2 Preparing the Content View
36.3 Adding the Context Menu
36.4 Testing the Context Menu
36.5 Summary
37. Basic SwiftUI Graphics Drawing
37.1 Creating the DrawDemo Project
37.2 SwiftUI Shapes
37.3 Using Overlays
37.4 Drawing Custom Paths and Shapes
37.5 Drawing Gradients
37.6 Summary
38. SwiftUI Animation and Transitions
38.1 Creating the AnimationDemo Example Project
38.2 Implicit Animation
38.3 Repeating an Animation
38.4 Explicit Animation
38.5 Animation and State Bindings
38.6 Automatically Starting an Animation
38.7 SwiftUI Transitions
38.8 Combining Transitions
38.9 Asymmetrical Transitions
38.10 Summary
39. Working with Gesture Recognizers in SwiftUI
39.1 Creating the GestureDemo Example Project
39.2 Basic Gestures
39.3 The onChange Action Callback
39.4 The updating Callback Action
39.5 Composing Gestures
39.6 Summary
40. Creating a Customized SwiftUI ProgressView
40.1 ProgressView Styles
40.2 Creating the ProgressViewDemo Project
40.3 Adding a ProgressView
40.4 Using the Circular ProgressView Style
40.5 Declaring an Indeterminate ProgressView
40.6 ProgressView Customization
40.7 Summary
41. An Overview of SwiftUI DocumentGroup Scenes
41.1 Documents in Apps
41.2 Creating the DocDemo App
41.3 The DocumentGroup Scene
41.4 Declaring File Type Support
41.4.1 Document Content Type Identifier
41.4.2 Handler Rank
41.4.3 Type Identifiers
41.4.4 Filename Extensions
41.4.5 Custom Type Document Content Identifiers
41.4.6 Exported vs. Imported Type Identifiers
41.5 Configuring File Type Support in Xcode
41.6 The Document Structure
41.7 The Content View
41.8 Running the Example App
41.9 Summary
42. A SwiftUI DocumentGroup Tutorial
42.1 Creating the ImageDocDemo Project
42.2 Modifying the Info.plist File
42.3 Adding an Image Asset
42.4 Modifying the ImageDocDemoDocument.swift File
42.5 Designing the Content View
42.6 Filtering the Image
42.7 Testing the App
42.8 Summary
43. An Introduction to Core Data and SwiftUI
43.1 The Core Data Stack
43.2 Persistent Container
43.3 Managed Objects
43.4 Managed Object Context
43.5 Managed Object Model
43.6 Persistent Store Coordinator
43.7 Persistent Object Store
43.8 Defining an Entity Description
43.9 Initializing the Persistent Container
43.10 Obtaining the Managed Object Context
43.11 Setting the Attributes of a Managed Object
43.12 Saving a Managed Object
43.13 Fetching Managed Objects
43.14 Retrieving Managed Objects based on Criteria
43.15 Summary
44. A SwiftUI Core Data Tutorial
44.1 Creating the CoreDataDemo Project
44.2 Defining the Entity Description
44.3 Creating the Persistence Controller
44.4 Setting up the View Context
44.5 Preparing the ContentView for Core Data
44.6 Designing the User Interface
44.7 Saving Products
44.8 Testing the addProduct() Function
44.9 Deleting Products
44.10 Adding the Search Function
44.11 Testing the Completed App
44.12 Summary
45. An Overview of SwiftUI Core Data and CloudKit Storage
45.1 An Overview of CloudKit
45.2 CloudKit Containers
45.3 CloudKit Public Database
45.4 CloudKit Private Databases
45.5 Data Storage Quotas
45.6 CloudKit Records
45.7 CloudKit Record IDs
45.8 CloudKit References
45.9 Record Zones
45.10 CloudKit Console
45.11 CloudKit Sharing
45.12 CloudKit Subscriptions
45.13 Summary
46. A SwiftUI Core Data and CloudKit Tutorial
46.1 Enabling CloudKit Support
46.2 Enabling Background Notifications Support
46.3 Switching to the CloudKit Persistent Container
46.4 Testing the App
46.5 Reviewing the Saved Data in the CloudKit Console
46.6 Fixing the recordName Problem
46.7 Filtering and Sorting Queries
46.8 Editing and Deleting Records
46.9 Adding New Records
46.10 Viewing Telemetry Data
46.11 Summary
47. An Introduction to SiriKit
47.1 Siri and SiriKit
47.2 SiriKit Domains
47.3 Siri Shortcuts
47.4 SiriKit Intents
47.5 How SiriKit Integration Works
47.6 Resolving Intent Parameters
47.7 The Confirm Method
47.8 The Handle Method
47.9 Custom Vocabulary
47.10 The Siri User Interface
47.11 Summary
48. A SwiftUI SiriKit Messaging Extension Tutorial
48.1 Creating the Example Project
48.2 Enabling the Siri Entitlement
48.3 Seeking Siri Authorization
48.4 Adding the Intents Extension
48.5 Supported Intents
48.6 Trying the Example
48.7 Specifying a Default Phrase
48.8 Reviewing the Intent Handler
48.9 Summary
49. An Overview of Siri Shortcut App Integration
49.1 An Overview of Siri Shortcuts
49.2 An Introduction to the Intent Definition File
49.3 Automatically Generated Classes
49.4 Donating Shortcuts
49.5 The Add to Siri Button
49.6 Summary
50. A SwiftUI Siri Shortcut Tutorial
50.1 About the Example App
50.2 App Groups and UserDefaults
50.3 Preparing the Project
50.4 Running the App
50.5 Enabling Siri Support
50.6 Seeking Siri Authorization
50.7 Adding the Intents Extension
50.8 Adding the SiriKit Intent Definition File
50.9 Adding the Intent to the App Group
50.10 Configuring the SiriKit Intent Definition File
50.11 Adding Intent Parameters
50.12 Declaring Shortcut Combinations
50.13 Configuring the Intent Response
50.14 Configuring Target Membership
50.15 Modifying the Intent Handler Code
50.16 Adding the Confirm Method
50.17 Donating Shortcuts to Siri
50.18 Testing the Shortcuts
50.19 Summary
51. Building Widgets with SwiftUI and WidgetKit
51.1 An Overview of Widgets
51.2 The Widget Extension
51.3 Widget Configuration Types
51.4 Widget Entry View
51.5 Widget Timeline Entries
51.6 Widget Timeline
51.7 Widget Provider
51.8 Reload Policy
51.9 Relevance
51.10 Forcing a Timeline Reload
51.11 Widget Sizes
51.12 Widget Placeholder
51.13 Summary
52. A SwiftUI WidgetKit Tutorial
52.1 About the WidgetDemo Project
52.2 Creating the WidgetDemo Project
52.3 Building the App
52.4 Adding the Widget Extension
52.5 Adding the Widget Data
52.6 Creating Sample Timelines
52.7 Adding Image and Color Assets
52.8 Designing the Widget View
52.9 Modifying the Widget Provider
52.10 Configuring the Placeholder View
52.11 Previewing the Widget
52.12 Summary
53. Supporting WidgetKit Size Families
53.1 Supporting Multiple Size Families
53.2 Adding Size Support to the Widget View
53.3 Summary
54. A SwiftUI WidgetKit Deep Link Tutorial
54.1 Adding Deep Link Support to the Widget
54.2 Adding Deep Link Support to the App
54.3 Testing the Widget
54.4 Summary
55. Adding Configuration Options to a WidgetKit Widget
55.1 Modifying the Weather Data
55.2 Configuring the Intent Definition
55.3 Modifying the Widget
55.4 Testing Widget Configuration
55.5 Customizing the Configuration Intent UI
55.6 Summary
56. Integrating UIViews with SwiftUI
56.1 SwiftUI and UIKit Integration
56.2 Integrating UIViews into SwiftUI
56.3 Adding a Coordinator
56.4 Handling UIKit Delegation and Data Sources
56.5 An Example Project
56.6 Wrapping the UIScrolledView
56.7 Implementing the Coordinator
56.8 Using MyScrollView
56.9 Summary
57. Integrating UIViewControllers with SwiftUI
57.1 UIViewControllers and SwiftUI
57.2 Creating the ViewControllerDemo project
57.3 Wrapping the UIImagePickerController
57.4 Designing the Content View
57.5 Completing MyImagePicker
57.6 Completing the Content View
57.7 Testing the App
57.8 Summary
58. Integrating SwiftUI with UIKit
58.1 An Overview of the Hosting Controller
58.2 A UIHostingController Example Project
58.3 Adding the SwiftUI Content View
58.4 Preparing the Storyboard
58.5 Adding a Hosting Controller
58.6 Configuring the Segue Action
58.7 Embedding a Container View
58.8 Embedding SwiftUI in Code
58.9 Summary
59. Preparing and Submitting an iOS 15 Application to the App Store
59.1 Verifying the iOS Distribution Certificate
59.2 Adding App Icons
59.3 Assign the Project to a Team
59.4 Archiving the Application for Distribution
59.5 Configuring the Application in App Store Connect
59.6 Validating and Submitting the Application
59.7 Configuring and Submitting the App for Review
Index