Cover: iOS 17 App Development Essentials - Payload Media, Inc.

iOS 17 App Development Essentials

Developing iOS 17 Apps with Xcode 15, Swift, and SwiftUI

Smyth(Author)

Payload Media, Inc. (Publisher)

1st Edition

Published on 23. October 2023

584 pages

E-Book

ePUB with Adobe-DRM

System requirements

978-1-951442-80-4 (ISBN)

€36.99incl. 7% vat

System requirements

for ePUB with Adobe-DRM

E-Book Single Licence

Available for download

Description

Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.

Alles über E-Books, Kopierschutz & Dateiformate finden Sie in unserem Info- & Hilfebereich.

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.

More details

Other editions

Content

Intro
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

System requirements

Save as PDF Copy link into clipboard