SwiftUI Essentials - iOS 14 Edition

Spis treści książki

• 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 12 and the iOS 14 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 12 and the iOS 14 SDK
  • 3.1 Identifying Your macOS Version
  • 3.2 Installing Xcode 12 and the iOS 14 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 12 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.4 Random Items and Shuffling
  • 14.5 Appending Items to an Array
    • 14.5.1 Inserting and Deleting Array Items
  • 14.6 Array Iteration
  • 14.7 Creating Mixed Type Arrays
  • 14.8 Swift Dictionary Collections
  • 14.9 Swift Dictionary Initialization
  • 14.10 Sequence-based Dictionary Initialization
  • 14.11 Dictionary Item Count
  • 14.12 Accessing and Updating Dictionary Items
  • 14.13 Adding and Removing Dictionary Entries
  • 14.14 Dictionary Iteration
  • 14.15 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 12
  • 17.2 Creating a SwiftUI Project
  • 17.3 Xcode in SwiftUI Mode
  • 17.4 The Preview Canvas
  • 17.5 Preview Pinning
  • 17.6 The Preview Toolbar
  • 17.7 Modifying the Design
  • 17.8 Editor Context Menu
  • 17.9 Previewing on Multiple Device Configurations
  • 17.10 Running the App on a Simulator
  • 17.11 Running the App on a Physical iOS Device
  • 17.12 Managing Devices and Simulators
  • 17.13 Enabling Network Testing
  • 17.14 Dealing with Build Errors
  • 17.15 Monitoring Application Performance
  • 17.16 Exploring the User Interface Layout Hierarchy
  • 17.17 Summary
• 18. SwiftUI Architecture
  • 18.1 SwiftUI App Hierarchy
  • 18.2 App
  • 18.3 Scenes
  • 18.4 Views
  • 18.5 Summary
• 19. The Anatomy of a Basic SwiftUI Project
  • 19.1 Creating an Example Project
  • 19.2 Project Folders
  • 19.3 The DemoProjectApp.swift File
  • 19.4 The ContentView.swift File
  • 19.5 Assets.xcassets
  • 19.6 Info.plist
  • 19.7 Summary
• 20. Creating Custom Views with SwiftUI
  • 20.1 SwiftUI Views
  • 20.2 Creating a Basic View
  • 20.3 Adding Additional Views
  • 20.4 Working with Subviews
  • 20.5 Views as Properties
  • 20.6 Modifying Views
  • 20.7 Working with Text Styles
  • 20.8 Modifier Ordering
  • 20.9 Custom Modifiers
  • 20.10 Basic Event Handling
  • 20.11 Building Custom Container Views
  • 20.12 Working with the Label View
  • 20.13 Summary
• 21. SwiftUI Stacks and Frames
  • 21.1 SwiftUI Stacks
  • 21.2 Spacers, Alignment and Padding
  • 21.3 Container Child Limit
  • 21.4 Text Line Limits and Layout Priority
  • 21.5 Traditional vs. Lazy Stacks
  • 21.6 SwiftUI Frames
  • 21.7 Frames and the Geometry Reader
  • 21.8 Summary
• 22. SwiftUI State Properties, Observable, State and Environment Objects
  • 22.1 State Properties
  • 22.2 State Binding
  • 22.3 Observable Objects
  • 22.4 State Objects
  • 22.5 Environment Objects
  • 22.6 Summary
• 23. A SwiftUI Example Tutorial
  • 23.1 Creating the Example Project
  • 23.2 Reviewing the Project
  • 23.3 Adding a VStack to the Layout
  • 23.4 Adding a Slider View to the Stack
  • 23.5 Adding a State Property
  • 23.6 Adding Modifiers to the Text View
  • 23.7 Adding Rotation and Animation
  • 23.8 Adding a TextField to the Stack
  • 23.9 Adding a Color Picker
  • 23.10 Tidying the Layout
  • 23.11 Summary
• 24. SwiftUI Lifecycle Event Modifiers
  • 24.1 Creating the LifecycleDemo Project
  • 24.2 Designing the App
  • 24.3 The onAppear and onDisappear Modifiers
  • 24.4 The onChange Modifier
  • 24.5 ScenePhase and the onChange Modifier
  • 24.6 Summary
• 25. SwiftUI Observable and Environment Objects A Tutorial
  • 25.1 About the ObservableDemo Project
  • 25.2 Creating the Project
  • 25.3 Adding the Observable Object
  • 25.4 Designing the ContentView Layout
  • 25.5 Adding the Second View
  • 25.6 Adding Navigation
  • 25.7 Using an Environment Object
  • 25.8 Summary
