SwiftUI Essentials – iOS 15 Edition: Learn to Develop iOS Apps Using SwiftUI, Swift 5.5 and Xcode 13
by Neil Smyth
- Length: 526 pages
- Edition: 1
- Language: English
- Publisher: Payload Media
- Publication Date: 2022-04-24
- ISBN-10: 1951442431
- ISBN-13: 9781951442439
- Sales Rank: #568868 (See Top 100 Books)
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.
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 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 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
Donate to keep this site alive
To access the Link, solve the captcha.
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.
