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

✍ Scribed by Neil Smyth

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

✦ Synopsis

This book will teach you the skills necessary to build iOS 16 applications using SwiftUI, Xcode 14, and the Swift 5.7 programming language.

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

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

A guided tour of Xcode in SwiftUI development mode follows an introduction to the key concepts of SwiftUI and project architecture. The book also covers creating custom SwiftUI views and explains how these views are combined to create user interface layouts, including stacks, frames, and forms.

Other topics covered include data handling using state properties and 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 also explain how to integrate SwiftUI views into existing UIKit-based projects and integrate 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 16 using SwiftUI. Assuming you are ready to download the iOS 16 SDK and Xcode 14 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 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

✦ Subjects

SwiftUI; Swift Programming; iOS Apps Development; Xcode; iOS