• 26. SwiftUI Data Persistence using AppStorage and SceneStorage
  • 26.1 The @SceneStorage Property Wrapper
  • 26.2 The @AppStorage Property Wrapper
  • 26.3 Creating and Preparing the StorageDemo Project
  • 26.4 Using Scene Storage
  • 26.5 Using App Storage
  • 26.6 Storing Custom Types
  • 26.7 Summary
• 27. SwiftUI Stack Alignment and Alignment Guides
  • 27.1 Container Alignment
  • 27.2 Alignment Guides
  • 27.3 Using the Alignment Guides Tool
  • 27.4 Custom Alignment Types
  • 27.5 Cross Stack Alignment
  • 27.6 ZStack Custom Alignment
  • 27.7 Summary
• 28. SwiftUI Lists and Navigation
  • 28.1 SwiftUI Lists
  • 28.2 SwiftUI Dynamic Lists
  • 28.3 SwiftUI NavigationView and NavigationLink
  • 28.4 Making the List Editable
  • 28.5 Hierarchical Lists
  • 28.6 Summary
• 29. A SwiftUI List and Navigation Tutorial
  • 29.1 About the ListNavDemo Project
  • 29.2 Creating the ListNavDemo Project
  • 29.3 Preparing the Project
  • 29.4 Adding the Car Structure
  • 29.5 Loading the JSON Data
  • 29.6 Adding the Data Store
  • 29.7 Designing the Content View
  • 29.8 Designing the Detail View
  • 29.9 Adding Navigation to the List
  • 29.10 Designing the Add Car View
  • 29.11 Implementing Add and Edit Buttons
  • 29.12 Adding the Edit Button Methods
  • 29.13 Summary
• 30. An Overview of List, OutlineGroup and DisclosureGroup
  • 30.1 Hierarchical Data and Disclosures
  • 30.2 Hierarchies and Disclosure in SwiftUI Lists
  • 30.3 Using OutlineGroup
  • 30.4 Using DisclosureGroup
  • 30.5 Summary
• 31. A SwiftUI List, OutlineGroup and DisclosureGroup Tutorial
  • 31.1 About the Example Project
  • 31.2 Creating the OutlineGroupDemo Project
  • 31.3 Adding the Data Structure
  • 31.4 Adding the List View
  • 31.5 Testing the Project
  • 31.6 Using the Sidebar List Style
  • 31.7 Using OutlineGroup
  • 31.8 Working with DisclosureGroups
  • 31.9 Summary
• 32. Building SwiftUI Grids with LazyVGrid and LazyHGrid
  • 32.1 SwiftUI Grids
  • 32.2 GridItems
  • 32.3 Creating the GridDemo Project
  • 32.4 Working with Flexible GridItems
  • 32.5 Adding Scrolling Support to a Grid
  • 32.6 Working with Adaptive GridItems
  • 32.7 Working with Fixed GridItems
  • 32.8 Using the LazyHGrid View
  • 32.9 Summary
• 33. Building Tabbed and Paged Views in SwiftUI
  • 33.1 An Overview of SwiftUI TabView
  • 33.2 Creating the TabViewDemo App
  • 33.3 Adding the TabView Container
  • 33.4 Adding the Content Views
  • 33.5 Adding View Paging
  • 33.6 Adding the Tab Items
  • 33.7 Adding Tab Item Tags
  • 33.8 Summary
• 34. Building Context Menus in SwiftUI
  • 34.1 Creating the ContextMenuDemo Project
  • 34.2 Preparing the Content View
  • 34.3 Adding the Context Menu
  • 34.4 Testing the Context Menu
  • 34.5 Summary
• 35. Basic SwiftUI Graphics Drawing
  • 35.1 Creating the DrawDemo Project
  • 35.2 SwiftUI Shapes
  • 35.3 Using Overlays
  • 35.4 Drawing Custom Paths and Shapes
  • 35.5 Drawing Gradients
  • 35.6 Summary
• 36. SwiftUI Animation and Transitions
  • 36.1 Creating the AnimationDemo Example Project
  • 36.2 Implicit Animation
  • 36.3 Repeating an Animation
  • 36.4 Explicit Animation
  • 36.5 Animation and State Bindings
  • 36.6 Automatically Starting an Animation
  • 36.7 SwiftUI Transitions
  • 36.8 Combining Transitions
  • 36.9 Asymmetrical Transitions
  • 36.10 Summary
