35,99 €
Mehr erfahren.
- Herausgeber: Payload Media, Inc.
- Kategorie: Fachliteratur
- Sprache: Englisch
This book aims to teach the skills necessary to build iOS 18 applications using SwiftUI, Xcode 16, and the Swift programming language.
Beginning with the basics, this book outlines the steps 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 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 and chart drawing, user interface animation, view transitions and gesture handling, WidgetKit, Live Activities, document-based apps, Core Data, SwiftData, and CloudKit.
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, and over 50 online knowledge test quizzes.
The aim of this book, therefore, is to teach you the skills to build your own apps for iOS 18 using SwiftUI. Assuming you are ready to download the iOS 18 SDK and Xcode 16 and have an Apple Mac system, you are ready to get started.
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Seitenzahl: 690
Veröffentlichungsjahr: 2024
Ähnliche
iOS 18 App Development
Essentials
iOS 18 App Development Essentials
ISBN-13: 978-1-951442-99-6
© 2024 Neil Smyth / Payload Media, Inc. All Rights Reserved.
This book is provided for personal use only. Unauthorized use, reproduction and/or distribution strictly prohibited. All rights reserved.
The content of this book is provided for informational purposes only. Neither the publisher nor the author offers any warranties or representation, express or implied, with regard to the accuracy of information contained in this book, nor do they accept any liability for any loss or damage arising from any errors or omissions.
This book contains trademarked terms that are used solely for editorial purposes and to the benefit of the respective trademark owner. The terms used within this book are not intended as infringement of any trademarks.
Rev: 1.0
https://www.payloadbooks.com
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
1.6 Take the Knowledge Tests
2. Joining the Apple Developer Program
2.1 Downloading Xcode 16 and the iOS 18 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 16 and the iOS 18 SDK
3.1 Identifying Your macOS Version
3.2 Installing Xcode 16 and the iOS 18 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 16 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 Take the Knowledge Test
5.11 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 Take the Knowledge Test
6.13 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 Take the Knowledge Test
7.12 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 Take the Knowledge Test
8.9 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 Take the Knowledge Test
9.18 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 Take the Knowledge Test
10.15 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 Take the Knowledge Test
11.9 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 Take the Knowledge Test
12.6 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 Take the Knowledge Test
13.5 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 Take the Knowledge Test
14.13 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 Take the Knowledge Test
15.9 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 Take the Knowledge Test
16.6 Summary
17. Using Xcode in SwiftUI Mode
17.1 Starting Xcode 16
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 Running the App on a Simulator
17.10 Running the App on a Physical iOS Device
17.11 Managing Devices and Simulators
17.12 Enabling Network Testing
17.13 Dealing with Build Errors
17.14 Monitoring Application Performance
17.15 Exploring the User Interface Layout Hierarchy
17.16 Take the Knowledge Test
17.17 Summary
18. SwiftUI Architecture
18.1 SwiftUI App Hierarchy
18.2 App
18.3 Scenes
18.4 Views
18.5 Take the Knowledge Test
18.6 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 Take the Knowledge Test
19.8 Summary
20. Creating Custom Views with SwiftUI
20.1 SwiftUI Views
20.2 Creating a Basic View
20.3 Adding Views
20.4 SwiftUI Hierarchies
20.5 Concatenating Text Views
20.6 Working with Subviews
20.7 Views as Properties
20.8 Modifying Views
20.9 Working with Text Styles
20.10 Modifier Ordering
20.11 Custom Modifiers
20.12 Basic Event Handling
20.13 Building Custom Container Views
20.14 Working with the Label View
20.15 Take the Knowledge Test
20.16 Summary
21. SwiftUI Stacks and Frames
21.1 SwiftUI Stacks
21.2 Spacers, Alignment and Padding
21.3 Grouping Views
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 Take the Knowledge Test
21.10 Summary
22. SwiftUI State Properties, Observation, and Environment Objects
22.1 State Properties
22.2 State Binding
22.3 Observable Objects
22.4 Observation using Combine
22.5 Combine State Objects
22.6 Using the Observation Framework
22.7 Observation and @Bindable
22.8 Environment Objects
22.9 Take the Knowledge Test
22.10 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 Take the Knowledge Test
23.12 Summary
24. SwiftUI Stack Alignment and Alignment Guides
24.1 Container Alignment
24.2 Alignment Guides
24.3 Custom Alignment Types
24.4 Cross Stack Alignment
24.5 ZStack Custom Alignment
24.6 Take the Knowledge Test
24.7 Summary
25. Predictive Code Completion in Xcode
25.1 Enabling Predictive Code Completion
25.2 Creating the CodeCompletion Project
25.3 Working with Code Completion
25.4 Code Completion from Comments
25.5 Take the Knowledge Test
25.6 Summary
26. An Overview of Swift Structured Concurrency
26.1 An Overview of Threads
26.2 The Application Main Thread
26.3 Completion Handlers
26.4 Structured Concurrency
26.5 Preparing the Project
26.6 Non-Concurrent Code
26.7 Introducing async/await Concurrency
26.8 Asynchronous Calls from Synchronous Functions
26.9 The await Keyword
26.10 Using async-let Bindings
26.11 Handling Errors
26.12 Understanding Tasks
26.13 Unstructured Concurrency
26.14 Detached Tasks
26.15 Task Management
26.16 Working with Task Groups
26.17 Avoiding Data Races
26.18 The for-await Loop
26.19 Asynchronous Properties
26.20 Take the Knowledge Test
26.21 Summary
27. An Introduction to Swift Actors
27.1 An Overview of Actors
27.2 Declaring an Actor
27.3 Understanding Data Isolation
27.4 A Swift Actor Example
27.5 Introducing the MainActor
27.6 Take the Knowledge Test
27.7 Summary
28. SwiftUI Concurrency and Lifecycle Event Modifiers
28.1 Creating the LifecycleDemo Project
28.2 Designing the App
28.3 The onAppear and onDisappear Modifiers
28.4 The onChange Modifier
28.5 ScenePhase and the onChange Modifier
28.6 Launching Concurrent Tasks
28.7 Take the Knowledge Test
28.8 Summary
29. SwiftUI Observable and Environment Objects – A Tutorial
29.1 About the ObservableDemo Project
29.2 Creating the Project
29.3 Adding the Observable Object
29.4 Designing the ContentView Layout
29.5 Adding the Second View
29.6 Adding Navigation
29.7 Using an Environment Object
29.8 Take the Knowledge Test
29.9 Summary
30. SwiftUI Data Persistence using AppStorage and SceneStorage
30.1 The @SceneStorage Property Wrapper
30.2 The @AppStorage Property Wrapper
30.3 Creating and Preparing the StorageDemo Project
30.4 Using Scene Storage
30.5 Using App Storage
30.6 Storing Custom Types
30.7 Take the Knowledge Test
30.8 Summary
31. SwiftUI Lists and Navigation
31.1 SwiftUI Lists
31.2 Modifying List Separators and Rows
31.3 SwiftUI Dynamic Lists
31.4 Creating a Refreshable List
31.5 SwiftUI NavigationStack and NavigationLink
31.6 Navigation by Value Type
31.7 Working with Navigation Paths
31.8 Navigation Bar Customization
31.9 Making the List Editable
31.10 Hierarchical Lists
31.11 Multicolumn Navigation
31.12 Take the Knowledge Test
31.13 Summary
32. A SwiftUI List and NavigationStack Tutorial
32.1 About the ListNavDemo Project
32.2 Creating the ListNavDemo Project
32.3 Preparing the Project
32.4 Adding the Car Structure
32.5 Adding the Data Store
32.6 Designing the Content View
32.7 Designing the Detail View
32.8 Adding Navigation to the List
32.9 Designing the Add Car View
32.10 Implementing Add and Edit Buttons
32.11 Adding a Navigation Path
32.12 Adding the Edit Button Methods
32.13 Summary
33. An Overview of Split View Navigation
33.1 Introducing NavigationSplitView
33.2 Using NavigationSplitView
33.3 Handling List Selection
33.4 NavigationSplitView Configuration
33.5 Controlling Column Visibility
33.6 Take the Knowledge Test
33.7 Summary
34. A NavigationSplitView Tutorial
34.1 About the Project
34.2 Creating the NavSplitDemo Project
34.3 Adding the Project Data
34.4 Creating the Navigation View
34.5 Building the Sidebar Column
34.6 Adding the Content Column List
34.7 Adding the Detail Column
34.8 Configuring the Split Navigation Experience
34.9 Summary
35. An Overview of List, OutlineGroup and DisclosureGroup
35.1 Hierarchical Data and Disclosures
35.2 Hierarchies and Disclosure in SwiftUI Lists
35.3 Using OutlineGroup
35.4 Using DisclosureGroup
35.5 Take the Knowledge Test
35.6 Summary
36. A SwiftUI List, OutlineGroup, and DisclosureGroup Tutorial
36.1 About the Example Project
36.2 Creating the OutlineGroupDemo Project
36.3 Adding the Data Structure
36.4 Adding the List View
36.5 Testing the Project
36.6 Using the Sidebar List Style
36.7 Using OutlineGroup
36.8 Working with DisclosureGroups
36.9 Summary
37. Building SwiftUI Grids with LazyVGrid and LazyHGrid
37.1 SwiftUI Grids
37.2 GridItems
37.3 Creating the GridDemo Project
37.4 Working with Flexible GridItems
37.5 Adding Scrolling Support to a Grid
37.6 Working with Adaptive GridItems
37.7 Working with Fixed GridItems
37.8 Using the LazyHGrid View
37.9 Take the Knowledge Test
37.10 Summary
38. Building SwiftUI Grids with Grid and GridRow
38.1 Grid and GridRow Views
38.2 Creating the GridRowDemo Project
38.3 A Simple Grid Layout
38.4 Non-GridRow Children
38.5 Automatic Empty Grid Cells
38.6 Adding Empty Cells
38.7 Column Spanning
38.8 Grid Alignment and Spacing
38.9 Take the Knowledge Test
38.10 Summary
39. Building Custom Containers
39.1 Introducing custom containers
39.2 Working with ViewBuilder Closures
39.3 Supporting Section Headers
39.4 Take the Knowledge Test
39.5 Summary
40. A SwiftUI Custom Container Tutorial
40.1 About the Custom Container Project
40.2 Creating the CustomContainerDemo Project
40.3 Adding the Sample Data
40.4 Declaring the Item View
40.5 Designing the Container
40.6 Using the Custom Container
40.7 Completing the Item View
40.8 Adding Section Headers
40.9 Summary
41. Building Tabbed and Paged Views in SwiftUI
41.1 An Overview of SwiftUI TabView
41.2 Creating the TabViewDemo App
41.3 Adding the TabView Container
41.4 Adding the Content Views
41.5 Adding View Paging
41.6 Adding the Tab Items
41.7 Adding Tab Item Tags
41.8 Take the Knowledge Test
41.9 Summary
42. Building Context Menus in SwiftUI
42.1 Creating the ContextMenuDemo Project
42.2 Preparing the Content View
42.3 Adding the Context Menu
42.4 Testing the Context Menu
42.5 Take the Knowledge Test
42.6 Summary
43. Basic SwiftUI Graphics Drawing
43.1 Creating the DrawDemo Project
43.2 SwiftUI Shapes
43.3 Using Overlays
43.4 Drawing Custom Paths and Shapes
43.5 Color Mixing
43.6 Color Gradients and Shadows
43.7 Drawing Gradients
43.8 Mesh Gradients
43.9 Take the Knowledge Test
43.10 Summary
44. SwiftUI Animation and Transitions
44.1 Creating the AnimationDemo Example Project
44.2 Implicit Animation
44.3 Repeating an Animation
44.4 Explicit Animation
44.5 Animation and State Bindings
44.6 Automatically Starting an Animation
44.7 SwiftUI Transitions
44.8 Combining Transitions
44.9 Asymmetrical Transitions
44.10 Take the Knowledge Test
44.11 Summary
45. Working with Gesture Recognizers in SwiftUI
45.1 Creating the GestureDemo Example Project
45.2 Basic Gestures
45.3 The onChange Action Callback
45.4 The updating Callback Action
45.5 Composing Gestures
45.6 Take the Knowledge Test
45.7 Summary
46. Creating a Customized SwiftUI ProgressView
46.1 ProgressView Styles
46.2 Creating the ProgressViewDemo Project
46.3 Adding a ProgressView
46.4 Using the Circular ProgressView Style
46.5 Declaring an Indeterminate ProgressView
46.6 ProgressView Customization
46.7 Take the Knowledge Test
46.8 Summary
47. Presenting Data with SwiftUI Charts
47.1 Introducing SwiftUI Charts
47.2 Passing Data to the Chart
47.3 Combining Mark Types
47.4 Filtering Data into Multiple Graphs
47.5 Changing the Chart Background
47.6 Changing the Interpolation Method
47.7 Take the Knowledge Test
47.8 Summary
48. A SwiftUI Charts Tutorial
48.1 Creating the ChartDemo Project
48.2 Adding the Project Data
48.3 Adding the Chart View
48.4 Creating Multiple Graphs
48.5 Summary
49. An Overview of SwiftUI DocumentGroup Scenes
49.1 Documents in Apps
49.2 Creating the DocDemo App
49.3 The DocumentGroup Scene
49.4 Declaring File Type Support
49.4.1 Document Content Type Identifier
49.4.2 Handler Rank
49.4.3 Type Identifiers
49.4.4 Filename Extensions
49.4.5 Custom Type Document Content Identifiers
49.4.6 Exported vs. Imported Type Identifiers
49.5 Configuring File Type Support in Xcode
49.6 The Document Structure
49.7 The Content View
49.8 Adding Navigation
49.9 Running the Example App
49.10 Customizing the Launch Screen
49.11 Take the Knowledge Test
49.12 Summary
50. A SwiftUI DocumentGroup Tutorial
50.1 Creating the ImageDocDemo Project
50.2 Modifying the Info.plist File
50.3 Adding an Image Asset
50.4 Modifying the ImageDocDemoDocument.swift File
50.5 Designing the Content View
50.6 Filtering the Image
50.7 Testing the App
50.8 Summary
51. An Introduction to Core Data and SwiftUI
51.1 The Core Data Stack
51.2 Persistent Container
51.3 Managed Objects
51.4 Managed Object Context
51.5 Managed Object Model
51.6 Persistent Store Coordinator
51.7 Persistent Object Store
51.8 Defining an Entity Description
51.9 Initializing the Persistent Container
51.10 Obtaining the Managed Object Context
51.11 Setting the Attributes of a Managed Object
51.12 Saving a Managed Object
51.13 Fetching Managed Objects
51.14 Retrieving Managed Objects based on Criteria
51.15 Take the Knowledge Test
51.16 Summary
52. A SwiftUI Core Data Tutorial
52.1 Creating the CoreDataDemo Project
52.2 Defining the Entity Description
52.3 Creating the Persistence Controller
52.4 Setting up the View Context
52.5 Preparing the ContentView for Core Data
52.6 Designing the User Interface
52.7 Saving Products
52.8 Testing the addProduct() Function
52.9 Deleting Products
52.10 Adding the Search Function
52.11 Testing the Completed App
52.12 Summary
53. An Overview of SwiftUI Core Data and CloudKit Storage
53.1 An Overview of CloudKit
53.2 CloudKit Containers
53.3 CloudKit Public Database
53.4 CloudKit Private Databases
53.5 Data Storage Quotas
53.6 CloudKit Records
53.7 CloudKit Record IDs
53.8 CloudKit References
53.9 Record Zones
53.10 CloudKit Console
53.11 CloudKit Sharing
53.12 CloudKit Subscriptions
53.13 Take the Knowledge Test
53.14 Summary
54. A SwiftUI Core Data and CloudKit Tutorial
54.1 Enabling CloudKit Support
54.2 Enabling Background Notifications Support
54.3 Switching to the CloudKit Persistent Container
54.4 Testing the App
54.5 Reviewing the Saved Data in the CloudKit Console
54.6 Filtering and Sorting Queries
54.7 Editing and Deleting Records
54.8 Adding New Records
54.9 Summary
55. An Introduction to SwiftData
55.1 Introducing SwiftData
55.2 Model Classes
55.3 Model Container
55.4 Model Configuration
55.5 Model Context
55.6 Predicates and FetchDescriptors
55.7 The @Query Macro
55.8 Model Relationships
55.9 Model Attributes
55.10 Take the Knowledge Test
55.11 Summary
56. A SwiftData Tutorial
56.1 About the SwiftData Project
56.2 Creating the SwiftDataDemo Project
56.3 Adding the Data Models
56.4 Setting up the Model Container
56.5 Accessing the Model Context
56.6 Designing the Visitor List View
56.7 Establishing the Relationship
56.8 Creating the Visitor Detail View
56.9 Modifying the Content View
56.10 Testing the SwiftData Demo App
56.11 Adding the Search Predicate
56.12 Summary
57. Building Widgets with SwiftUI and WidgetKit
57.1 An Overview of Widgets
57.2 The Widget Extension
57.3 Widget Configuration Types
57.4 Widget Entry View
57.5 Widget Timeline Entries
57.6 Widget Timeline
57.7 Widget Provider
57.8 Reload Policy
57.9 Relevance
57.10 Forcing a Timeline Reload
57.11 Widget Sizes
57.12 Widget Placeholder
57.13 Take the Knowledge Test
57.14 Summary
58. A SwiftUI WidgetKit Tutorial
58.1 About the WidgetDemo Project
58.2 Creating the WidgetDemo Project
58.3 Building the App
58.4 Adding the Widget Extension
58.5 Adding the Widget Data
58.6 Creating Sample Timelines
58.7 Adding Image and Color Assets
58.8 Designing the Widget View
58.9 Modifying the Widget Provider
58.10 Configuring the Placeholder View
58.11 Previewing the Widget
58.12 Summary
59. Supporting WidgetKit Size Families
59.1 Supporting Multiple Size Families
59.2 Adding Size Support to the Widget View
59.3 Take the Knowledge Test
59.4 Summary
60. A SwiftUI WidgetKit Deep Link Tutorial
60.1 Adding Deep Link Support to the Widget
60.2 Adding Deep Link Support to the App
60.3 Testing the Widget
60.4 Summary
61. Adding Configuration Options to a WidgetKit Widget
61.1 Reviewing the Project Code
61.2 Adding an App Entity
61.3 Adding Entity Query
61.4 Modifying the App Intent
61.5 Modifying the Timeline Code
61.6 Testing Widget Configuration
61.7 Customizing the Configuration Intent UI
61.8 Take the Knowledge Test
61.9 Summary
62. An Overview of Live Activities in SwiftUI
62.1 Introducing Live Activities
62.2 Creating a Live Activity
62.3 Live Activity Attributes
62.4 Designing the Live Activity Presentations
62.4.1 Lock Screen/Banner
62.4.2 Dynamic Island Expanded Regions
62.4.3 Dynamic Island Compact Regions
62.4.4 Dynamic Island Minimal
62.5 Starting a Live Activity
62.6 Updating a Live Activity
62.7 Activity Alert Configurations
62.8 Stopping a Live Activity
62.9 Take the Knowledge Test
62.10 Summary
63. A SwiftUI Live Activity Tutorial
63.1 About the LiveActivityDemo Project
63.2 Creating the Project
63.3 Building the View Model
63.4 Designing the Content View
63.5 Adding the Live Activity Extension
63.6 Enabling Live Activities Support
63.7 Enabling the Background Fetch Capability
63.8 Defining the Activity Widget Attributes
63.9 Adding the Percentage and Lock Screen Views
63.10 Designing the Widget Layouts
63.11 Launching the Live Activity
63.12 Updating the Live Activity
63.13 Stopping the Live Activity
63.14 Testing the App
63.15 Adding an Alert Notification
63.16 Understanding Background Updates
63.17 Summary
64. Adding a Refresh Button to a Live Activity
64.1 Adding Interactivity to Live Activities
64.2 Adding the App Intent
64.3 Setting a Stale Date
64.4 Detecting Stale Data
64.5 Testing the Live Activity Intent
64.6 Take the Knowledge Test
64.7 Summary
65. A Live Activity Push Notifications Tutorial
65.1 An Overview of Push Notifications
65.2 Registering an APNs Key
65.3 Enabling Push Notifications for the App
65.4 Enabling Frequent Updates
65.5 Requesting User Permission
65.6 Changing the Push Type
65.7 Obtaining a Push Token
65.8 Removing the Refresh Button
65.9 Take the Knowledge Test
65.10 Summary
66. Testing Live Activity Push Notifications
66.1 Using the Push Notifications Console
66.2 Configuring the Notification
66.3 Defining the Payload
66.4 Sending the Notification
66.5 Sending Push Notifications from the Command Line
66.6 Summary
67. Troubleshooting Live Activity Push Notifications
67.1 Push Notification Problems
67.2 Push Notification Delivery
67.3 Check the Payload Structure
67.4 Validating the Push and Authentication Tokens
67.5 Checking the Device Log
67.6 Take the Knowledge Test
67.7 Summary
68. Integrating UIViews with SwiftUI
68.1 SwiftUI and UIKit Integration
68.2 Integrating UIViews into SwiftUI
68.3 Adding a Coordinator
68.4 Handling UIKit Delegation and Data Sources
68.5 An Example Project
68.6 Wrapping the UIScrolledView
68.7 Implementing the Coordinator
68.8 Using MyScrollView
68.9 Take the Knowledge Test
68.10 Summary
69. Integrating UIViewControllers with SwiftUI
69.1 UIViewControllers and SwiftUI
69.2 Creating the ViewControllerDemo project
69.3 Wrapping the UIImagePickerController
69.4 Designing the Content View
69.5 Completing MyImagePicker
69.6 Completing the Content View
69.7 Testing the App
69.8 Take the Knowledge Test
69.9 Summary
70. Integrating SwiftUI with UIKit
70.1 An Overview of the Hosting Controller
70.2 A UIHostingController Example Project
70.3 Adding the SwiftUI Content View
70.4 Preparing the Storyboard
70.5 Adding a Hosting Controller
70.6 Configuring the Segue Action
70.7 Embedding a Container View
70.8 Embedding SwiftUI in Code
70.9 Take the Knowledge Test
70.10 Summary
71. Preparing and Submitting an iOS 18 Application to the App Store
71.1 Verifying the iOS Distribution Certificate
71.2 Adding App Icons
71.3 Assign the Project to a Team
71.4 Archiving the Application for Distribution
71.5 Configuring the Application in App Store Connect
71.6 Validating and Submitting the Application
71.7 Configuring and Submitting the App for Review
Index
1. Start Here
This book aims to teach the skills necessary to build iOS 18 applications using SwiftUI, Xcode 16, and the Swift programming language.
Beginning with the basics, this book outlines the steps 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 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 and chart drawing, user interface animation, view transitions and gesture handling, WidgetKit, Live Activities, document-based apps, Core Data, SwiftData, and CloudKit.
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 to build your own apps for iOS 18 using SwiftUI. Assuming you are ready to download the iOS 18 SDK and Xcode 16 and have an Apple Mac system, you are ready to get started.
1.1 For Swift Programmers
This book has been designed to address the needs of both existing Swift programmers and those new to Swift and iOS app development. If you are familiar with the Swift programming language, you can probably skip the Swift-specific chapters. If you are not yet familiar with the SwiftUI-specific language features of Swift, however, we recommend that you at least read the sections covering implicit returns from single expressions, opaque return types, and property wrappers. These features are central to the implementation and understanding of SwiftUI.
1.2 For Non-Swift Programmers
If you are new to programming in Swift, then the entire book is appropriate for you. Just start at the beginning and keep going.
1.3 Source Code Download
The source code and Xcode project files for the examples contained in this book are available for download at:
https://www.payloadbooks.com/product/ios18code/
1.4 Feedback
We want you to be satisfied with your purchase of this book. Therefore, if you find any errors in the book or have any comments, questions, or concerns, please contact us at [email protected].
1.5 Errata
While we make every effort to ensure the accuracy of the content of this book, inevitably, a book covering a subject area of this size and complexity may include some errors and oversights. Any known issues with the book will be outlined, together with solutions, at the following URL:
https://www.payloadbooks.com/ios18errata/
In the event that you find an error not listed in the errata, please let us know by emailing our technical support team at [email protected].
1.6 Take the Knowledge Tests
Look for this section at the end of most chapters and use the link or scan the QR code to take a knowledge quiz to test and reinforce your understanding of the covered topic. Use the following link to review the full list of tests available for this book:
https://www.answertopia.com/g3um
2. Joining the Apple Developer Program
The first step in the process of learning to develop iOS 18 based applications involves gaining an understanding of the advantages of enrolling in the Apple Developer Program and deciding the point at which it makes sense to pay to join. With these goals in mind, this chapter will outline the costs and benefits of joining the developer program and, finally, walk through the steps involved in enrolling.
2.1 Downloading Xcode 16 and the iOS 18 SDK
The latest versions of both the iOS SDK and Xcode can be downloaded free of charge from the macOS App Store. Since the tools are free, this raises the question of whether to enroll in the Apple Developer Program, or to wait until it becomes necessary later in your app development learning curve.
2.2 Apple Developer Program
Membership in the Apple Developer Program currently costs $99 per year to enroll as an individual developer. Organization level membership is also available.
Much can be achieved without the need to pay to join the Apple Developer program. There are, however, areas of app development which cannot be fully tested without program membership. Of particular significance is the fact that Siri integration, iCloud access, Apple Pay, Game Center and In-App Purchasing can only be enabled and tested with Apple Developer Program membership.
Of further significance is the fact that Apple Developer Program members have access to technical support from Apple’s iOS support engineers (though the annual fee initially covers the submission of only two support incident reports, more can be purchased). Membership also includes access to the Apple Developer forums; an invaluable resource both for obtaining assistance and guidance from other iOS developers, and for finding solutions to problems that others have encountered and subsequently resolved.
Program membership also provides early access to the pre-release Beta versions of Xcode, macOS and iOS.
By far the most important aspect of the Apple Developer Program is that membership is a mandatory requirement in order to publish an application for sale or download in the App Store.
Clearly, program membership is going to be required at some point before your application reaches the App Store. The only question remaining is when exactly to sign up.
2.3 When to Enroll in the Apple Developer Program?
Clearly, there are many benefits to Apple Developer Program membership and, eventually, membership will be necessary to begin selling your apps. As to whether to pay the enrollment fee now or later will depend on individual circumstances. If you are still in the early stages of learning to develop iOS apps or have yet to come up with a compelling idea for an app to develop then much of what you need is provided without program membership. As your skill level increases and your ideas for apps to develop take shape you can, after all, always enroll in the developer program later.
If, on the other hand, you are confident that you will reach the stage of having an application ready to publish, or know that you will need access to more advanced features such as Siri support, iCloud storage, In-App Purchasing and Apple Pay then it is worth joining the developer program sooner rather than later.
2.4 Enrolling in the Apple Developer Program
If your goal is to develop iOS apps for your employer, then it is first worth checking whether the company already has membership. That being the case, contact the program administrator in your company and ask them to send you an invitation from within the Apple Developer Program Member Center to join the team. Once they have done so, Apple will send you an email entitled You Have Been Invited to Join an Apple Developer Program containing a link to activate your membership. If you or your company is not already a program member, you can enroll online at:
https://developer.apple.com/programs/enroll/
Apple provides enrollment options for businesses and individuals. To enroll as an individual, you will need to provide credit card information in order to verify your identity. To enroll as a company, you must have legal signature authority (or access to someone who does) and be able to provide documentation such as a Dun & Bradstreet D-U-N-S number and documentation confirming legal entity status.
Acceptance into the developer program as an individual member typically takes less than 24 hours with notification arriving in the form of an activation email from Apple. Enrollment as a company can take considerably longer (sometimes weeks or even months) due to the burden of the additional verification requirements.
While awaiting activation you may log in to the Member Center with restricted access using your Apple ID and password at the following URL:
https://developer.apple.com/membercenter
Once logged in, clicking on the Your Account tab at the top of the page will display the prevailing status of your application to join the developer program as Enrollment Pending. Once the activation email has arrived, log in to the Member Center again and note that access is now available to a wide range of options and resources, as illustrated in Figure 2-1:
Figure 2-1
2.5 Summary
An important early step in the iOS 18 application development process involves identifying the best time to enroll in the Apple Developer Program. This chapter has outlined the benefits of joining the program, provided some guidance to keep in mind when considering developer program membership and walked briefly through the enrollment process. The next step is to download and install the iOS 18 SDK and Xcode 16 development environment.
3. Installing Xcode 16 and the iOS 18 SDK
iOS apps are developed using the iOS SDK and Apple’s Xcode development environment. Xcode is an integrated development environment (IDE) within which you will code, compile, test and debug your iOS applications.
All of the examples in this book are based on Xcode version 15 and use features unavailable in earlier Xcode versions. This chapter will cover the steps involved in installing Xcode 16 and the iOS 18 SDK on macOS.
3.1 Identifying Your macOS Version
When developing with Xcode 16, a system running macOS Sonoma 14.5 or later or later is required. If you are unsure of the version of macOS on your Mac, you can find this information by clicking on the Apple menu in the top left-hand corner of the screen and selecting the About This Mac option from the menu. In the resulting dialog, check the macOS line:
Figure 3-1
If the “About This Mac” dialog does not indicate that macOS Sonoma 14.5 or later is running, click on the More Info... button to open the Settings app and check for available operating system updates.
3.2 Installing Xcode 16 and the iOS 18 SDK
The best way to obtain the latest Xcode and iOS SDK versions is to download them from the Apple Mac App Store. Launch the App Store on your macOS system, enter Xcode into the search box and click on the Get button to initiate the installation. This will install both Xcode and the iOS SDK.
3.3 Starting Xcode
Having successfully installed the SDK and Xcode, the next step is to launch it so we are ready to start development work. To start up Xcode, open the macOS Finder and search for Xcode. Since you will be frequently using this tool, take this opportunity to drag and drop it onto your dock for easier access in the future. Click on the Xcode icon in the dock to launch the tool. The first time Xcode runs you may be prompted to install additional components. Follow these steps, entering your username and password when prompted.
Once Xcode has loaded, and assuming this is the first time you have used Xcode on this system, you will be presented with the Welcome screen from which you are ready to proceed:
Figure 3-2
3.4 Adding Your Apple ID to the Xcode Preferences
Whether or not you enroll in the Apple Developer Program, it is worth adding your Apple ID to Xcode now that it is installed and running. Select the Xcode -> Settings… menu option followed by the Accounts tab. On the Accounts screen, click on the + button highlighted in Figure 3-3, select Apple ID from the resulting panel and click on the Continue button. When prompted, enter your Apple ID and password before clicking on the Sign In button to add the account to the preferences.
Figure 3-3
3.5 Developer and Distribution Signing Identities
Once the Apple ID has been entered the next step is to generate signing identities. To view the current signing identities, select the newly added Apple ID in the Accounts panel and click on the Manage Certificates… button to display a list of available signing identity types. To create a signing identity, simply click on the + button highlighted in Figure 3-4 and make the appropriate selection from the menu:
Figure 3-4
If the Apple ID has been used to enroll in the Apple Developer program, the option to create an Apple Distribution certificate will appear in the menu which will, when clicked, generate the signing identity required to submit the app to the Apple App Store. You will also need to create a Developer ID Application certificate if you plan to integrate features such as iCloud and Siri into your app projects. If you have not yet signed up for the Apple Developer program, select the Apple Development option to allow apps to be tested during development.
3.6 Summary
This book was written using Xcode 16 and the iOS 18 SDK running on macOS 13.5.2 (Ventura). Before beginning SwiftUI development, the first step is to install Xcode and configure it with your Apple ID via the accounts section of the Preferences screen. Once these steps have been performed, a development certificate must be generated which will be used to sign apps developed within Xcode. This will allow you to build and test your apps on physical iOS-based devices.
When you are ready to upload your finished app to the App Store, you will also need to generate a distribution certificate, a process requiring membership in the Apple Developer Program as outlined in the previous chapter.
Having installed the iOS SDK and successfully launched Xcode 16, we can now look at Xcode in more detail, starting with Playgrounds.
