book

SwiftUI Essentials – iOS 14 Edition

Name: SwiftUI Essentials – iOS 14 Edition
Author: Neil Smyth
ISBN: 9781801813228

by Neil Smyth

May 2021

Intermediate to advanced

494 pages

12h 56m

English

Packt Publishing

Read now

Unlock full access

1. Start Here
1.1 For Swift Programmers1.2 For Non-Swift Programmers1.3 Source Code Download1.4 Feedback1.5 Errata
2. Joining the Apple Developer Program
2.1 Downloading Xcode 12 and the iOS 14 SDK2.2 Apple Developer Program2.3 When to Enroll in the Apple Developer Program?2.4 Enrolling in the Apple Developer Program2.5 Summary
3. Installing Xcode 12 and the iOS 14 SDK
3.1 Identifying Your macOS Version3.2 Installing Xcode 12 and the iOS 14 SDK3.3 Starting Xcode3.4 Adding Your Apple ID to the Xcode Preferences3.5 Developer and Distribution Signing Identities3.6 Summary
4. An Introduction to Xcode 12 Playgrounds
4.1 What is a Playground?4.2 Creating a New Playground4.3 A Swift Playground Example4.4 Viewing Results4.5 Adding Rich Text Comments4.6 Working with Playground Pages4.7 Working with SwiftUI and Live View in Playgrounds4.8 Summary
5. Swift Data Types, Constants and Variables
5.1 Using a Swift Playground5.2 Swift Data Types5.2.1 Integer Data Types5.2.2 Floating Point Data Types5.2.3 Bool Data Type5.2.4 Character Data Type5.2.5 String Data Type5.2.6 Special Characters/Escape Sequences5.3 Swift Variables5.4 Swift Constants5.5 Declaring Constants and Variables5.6 Type Annotations and Type Inference5.7 The Swift Tuple5.8 The Swift Optional Type5.9 Type Casting and Type Checking5.10 Summary
6. Swift Operators and Expressions
6.1 Expression Syntax in Swift6.2 The Basic Assignment Operator6.3 Swift Arithmetic Operators6.4 Compound Assignment Operators6.5 Comparison Operators6.6 Boolean Logical Operators6.7 Range Operators6.8 The Ternary Operator6.9 Nil Coalescing Operator6.10 Bitwise Operators6.10.1 Bitwise NOT6.10.2 Bitwise AND6.10.3 Bitwise OR6.10.4 Bitwise XOR6.10.5 Bitwise Left Shift6.10.6 Bitwise Right Shift6.11 Compound Bitwise Operators6.12 Summary
7. Swift Control Flow
7.1 Looping Control Flow7.2 The Swift for-in Statement7.2.1 The while Loop 7.3 The repeat ... while loop 7.4 Breaking from Loops7.5 The continue Statement 7.6 Conditional Control Flow7.7 Using the if Statement 7.8 Using if ... else … Statements 7.9 Using if ... else if ... Statements 7.10 The guard Statement7.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 Statement8.6 Using the where statement8.7 Fallthrough8.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 Function9.4 Implicit Returns from Single Expressions9.5 Calling a Swift Function9.6 Handling Return Values9.7 Local and External Parameter Names9.8 Declaring Default Function Parameters9.9 Returning Multiple Results from a Function9.10 Variable Numbers of Function Parameters 9.11 Parameters as Variables9.12 Working with In-Out Parameters9.13 Functions as Parameters9.14 Closure Expressions9.15 Shorthand Argument Names9.16 Closures in Swift9.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 Class10.4 Adding Instance Properties to a Class10.5 Defining Methods10.6 Declaring and Initializing a Class Instance10.7 Initializing and De-initializing a Class Instance10.8 Calling Methods and Accessing Properties10.9 Stored and Computed Properties10.10 Lazy Stored Properties10.11 Using self in Swift10.12 Understanding Swift Protocols10.13 Opaque Return Types10.14 Summary