• 37. Working with Gesture Recognizers in SwiftUI
  • 37.1 Creating the GestureDemo Example Project
  • 37.2 Basic Gestures
  • 37.3 The onChange Action Callback
  • 37.4 The updating Callback Action
  • 37.5 Composing Gestures
  • 37.6 Summary
• 38. Creating a Customized SwiftUI ProgressView
  • 38.1 ProgressView Styles
  • 38.2 Creating the ProgressViewDemo Project
  • 38.3 Adding a ProgressView
  • 38.4 Using the Circular ProgressView Style
  • 38.5 Declaring an Indeterminate ProgressView
  • 38.6 ProgressView Customization
  • 38.7 Summary
• 39. An Overview of SwiftUI DocumentGroup Scenes
  • 39.1 Documents in Apps
  • 39.2 Creating the DocDemo App
  • 39.3 The DocumentGroup Scene
  • 39.4 Declaring File Type Support
    • 39.4.1 Document Content Type Identifier
    • 39.4.2 Handler Rank
    • 39.4.3 Type Identifiers
    • 39.4.4 Filename Extensions
    • 39.4.5 Custom Type Document Content Identifiers
    • 39.4.6 Exported vs. Imported Type Identifiers
  • 39.5 Configuring File Type Support in Xcode
  • 39.6 The Document Structure
  • 39.7 The Content View
  • 39.8 Running the Example App
  • 39.9 Summary
• 40. A SwiftUI DocumentGroup Tutorial
  • 40.1 Creating the ImageDocDemo Project
  • 40.2 Modifying the Info.plist File
  • 40.3 Adding an Image Asset
  • 40.4 Modifying the ImageDocDemoDocument.swift File
  • 40.5 Designing the Content View
  • 40.6 Filtering the Image
  • 40.7 Testing the App
  • 40.8 Summary
• 41. An Introduction to SiriKit
  • 41.1 Siri and SiriKit
  • 41.2 SiriKit Domains
  • 41.3 Siri Shortcuts
  • 41.4 SiriKit Intents
  • 41.5 How SiriKit Integration Works
  • 41.6 Resolving Intent Parameters
  • 41.7 The Confirm Method
  • 41.8 The Handle Method
  • 41.9 Custom Vocabulary
  • 41.10 The Siri User Interface
  • 41.11 Summary
• 42. A SwiftUI SiriKit Messaging Extension Tutorial
  • 42.1 Creating the Example Project
  • 42.2 Enabling the Siri Entitlement
  • 42.3 Seeking Siri Authorization
  • 42.4 Adding the Intents Extension
  • 42.5 Supported Intents
  • 42.6 Trying the Example
  • 42.7 Specifying a Default Phrase
  • 42.8 Reviewing the Intent Handler
  • 42.9 Summary
• 43. Customizing the SiriKit Intent User Interface
  • 43.1 Adding the Intents UI Extension
  • 43.2 Modifying the UI Extension
  • 43.3 Using the configure Method
  • 43.4 Using the configureView Method
  • 43.5 Designing the Siri Snippet
  • 43.6 Implementing a configureView Method
  • 43.7 Testing the Extension
  • 43.8 Summary
• 44. A SwiftUI SiriKit NSUserActivity Tutorial
  • 44.1 About the SiriKit Photo Search Project
  • 44.2 Creating the SiriPhoto Project
  • 44.3 Enabling the Siri Entitlement
  • 44.4 Seeking Siri Authorization
  • 44.5 Adding an Image Asset
  • 44.6 Adding the Intents Extension to the Project
  • 44.7 Reviewing the Default Intents Extension
  • 44.8 Modifying the Supported Intents
  • 44.9 Modifying the IntentHandler Implementation
  • 44.10 Implementing the Resolve Methods
  • 44.11 Implementing the Confirmation Method
  • 44.12 Handling the Intent
  • 44.13 Testing the App
  • 44.14 Adding a Data Class to SiriPhoto
  • 44.15 Designing the Content View
  • 44.16 Adding Supported Activity Types to SiriPhoto
  • 44.17 Handling the NSUserActivity Object
  • 44.18 Testing the Completed App
  • 44.19 Summary
• 45. An Overview of Siri Shortcut App Integration
  • 45.1 An Overview of Siri Shortcuts
  • 45.2 An Introduction to the Intent Definition File
  • 45.3 Automatically Generated Classes
  • 45.4 Donating Shortcuts
  • 45.5 The Add to Siri Button
  • 45.6 Summary
