SwiftUI Essentials - iOS 16 Edition: Learn to Develop iOS Apps Using SwiftUI, Swift, and Xcode 14

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 14 and the iOS 16 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 14 and the iOS 16 SDK
3.1 Identifying Your macOS Version
3.2 Installing Xcode 14 and the iOS 16 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 14 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 14
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 The DemoProjectApp.swift File
19.3 The ContentView.swift File
19.4 Assets.xcassets
19.5 DemoProject.entitlements
19.6 Preview Content
19.7 Summary
20. Creating Custom Views with SwiftUI
20.1 SwiftUI Views
20.2 Creating a Basic View
20.3 Adding 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 Dynamic HStack and VStack Conversion
21.5 Text Line Limits and Layout Priority
21.6 Traditional vs. Lazy Stacks
21.7 SwiftUI Frames
21.8 Frames and the Geometry Reader
21.9 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 Modifying 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 NavigationStack and NavigationLink
30.6 Navigation by Value Type
30.7 Working with Navigation Paths
30.8 Navigation Bar Customization
30.9 Making the List Editable
30.10 Hierarchical Lists
30.11 Multicolumn Navigation
30.12 Summary
31. A SwiftUI List and NavigationStack 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 a Navigation Path
31.13 Adding the Edit Button Methods
31.14 Summary
32. An Overview of Split View Navigation
32.1 Introducing NavigationSplitView
32.2 Using NavigationSplitView
32.3 Handling List Selection
32.4 NavigationSplitView Configuration
32.5 Controlling Column Visibility
32.6 Summary
33. A NavigationSplitView Tutorial
33.1 About the Project
33.2 Creating the NavSplitDemo Project
33.3 Adding the Project Data
33.4 Creating the Navigation View
33.5 Building the Sidebar Column
33.6 Adding the Content Column List
33.7 Adding the Detail Column
33.8 Configuring the Split Navigation Experience
33.9 Summary
34. An Overview of List, OutlineGroup and DisclosureGroup
34.1 Hierarchical Data and Disclosures
34.2 Hierarchies and Disclosure in SwiftUI Lists
34.3 Using OutlineGroup
34.4 Using DisclosureGroup
34.5 Summary
35. A SwiftUI List, OutlineGroup, and DisclosureGroup Tutorial
35.1 About the Example Project
35.2 Creating the OutlineGroupDemo Project
35.3 Adding the Data Structure
35.4 Adding the List View
35.5 Testing the Project
35.6 Using the Sidebar List Style
35.7 Using OutlineGroup
35.8 Working with DisclosureGroups
35.9 Summary
36. Building SwiftUI Grids with LazyVGrid and LazyHGrid
36.1 SwiftUI Grids
36.2 GridItems
36.3 Creating the GridDemo Project
36.4 Working with Flexible GridItems
36.5 Adding Scrolling Support to a Grid
36.6 Working with Adaptive GridItems
36.7 Working with Fixed GridItems
36.8 Using the LazyHGrid View
36.9 Summary
37. Building SwiftUI Grids with Grid and GridRow
37.1 Grid and GridRow Views
37.2 Creating the GridRowDemo Project
37.3 A Simple Grid Layout
37.4 Non-GridRow Children
37.5 Automatic Empty Grid Cells
37.6 Adding Empty Cells
37.7 Column Spanning
37.8 Grid Alignment and Spacing
37.9 Summary
38. Building Tabbed and Paged Views in SwiftUI
38.1 An Overview of SwiftUI TabView
38.2 Creating the TabViewDemo App
38.3 Adding the TabView Container
38.4 Adding the Content Views
38.5 Adding View Paging
38.6 Adding the Tab Items
38.7 Adding Tab Item Tags
38.8 Summary
39. Building Context Menus in SwiftUI
39.1 Creating the ContextMenuDemo Project
39.2 Preparing the Content View
39.3 Adding the Context Menu
39.4 Testing the Context Menu
39.5 Summary
40. Basic SwiftUI Graphics Drawing
40.1 Creating the DrawDemo Project
40.2 SwiftUI Shapes
40.3 Using Overlays
40.4 Drawing Custom Paths and Shapes
40.5 Color Gradients and Shadows
40.6 Drawing Gradients
40.7 Summary
41. SwiftUI Animation and Transitions
41.1 Creating the AnimationDemo Example Project
41.2 Implicit Animation
41.3 Repeating an Animation
41.4 Explicit Animation
41.5 Animation and State Bindings
41.6 Automatically Starting an Animation
41.7 SwiftUI Transitions
41.8 Combining Transitions
41.9 Asymmetrical Transitions
41.10 Summary
42. Working with Gesture Recognizers in SwiftUI
42.1 Creating the GestureDemo Example Project
42.2 Basic Gestures
42.3 The onChange Action Callback
42.4 The updating Callback Action
42.5 Composing Gestures
42.6 Summary
43. Creating a Customized SwiftUI ProgressView
43.1 ProgressView Styles
43.2 Creating the ProgressViewDemo Project
43.3 Adding a ProgressView
43.4 Using the Circular ProgressView Style
43.5 Declaring an Indeterminate ProgressView
43.6 ProgressView Customization
43.7 Summary
44. Presenting Data with SwiftUI Charts
44.1 Introducing SwiftUI Charts
44.2 Passing Data to the Chart
44.3 Combining Mark Types
44.4 Filtering Data into Multiple Graphs
44.5 Changing the Chart Background
44.6 Changing the Interpolation Method
44.7 Summary
45. A SwiftUI Charts Tutorial
45.1 Creating the ChartDemo Project
45.2 Adding the Project Data
45.3 Adding the Chart View
45.4 Creating Multiple Graphs
45.5 Summary
46. An Overview of SwiftUI DocumentGroup Scenes
46.1 Documents in Apps
46.2 Creating the DocDemo App
46.3 The DocumentGroup Scene
46.4 Declaring File Type Support
46.4.1 Document Content Type Identifier
46.4.2 Handler Rank
46.4.3 Type Identifiers
46.4.4 Filename Extensions
46.4.5 Custom Type Document Content Identifiers
46.4.6 Exported vs. Imported Type Identifiers
46.5 Configuring File Type Support in Xcode
46.6 The Document Structure
46.7 The Content View
46.8 Running the Example App
46.9 Summary
47. A SwiftUI DocumentGroup Tutorial
47.1 Creating the ImageDocDemo Project
47.2 Modifying the Info.plist File
47.3 Adding an Image Asset
47.4 Modifying the ImageDocDemoDocument.swift File
47.5 Designing the Content View
47.6 Filtering the Image
47.7 Testing the App
47.8 Summary
48. An Introduction to Core Data and SwiftUI
48.1 The Core Data Stack
48.2 Persistent Container
48.3 Managed Objects
48.4 Managed Object Context
48.5 Managed Object Model
48.6 Persistent Store Coordinator
48.7 Persistent Object Store
48.8 Defining an Entity Description
48.9 Initializing the Persistent Container
48.10 Obtaining the Managed Object Context
48.11 Setting the Attributes of a Managed Object
48.12 Saving a Managed Object
48.13 Fetching Managed Objects
48.14 Retrieving Managed Objects based on Criteria
48.15 Summary
49. A SwiftUI Core Data Tutorial
49.1 Creating the CoreDataDemo Project
49.2 Defining the Entity Description
49.3 Creating the Persistence Controller
49.4 Setting up the View Context
49.5 Preparing the ContentView for Core Data
49.6 Designing the User Interface
49.7 Saving Products
49.8 Testing the addProduct() Function
49.9 Deleting Products
49.10 Adding the Search Function
49.11 Testing the Completed App
49.12 Summary
50. An Overview of SwiftUI Core Data and CloudKit Storage
50.1 An Overview of CloudKit
50.2 CloudKit Containers
50.3 CloudKit Public Database
50.4 CloudKit Private Databases
50.5 Data Storage Quotas
50.6 CloudKit Records
50.7 CloudKit Record IDs
50.8 CloudKit References
50.9 Record Zones
50.10 CloudKit Console
50.11 CloudKit Sharing
50.12 CloudKit Subscriptions
50.13 Summary
51. A SwiftUI Core Data and CloudKit Tutorial
51.1 Enabling CloudKit Support
51.2 Enabling Background Notifications Support
51.3 Switching to the CloudKit Persistent Container
51.4 Testing the App
51.5 Reviewing the Saved Data in the CloudKit Console
51.6 Fixing the recordName Problem
51.7 Filtering and Sorting Queries
51.8 Editing and Deleting Records
51.9 Adding New Records
51.10 Viewing Telemetry Data
51.11 Summary
52. An Introduction to SiriKit
52.1 Siri and SiriKit
52.2 SiriKit Domains
52.3 Siri Shortcuts
52.4 SiriKit Intents
52.5 How SiriKit Integration Works
52.6 Resolving Intent Parameters
52.7 The Confirm Method
52.8 The Handle Method
52.9 Custom Vocabulary
52.10 The Siri User Interface
52.11 Summary
53. A SwiftUI SiriKit Messaging Extension Tutorial
53.1 Creating the Example Project
53.2 Enabling the Siri Entitlement
53.3 Seeking Siri Authorization
53.4 Adding the Intents Extension
53.5 Supported Intents
53.6 Trying the Example
53.7 Specifying a Default Phrase
53.8 Reviewing the Intent Handler
53.9 Summary
54. An Overview of Siri Shortcut App Integration
54.1 An Overview of Siri Shortcuts
54.2 An Introduction to the Intent Definition File
54.3 Automatically Generated Classes
54.4 Donating Shortcuts
54.5 The Add to Siri Button
54.6 Summary
55. A SwiftUI Siri Shortcut Tutorial
55.1 About the Example App
55.2 App Groups and UserDefaults
55.3 Preparing the Project
55.4 Running the App
55.5 Enabling Siri Support
55.6 Seeking Siri Authorization
55.7 Adding the Intents Extension
55.8 Adding the SiriKit Intent Definition File
55.9 Adding the Intent to the App Group
55.10 Configuring the SiriKit Intent Definition File
55.11 Adding Intent Parameters
55.12 Declaring Shortcut Combinations
55.13 Configuring the Intent Response
55.14 Configuring Target Membership
55.15 Modifying the Intent Handler Code
55.16 Adding the Confirm Method
55.17 Donating Shortcuts to Siri
55.18 Testing the Shortcuts
55.19 Summary
56. Building Widgets with SwiftUI and WidgetKit
56.1 An Overview of Widgets
56.2 The Widget Extension
56.3 Widget Configuration Types
56.4 Widget Entry View
56.5 Widget Timeline Entries
56.6 Widget Timeline
56.7 Widget Provider
56.8 Reload Policy
56.9 Relevance
56.10 Forcing a Timeline Reload
56.11 Widget Sizes
56.12 Widget Placeholder
56.13 Summary
57. A SwiftUI WidgetKit Tutorial
57.1 About the WidgetDemo Project
57.2 Creating the WidgetDemo Project
57.3 Building the App
57.4 Adding the Widget Extension
57.5 Adding the Widget Data
57.6 Creating Sample Timelines
57.7 Adding Image and Color Assets
57.8 Designing the Widget View
57.9 Modifying the Widget Provider
57.10 Configuring the Placeholder View
57.11 Previewing the Widget
57.12 Summary
58. Supporting WidgetKit Size Families
58.1 Supporting Multiple Size Families
58.2 Adding Size Support to the Widget View
58.3 Summary
59. A SwiftUI WidgetKit Deep Link Tutorial
59.1 Adding Deep Link Support to the Widget
59.2 Adding Deep Link Support to the App
59.3 Testing the Widget
59.4 Summary
60. Adding Configuration Options to a WidgetKit Widget
60.1 Modifying the Weather Data
60.2 Configuring the Intent Definition
60.3 Modifying the Widget
60.4 Testing Widget Configuration
60.5 Customizing the Configuration Intent UI
60.6 Summary
61. Integrating UIViews with SwiftUI
61.1 SwiftUI and UIKit Integration
61.2 Integrating UIViews into SwiftUI
61.3 Adding a Coordinator
61.4 Handling UIKit Delegation and Data Sources
61.5 An Example Project
61.6 Wrapping the UIScrolledView
61.7 Implementing the Coordinator
61.8 Using MyScrollView
61.9 Summary
62. Integrating UIViewControllers with SwiftUI
62.1 UIViewControllers and SwiftUI
62.2 Creating the ViewControllerDemo project
62.3 Wrapping the UIImagePickerController
62.4 Designing the Content View
62.5 Completing MyImagePicker
62.6 Completing the Content View
62.7 Testing the App
62.8 Summary
63. Integrating SwiftUI with UIKit
63.1 An Overview of the Hosting Controller
63.2 A UIHostingController Example Project
63.3 Adding the SwiftUI Content View
63.4 Preparing the Storyboard
63.5 Adding a Hosting Controller
63.6 Configuring the Segue Action
63.7 Embedding a Container View
63.8 Embedding SwiftUI in Code
63.9 Summary
64. Preparing and Submitting an iOS 16 Application to the App Store
64.1 Verifying the iOS Distribution Certificate
64.2 Adding App Icons
64.3 Assign the Project to a Team
64.4 Archiving the Application for Distribution
64.5 Configuring the Application in App Store Connect
64.6 Validating and Submitting the Application
64.7 Configuring and Submitting the App for Review
Index
Blank Page