11. An Introduction to Swift Subclassing and Extensions
11.1 Inheritance, Classes and Subclasses11.2 A Swift Inheritance Example11.3 Extending the Functionality of a Subclass11.4 Overriding Inherited Methods11.5 Initializing the Subclass11.6 Using the SavingsAccount Class11.7 Swift Class Extensions11.8 Summary
12. An Introduction to Swift Structures and Enumerations
12.1 An Overview of Swift Structures12.2 Value Types vs. Reference Types12.3 When to Use Structures or Classes12.4 An Overview of Enumerations12.5 Summary
13. An Introduction to Swift Property Wrappers
13.1 Understanding Property Wrappers13.2 A Simple Property Wrapper Example13.3 Supporting Multiple Variables and Types13.4 Summary
14. Working with Array and Dictionary Collections in Swift
14.1 Mutable and Immutable Collections14.2 Swift Array Initialization14.3 Working with Arrays in Swift14.3.1 Array Item Count14.3.2 Accessing Array Items14.4 Random Items and Shuffling14.5 Appending Items to an Array14.5.1 Inserting and Deleting Array Items14.6 Array Iteration14.7 Creating Mixed Type Arrays14.8 Swift Dictionary Collections14.9 Swift Dictionary Initialization14.10 Sequence-based Dictionary Initialization14.11 Dictionary Item Count14.12 Accessing and Updating Dictionary Items14.13 Adding and Removing Dictionary Entries14.14 Dictionary Iteration14.15 Summary
15. Understanding Error Handling in Swift 5
15.1 Understanding Error Handling15.2 Declaring Error Types15.3 Throwing an Error15.4 Calling Throwing Methods and Functions15.5 Accessing the Error Object15.6 Disabling Error Catching15.7 Using the defer Statement15.8 Summary
16. An Overview of SwiftUI
16.1 UIKit and Interface Builder16.2 SwiftUI Declarative Syntax16.3 SwiftUI is Data Driven16.4 SwiftUI vs. UIKit16.5 Summary
17. Using Xcode in SwiftUI Mode
17.1 Starting Xcode 1217.2 Creating a SwiftUI Project17.3 Xcode in SwiftUI Mode17.4 The Preview Canvas17.5 Preview Pinning17.6 The Preview Toolbar17.7 Modifying the Design17.8 Editor Context Menu17.9 Previewing on Multiple Device Configurations17.10 Running the App on a Simulator17.11 Running the App on a Physical iOS Device17.12 Managing Devices and Simulators17.13 Enabling Network Testing17.14 Dealing with Build Errors17.15 Monitoring Application Performance17.16 Exploring the User Interface Layout Hierarchy17.17 Summary
18. SwiftUI Architecture
18.1 SwiftUI App Hierarchy18.2 App18.3 Scenes18.4 Views18.5 Summary
19. The Anatomy of a Basic SwiftUI Project
19.1 Creating an Example Project19.2 Project Folders19.3 The DemoProjectApp.swift File19.4 The ContentView.swift File19.5 Assets.xcassets19.6 Info.plist19.7 Summary
20. Creating Custom Views with SwiftUI
20.1 SwiftUI Views20.2 Creating a Basic View20.3 Adding Additional Views20.4 Working with Subviews20.5 Views as Properties20.6 Modifying Views20.7 Working with Text Styles20.8 Modifier Ordering20.9 Custom Modifiers20.10 Basic Event Handling20.11 Building Custom Container Views20.12 Working with the Label View20.13 Summary
21. SwiftUI Stacks and Frames
21.1 SwiftUI Stacks21.2 Spacers, Alignment and Padding21.3 Container Child Limit21.4 Text Line Limits and Layout Priority21.5 Traditional vs. Lazy Stacks21.6 SwiftUI Frames21.7 Frames and the Geometry Reader21.8 Summary
22. SwiftUI State Properties, Observable, State and Environment Objects
22.1 State Properties22.2 State Binding22.3 Observable Objects22.4 State Objects22.5 Environment Objects22.6 Summary
23. A SwiftUI Example Tutorial
23.1 Creating the Example Project23.2 Reviewing the Project23.3 Adding a VStack to the Layout23.4 Adding a Slider View to the Stack23.5 Adding a State Property23.6 Adding Modifiers to the Text View23.7 Adding Rotation and Animation23.8 Adding a TextField to the Stack23.9 Adding a Color Picker23.10 Tidying the Layout23.11 Summary
24. SwiftUI Lifecycle Event Modifiers
24.1 Creating the LifecycleDemo Project24.2 Designing the App24.3 The onAppear and onDisappear Modifiers24.4 The onChange Modifier24.5 ScenePhase and the onChange Modifier24.6 Summary
25. SwiftUI Observable and Environment Objects – A Tutorial
25.1 About the ObservableDemo Project25.2 Creating the Project25.3 Adding the Observable Object25.4 Designing the ContentView Layout25.5 Adding the Second View25.6 Adding Navigation25.7 Using an Environment Object25.8 Summary
26. SwiftUI Data Persistence using AppStorage and SceneStorage
26.1 The @SceneStorage Property Wrapper26.2 The @AppStorage Property Wrapper26.3 Creating and Preparing the StorageDemo Project26.4 Using Scene Storage26.5 Using App Storage26.6 Storing Custom Types26.7 Summary
27. SwiftUI Stack Alignment and Alignment Guides
27.1 Container Alignment27.2 Alignment Guides27.3 Using the Alignment Guides Tool27.4 Custom Alignment Types27.5 Cross Stack Alignment27.6 ZStack Custom Alignment27.7 Summary
28. SwiftUI Lists and Navigation
28.1 SwiftUI Lists28.2 SwiftUI Dynamic Lists28.3 SwiftUI NavigationView and NavigationLink28.4 Making the List Editable28.5 Hierarchical Lists28.6 Summary
29. A SwiftUI List and Navigation Tutorial
29.1 About the ListNavDemo Project29.2 Creating the ListNavDemo Project29.3 Preparing the Project29.4 Adding the Car Structure29.5 Loading the JSON Data29.6 Adding the Data Store29.7 Designing the Content View29.8 Designing the Detail View29.9 Adding Navigation to the List29.10 Designing the Add Car View29.11 Implementing Add and Edit Buttons29.12 Adding the Edit Button Methods29.13 Summary
30. An Overview of List, OutlineGroup and DisclosureGroup
30.1 Hierarchical Data and Disclosures30.2 Hierarchies and Disclosure in SwiftUI Lists30.3 Using OutlineGroup30.4 Using DisclosureGroup30.5 Summary
31. A SwiftUI List, OutlineGroup and DisclosureGroup Tutorial
31.1 About the Example Project31.2 Creating the OutlineGroupDemo Project31.3 Adding the Data Structure31.4 Adding the List View31.5 Testing the Project31.6 Using the Sidebar List Style31.7 Using OutlineGroup31.8 Working with DisclosureGroups31.9 Summary
32. Building SwiftUI Grids with LazyVGrid and LazyHGrid
32.1 SwiftUI Grids32.2 GridItems32.3 Creating the GridDemo Project32.4 Working with Flexible GridItems32.5 Adding Scrolling Support to a Grid32.6 Working with Adaptive GridItems32.7 Working with Fixed GridItems32.8 Using the LazyHGrid View32.9 Summary
33. Building Tabbed and Paged Views in SwiftUI
33.1 An Overview of SwiftUI TabView33.2 Creating the TabViewDemo App33.3 Adding the TabView Container33.4 Adding the Content Views33.5 Adding View Paging33.6 Adding the Tab Items33.7 Adding Tab Item Tags33.8 Summary
34. Building Context Menus in SwiftUI
34.1 Creating the ContextMenuDemo Project34.2 Preparing the Content View34.3 Adding the Context Menu34.4 Testing the Context Menu34.5 Summary
35. Basic SwiftUI Graphics Drawing
35.1 Creating the DrawDemo Project35.2 SwiftUI Shapes35.3 Using Overlays35.4 Drawing Custom Paths and Shapes35.5 Drawing Gradients35.6 Summary
36. SwiftUI Animation and Transitions
36.1 Creating the AnimationDemo Example Project36.2 Implicit Animation36.3 Repeating an Animation36.4 Explicit Animation36.5 Animation and State Bindings36.6 Automatically Starting an Animation36.7 SwiftUI Transitions36.8 Combining Transitions36.9 Asymmetrical Transitions36.10 Summary
37. Working with Gesture Recognizers in SwiftUI
37.1 Creating the GestureDemo Example Project37.2 Basic Gestures37.3 The onChange Action Callback37.4 The updating Callback Action37.5 Composing Gestures37.6 Summary
38. Creating a Customized SwiftUI ProgressView
38.1 ProgressView Styles38.2 Creating the ProgressViewDemo Project38.3 Adding a ProgressView38.4 Using the Circular ProgressView Style38.5 Declaring an Indeterminate ProgressView38.6 ProgressView Customization38.7 Summary
39. An Overview of SwiftUI DocumentGroup Scenes
39.1 Documents in Apps39.2 Creating the DocDemo App39.3 The DocumentGroup Scene39.4 Declaring File Type Support39.4.1 Document Content Type Identifier39.4.2 Handler Rank39.4.3 Type Identifiers39.4.4 Filename Extensions39.4.5 Custom Type Document Content Identifiers39.4.6 Exported vs. Imported Type Identifiers39.5 Configuring File Type Support in Xcode39.6 The Document Structure39.7 The Content View39.8 Running the Example App39.9 Summary
40. A SwiftUI DocumentGroup Tutorial
40.1 Creating the ImageDocDemo Project40.2 Modifying the Info.plist File40.3 Adding an Image Asset40.4 Modifying the ImageDocDemoDocument.swift File40.5 Designing the Content View40.6 Filtering the Image40.7 Testing the App40.8 Summary
41. An Introduction to SiriKit
41.1 Siri and SiriKit41.2 SiriKit Domains 41.3 Siri Shortcuts41.4 SiriKit Intents41.5 How SiriKit Integration Works41.6 Resolving Intent Parameters41.7 The Confirm Method41.8 The Handle Method41.9 Custom Vocabulary41.10 The Siri User Interface41.11 Summary
42. A SwiftUI SiriKit Messaging Extension Tutorial
42.1 Creating the Example Project42.2 Enabling the Siri Entitlement42.3 Seeking Siri Authorization42.4 Adding the Intents Extension42.5 Supported Intents42.6 Trying the Example42.7 Specifying a Default Phrase42.8 Reviewing the Intent Handler42.9 Summary
43. Customizing the SiriKit Intent User Interface
43.1 Adding the Intents UI Extension43.2 Modifying the UI Extension43.3 Using the configure Method43.4 Using the configureView Method43.5 Designing the Siri Snippet43.6 Implementing a configureView Method43.7 Testing the Extension43.8 Summary
44. A SwiftUI SiriKit NSUserActivity Tutorial
44.1 About the SiriKit Photo Search Project44.2 Creating the SiriPhoto Project44.3 Enabling the Siri Entitlement44.4 Seeking Siri Authorization44.5 Adding an Image Asset44.6 Adding the Intents Extension to the Project44.7 Reviewing the Default Intents Extension44.8 Modifying the Supported Intents44.9 Modifying the IntentHandler Implementation44.10 Implementing the Resolve Methods44.11 Implementing the Confirmation Method44.12 Handling the Intent44.13 Testing the App44.14 Adding a Data Class to SiriPhoto44.15 Designing the Content View44.16 Adding Supported Activity Types to SiriPhoto44.17 Handling the NSUserActivity Object44.18 Testing the Completed App44.19 Summary
45. An Overview of Siri Shortcut App Integration
45.1 An Overview of Siri Shortcuts45.2 An Introduction to the Intent Definition File45.3 Automatically Generated Classes45.4 Donating Shortcuts45.5 The Add to Siri Button45.6 Summary
46. A SwiftUI Siri Shortcut Tutorial
46.1 About the Example App46.2 App Groups and UserDefaults46.3 Preparing the Project46.4 Running the App46.5 Enabling Siri Support46.6 Seeking Siri Authorization46.7 Adding the Intents Extension46.8 Adding the SiriKit Intent Definition File46.9 Adding the Intent to the App Group46.10 Configuring the SiriKit Intent Definition File46.11 Adding Intent Parameters46.12 Declaring Shortcut Combinations46.13 Configuring the Intent Response46.14 Configuring Target Membership46.15 Modifying the Intent Handler Code46.16 Adding the Confirm Method46.17 Donating Shortcuts to Siri46.18 Testing the Shortcuts46.19 Designing the Intent UI46.20 Summary
47. Building Widgets with SwiftUI and WidgetKit
47.1 An Overview of Widgets47.2 The Widget Extension47.3 Widget Configuration Types47.4 Widget Entry View47.5 Widget Timeline Entries47.6 Widget Timeline47.7 Widget Provider47.8 Reload Policy47.9 Relevance47.10 Forcing a Timeline Reload47.11 Widget Sizes47.12 Widget Placeholder47.13 Summary
48. A SwiftUI WidgetKit Tutorial
48.1 About the WidgetDemo Project48.2 Creating the WidgetDemo Project48.3 Building the App48.4 Adding the Widget Extension48.5 Adding the Widget Data48.6 Creating Sample Timelines48.7 Adding Image and Color Assets48.8 Designing the Widget View48.9 Modifying the Widget Provider48.10 Configuring the Placeholder View48.11 Previewing the Widget48.12 Summary
49. Supporting WidgetKit Size Families
49.1 Supporting Multiple Size Families49.2 Adding Size Support to the Widget View49.3 Summary
50. A SwiftUI WidgetKit Deep Link Tutorial
50.1 Adding Deep Link Support to the Widget50.2 Adding Deep Link Support to the App50.3 Testing the Widget50.4 Summary
51. Adding Configuration Options to a WidgetKit Widget
51.1 Modifying the Weather Data51.2 Configuring the Intent Definition51.3 Modifying the Widget51.4 Testing Widget Configuration51.5 Customizing the Configuration Intent UI51.6 Summary
52. Integrating UIViews with SwiftUI
52.1 SwiftUI and UIKit Integration52.2 Integrating UIViews into SwiftUI52.3 Adding a Coordinator52.4 Handling UIKit Delegation and Data Sources52.5 An Example Project52.6 Wrapping the UIScrolledView52.7 Implementing the Coordinator52.8 Using MyScrollView52.9 Summary
53. Integrating UIViewControllers with SwiftUI
53.1 UIViewControllers and SwiftUI53.2 Creating the ViewControllerDemo project53.3 Wrapping the UIImagePickerController53.4 Designing the Content View53.5 Completing MyImagePicker53.6 Completing the Content View53.7 Testing the App53.8 Summary
54. Integrating SwiftUI with UIKit
54.1 An Overview of the Hosting Controller54.2 A UIHostingController Example Project54.3 Adding the SwiftUI Content View54.4 Preparing the Storyboard54.5 Adding a Hosting Controller54.6 Configuring the Segue Action54.7 Embedding a Container View 54.8 Embedding SwiftUI in Code54.9 Summary
55. Preparing and Submitting an iOS 14 Application to the App Store
55.1 Verifying the iOS Distribution Certificate55.2 Adding App Icons55.3 Assign the Project to a Team55.4 Archiving the Application for Distribution55.5 Configuring the Application in App Store Connect55.6 Validating and Submitting the Application55.7 Configuring and Submitting the App for Review
Index