• 46. A SwiftUI Siri Shortcut Tutorial
  • 46.1 About the Example App
  • 46.2 App Groups and UserDefaults
  • 46.3 Preparing the Project
  • 46.4 Running the App
  • 46.5 Enabling Siri Support
  • 46.6 Seeking Siri Authorization
  • 46.7 Adding the Intents Extension
  • 46.8 Adding the SiriKit Intent Definition File
  • 46.9 Adding the Intent to the App Group
  • 46.10 Configuring the SiriKit Intent Definition File
  • 46.11 Adding Intent Parameters
  • 46.12 Declaring Shortcut Combinations
  • 46.13 Configuring the Intent Response
  • 46.14 Configuring Target Membership
  • 46.15 Modifying the Intent Handler Code
  • 46.16 Adding the Confirm Method
  • 46.17 Donating Shortcuts to Siri
  • 46.18 Testing the Shortcuts
  • 46.19 Designing the Intent UI
  • 46.20 Summary
• 47. Building Widgets with SwiftUI and WidgetKit
  • 47.1 An Overview of Widgets
  • 47.2 The Widget Extension
  • 47.3 Widget Configuration Types
  • 47.4 Widget Entry View
  • 47.5 Widget Timeline Entries
  • 47.6 Widget Timeline
  • 47.7 Widget Provider
  • 47.8 Reload Policy
  • 47.9 Relevance
  • 47.10 Forcing a Timeline Reload
  • 47.11 Widget Sizes
  • 47.12 Widget Placeholder
  • 47.13 Summary
• 48. A SwiftUI WidgetKit Tutorial
  • 48.1 About the WidgetDemo Project
  • 48.2 Creating the WidgetDemo Project
  • 48.3 Building the App
  • 48.4 Adding the Widget Extension
  • 48.5 Adding the Widget Data
  • 48.6 Creating Sample Timelines
  • 48.7 Adding Image and Color Assets
  • 48.8 Designing the Widget View
  • 48.9 Modifying the Widget Provider
  • 48.10 Configuring the Placeholder View
  • 48.11 Previewing the Widget
  • 48.12 Summary
• 49. Supporting WidgetKit Size Families
  • 49.1 Supporting Multiple Size Families
  • 49.2 Adding Size Support to the Widget View
  • 49.3 Summary
• 50. A SwiftUI WidgetKit Deep Link Tutorial
  • 50.1 Adding Deep Link Support to the Widget
  • 50.2 Adding Deep Link Support to the App
  • 50.3 Testing the Widget
  • 50.4 Summary
• 51. Adding Configuration Options to a WidgetKit Widget
  • 51.1 Modifying the Weather Data
  • 51.2 Configuring the Intent Definition
  • 51.3 Modifying the Widget
  • 51.4 Testing Widget Configuration
  • 51.5 Customizing the Configuration Intent UI
  • 51.6 Summary
• 52. Integrating UIViews with SwiftUI
  • 52.1 SwiftUI and UIKit Integration
  • 52.2 Integrating UIViews into SwiftUI
  • 52.3 Adding a Coordinator
  • 52.4 Handling UIKit Delegation and Data Sources
  • 52.5 An Example Project
  • 52.6 Wrapping the UIScrolledView
  • 52.7 Implementing the Coordinator
  • 52.8 Using MyScrollView
  • 52.9 Summary
• 53. Integrating UIViewControllers with SwiftUI
  • 53.1 UIViewControllers and SwiftUI
  • 53.2 Creating the ViewControllerDemo project
  • 53.3 Wrapping the UIImagePickerController
  • 53.4 Designing the Content View
  • 53.5 Completing MyImagePicker
  • 53.6 Completing the Content View
  • 53.7 Testing the App
  • 53.8 Summary
• 54. Integrating SwiftUI with UIKit
  • 54.1 An Overview of the Hosting Controller
  • 54.2 A UIHostingController Example Project
  • 54.3 Adding the SwiftUI Content View
  • 54.4 Preparing the Storyboard
  • 54.5 Adding a Hosting Controller
  • 54.6 Configuring the Segue Action
  • 54.7 Embedding a Container View
  • 54.8 Embedding SwiftUI in Code
  • 54.9 Summary
• 55. Preparing and Submitting an iOS 14 Application to the App Store
  • 55.1 Verifying the iOS Distribution Certificate
  • 55.2 Adding App Icons
  • 55.3 Assign the Project to a Team
  • 55.4 Archiving the Application for Distribution
  • 55.5 Configuring the Application in App Store Connect
  • 55.6 Validating and Submitting the Application
  • 55.7 Configuring and Submitting the App for Review
• Index

pokaż cały spis treści

ukryj recenzje