34,99 €
Mehr erfahren.
- Herausgeber: Payload Media, Inc.
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Englisch
This book will teach you how to build iOS 17 applications using SwiftUI, Xcode 15, 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 17 using SwiftUI.
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Seitenzahl: 663
Veröffentlichungsjahr: 2023
Ähnliche
iOS 17 App Development
Essentials
Figure 1-1Title
iOS 17 App Development Essentials
ISBN-13: 978-1-951442-80-4
© 2023 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
Contents
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 15 and the iOS 17 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 15 and the iOS 17 SDK
3.1 Identifying Your macOS Version
3.2 Installing Xcode 15 and the iOS 17 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 15 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 15
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 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 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 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 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 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 Custom Alignment Types
29.4 Cross Stack Alignment
29.5 ZStack Custom Alignment
29.6 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 Adding the Data Store
31.6 Designing the Content View
31.7 Designing the Detail View
31.8 Adding Navigation to the List
31.9 Designing the Add Car View
31.10 Implementing Add and Edit Buttons
31.11 Adding a Navigation Path
31.12 Adding the Edit Button Methods
31.13 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 Adding Navigation
46.9 Running the Example App
46.10 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 Filtering and Sorting Queries
51.7 Editing and Deleting Records
51.8 Adding New Records
51.9 Viewing Telemetry Data
51.10 Summary
52. An Introduction to SwiftData
52.1 Introducing SwiftData
52.2 Model Classes
52.3 Model Container
52.4 Model Configuration
52.5 Model Context
52.6 Predicates and FetchDescriptors
52.7 The @Query Macro
52.8 Model Relationships
52.9 Model Attributes
52.10 Summary
53. A SwiftData Tutorial
53.1 About the SwiftData Project
53.2 Creating the SwiftDataDemo Project
53.3 Adding the Data Models
53.4 Setting up the Model Container
53.5 Accessing the Model Context
53.6 Designing the Visitor List View
53.7 Establishing the Relationship
53.8 Creating the Visitor Detail View
53.9 Modifying the Content View
53.10 Testing the SwiftData Demo App
53.11 Adding the Search Predicate
53.12 Summary
54. Building Widgets with SwiftUI and WidgetKit
54.1 An Overview of Widgets
54.2 The Widget Extension
54.3 Widget Configuration Types
54.4 Widget Entry View
54.5 Widget Timeline Entries
54.6 Widget Timeline
54.7 Widget Provider
54.8 Reload Policy
54.9 Relevance
54.10 Forcing a Timeline Reload
54.11 Widget Sizes
54.12 Widget Placeholder
54.13 Summary
55. A SwiftUI WidgetKit Tutorial
55.1 About the WidgetDemo Project
55.2 Creating the WidgetDemo Project
55.3 Building the App
55.4 Adding the Widget Extension
55.5 Adding the Widget Data
55.6 Creating Sample Timelines
55.7 Adding Image and Color Assets
55.8 Designing the Widget View
55.9 Modifying the Widget Provider
55.10 Configuring the Placeholder View
55.11 Previewing the Widget
55.12 Summary
56. Supporting WidgetKit Size Families
56.1 Supporting Multiple Size Families
56.2 Adding Size Support to the Widget View
56.3 Summary
57. A SwiftUI WidgetKit Deep Link Tutorial
57.1 Adding Deep Link Support to the Widget
57.2 Adding Deep Link Support to the App
57.3 Testing the Widget
57.4 Summary
58. Adding Configuration Options to a WidgetKit Widget
58.1 Reviewing the Project Code
58.2 Adding an App Entity
58.3 Adding Entity Query
58.4 Modifying the App Intent
58.5 Modifying the Timeline Code
58.6 Testing Widget Configuration
58.7 Customizing the Configuration Intent UI
58.8 Summary
59. An Overview of Live Activities in SwiftUI
59.1 Introducing Live Activities
59.2 Creating a Live Activity
59.3 Live Activity Attributes
59.4 Designing the Live Activity Presentations
59.4.1 Lock Screen/Banner
59.4.2 Dynamic Island Expanded Regions
59.4.3 Dynamic Island Compact Regions
59.4.4 Dynamic Island Minimal
59.5 Starting a Live Activity
59.6 Updating a Live Activity
59.7 Activity Alert Configurations
59.8 Stopping a Live Activity
59.9 Summary
60. A SwiftUI Live Activity Tutorial
60.1 About the LiveActivityDemo Project
60.2 Creating the Project
60.3 Building the View Model
60.4 Designing the Content View
60.5 Adding the Live Activity Extension
60.6 Enabling Live Activities Support
60.7 Enabling the Background Fetch Capability
60.8 Defining the Activity Widget Attributes
60.9 Adding the Percentage and Lock Screen Views
60.10 Designing the Widget Layouts
60.11 Launching the Live Activity
60.12 Updating the Live Activity
60.13 Stopping the Live Activity
60.14 Testing the App
60.15 Adding an Alert Notification
60.16 Understanding Background Updates
60.17 Summary
61. Adding a Refresh Button to a Live Activity
61.1 Adding Interactivity to Live Activities
61.2 Adding the App Intent
61.3 Setting a Stale Date
61.4 Detecting Stale Data
61.5 Testing the Live Activity Intent
61.6 Summary
62. A Live Activity Push Notifications Tutorial
62.1 An Overview of Push Notifications
62.2 Registering an APNs Key
62.3 Enabling Push Notifications for the App
62.4 Enabling Frequent Updates
62.5 Requesting User Permission
62.6 Changing the Push Type
62.7 Obtaining a Push Token
62.8 Removing the Refresh Button
62.9 Summary
63. Testing Live Activity Push Notifications
63.1 Using the Push Notifications Console
63.2 Configuring the Notification
63.3 Defining the Payload
63.4 Sending the Notification
63.5 Sending Push Notifications from the Command Line
63.6 Summary
64. Troubleshooting Live Activity Push Notifications
64.1 Push Notification Problems
64.2 Push Notification Delivery
64.3 Check the Payload Structure
64.4 Validating the Push and Authentication Tokens
64.5 Checking the Device Log
64.6 Summary
65. Integrating UIViews with SwiftUI
65.1 SwiftUI and UIKit Integration
65.2 Integrating UIViews into SwiftUI
65.3 Adding a Coordinator
65.4 Handling UIKit Delegation and Data Sources
65.5 An Example Project
65.6 Wrapping the UIScrolledView
65.7 Implementing the Coordinator
65.8 Using MyScrollView
65.9 Summary
66. Integrating UIViewControllers with SwiftUI
66.1 UIViewControllers and SwiftUI
66.2 Creating the ViewControllerDemo project
66.3 Wrapping the UIImagePickerController
66.4 Designing the Content View
66.5 Completing MyImagePicker
66.6 Completing the Content View
66.7 Testing the App
66.8 Summary
67. Integrating SwiftUI with UIKit
67.1 An Overview of the Hosting Controller
67.2 A UIHostingController Example Project
67.3 Adding the SwiftUI Content View
67.4 Preparing the Storyboard
67.5 Adding a Hosting Controller
67.6 Configuring the Segue Action
67.7 Embedding a Container View
67.8 Embedding SwiftUI in Code
67.9 Summary
68. Preparing and Submitting an iOS 17 Application to the App Store
68.1 Verifying the iOS Distribution Certificate
68.2 Adding App Icons
68.3 Assign the Project to a Team
68.4 Archiving the Application for Distribution
68.5 Configuring the Application in App Store Connect
68.6 Validating and Submitting the Application
68.7 Configuring and Submitting the App for Review
Index
1. Start Here
This book aims to teach the skills necessary to build iOS 17 applications using SwiftUI, Xcode 15, 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 17 using SwiftUI. Assuming you are ready to download the iOS 17 SDK and Xcode 15 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.ebookfrenzy.com/retail/ios17/
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.ebookfrenzy.com/errata/ios17.html
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].
2. Joining the Apple Developer Program
The first step in the process of learning to develop iOS 17 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 15 and the iOS 17 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 17 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 17 SDK and Xcode 15 development environment.
3. Installing Xcode 15 and the iOS 17 SDK
iOS apps are developed using the iOS SDK in conjunction with 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 make use of features unavailable in earlier Xcode versions. In this chapter we will cover the steps involved in installing both Xcode 15 and the iOS 17 SDK on macOS.
3.1 Identifying Your macOS Version
When developing with SwiftUI, the Xcode 15 environment requires a system running macOS Ventura 13.5, or later. 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 13.5 or later is running, click on the Software Update… button to download and install the appropriate operating system upgrades.
3.2 Installing Xcode 15 and the iOS 17 SDK
The best way to obtain the latest versions of Xcode and the iOS SDK 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 that we are ready to start development work. To start up Xcode, open the macOS Finder and search for Xcode. Since you will be making frequent use of 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 to do so.
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
Regardless of whether or not you choose to 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 15 and the iOS 17 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 15 we can now look at Xcode in more detail, starting with Playgrounds.