Overview

"SwiftUI Essentials - iOS 14 Edition" is your guide to mastering iOS development using the latest tools and technologies such as SwiftUI, Xcode 12, and Swift 5.3. Through a practical, hands-on approach, this book takes you from setting up your development environment to building and publishing your own iOS apps in the Apple app store.

What this Book will help me do

Set up your macOS system with Xcode 12 for iOS development.
Master the fundamentals of Swift programming including object-oriented principles.
Learn to create effective user interfaces using SwiftUI, including layouts, animations, and gestures.
Understand how to integrate legacy UIKit components with SwiftUI for app development.
Publish your own iOS apps to the App Store, covering the full deployment process.

Author(s)

Neil Smyth is a seasoned software developer with extensive experience in mobile app development and technical writing. As an author of numerous technical guides, Neil specializes in simplifying programming concepts into actionable, hands-on learning resources. His books are known for their clear instructions that empower readers to achieve tangible results.

Who is it for?

This book is ideal for aspiring and intermediate iOS developers who are eager to upgrade their skills to the latest development methods. A background in basic programming is helpful but not required as the book builds knowledge step-by-step. It's particularly suited for developers aiming to create modern, visually appealing apps using SwiftUI. Whether you're learning on your own or as part of a technical team, this book will guide you through essential skills and insights for iOS app development.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781801813228

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills