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

✍ Scribed by Neil Smyth

• Publisher: Payload Media
• Year: 2022
• Tongue: English
• Leaves: 526
• Edition: 1
• Category: Library

✦ Synopsis

The goal of this book is to teach the skills necessary to build iOS 15 applications using SwiftUI, Xcode 13 and the Swift 5.5 programming language.

Beginning with the basics, this book provides an outline of the steps necessary to set up an iOS development environment together with an introduction to the use of Swift Playgrounds to learn and experiment with Swift.

The book also includes in-depth chapters introducing the Swift 5.5 programming language including data types, control flow, functions, object-oriented programming, property wrappers, structured concurrency, and error handling.

An introduction to the key concepts of SwiftUI and project architecture is followed by a guided tour of Xcode in SwiftUI development mode. The book also covers the creation of custom SwiftUI views and explains how these views are combined to create user interface layouts including the use of stacks, frames and forms.

Other topics covered include data handling using state properties in addition to observable, state and environment objects, as are key user interface design concepts such as modifiers, lists, tabbed views, context menus, user interface navigation, and outline groups.

The book also includes chapters covering graphics drawing, user interface animation, view transitions and gesture handling, WidgetKit, document-based apps, Core Data, CloudKit, and SiriKit integration.

Chapters are also provided explaining how to integrate SwiftUI views into existing UIKit-based projects and explains the integration of UIKit code into SwiftUI.

Finally, the book explains how to package up a completed app and upload it to the App Store for publication.

Along the way, the topics covered in the book are put into practice through detailed tutorials, the source code for which is also available for download.

The aim of this book, therefore, is to teach you the skills necessary to build your own apps for iOS 15 using SwiftUI. Assuming you are ready to download the iOS 15 SDK and Xcode 13 and have an Apple Mac system you are ready to get started.

✦ Table of Contents

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

✦ Subjects

iOS; iOS 15; Swift; SwiftUI; Xcode