Mastering iOS 18 Development

Name: Mastering iOS 18 Development | Take your iOS development experience to the next level with iOS, Xcode, Swift, and SwiftUI
Brand: Packt Publishing
Price: 31.19 EUR
Availability: OnlineOnly

Take your iOS development experience to the next level with iOS, Xcode, Swift, and SwiftUI

Avi Tsadok(Autor*in)

Packt Publishing

1. Auflage

Erschienen am 8. November 2024

418 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-1-83546-327-7 (ISBN)

31,19 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Part 1: Getting Started with iOS 18 Development
Chapter 1: What's New in iOS 18
Technical requirements
Understanding iOS 18 background
Introducing Swift Testing
Introducing Swift Data Improvements
Unique value
History API
Custom data stores in Swift Data
Introducing zoom transition
Adding a floating tab bar
Having more control over scroll views
Observing the scroll view position
Observing items' visibility
Changing the text rendering behavior
Positioning sub-views from another view
Entering the AI revolution
Summary
Chapter 2: Simplifying Our Entities with SwiftData
Technical requirements
Understanding SwiftData's background
Defining a SwiftData model
Expanding the @Model macro
Adding relationships
SwiftData relationship deletion rules
Defining the inverse relationship
Adding the @Attribute macro
Going non-persistent with transient
Exploring the container
Setting up ModelContainer
Connecting the container using the modelContainer modifier
Working with ModelConfiguration
Fetching and manipulating our data using model context
Saving new objects
Fetching objects
Migrating our data to a new schema
Learning the basic migration process
Creating a version schema
Creating the migration stages and plan
Connecting the migration plan to our container
Summary
Chapter 3: Understanding SwiftUI Observation
Technical requirements
Going over the SwiftUI observation system
Conforming to the ObservableObject protocol
Explaining the problem with the current observation situation
Adding the @Observable macro
Learning how the @Observable macro works
Excluding properties from observation using @ObservationIgnored
Observing computed variables
Working with environment variables
Adding an environment variable by type
Adding environment variable by key
Binding objects using @Bindable
Migrating to Observable
Summary
Chapter 4: Advanced Navigation with SwiftUI
Technical requirements
Understating why SwiftUI navigation is a challenge
Exploring NavigationStack
Separating the navigation destination using the navigationDestination view modifier
Using data models to trigger navigation
Responding to the path variable
Working with different types of data using NavigationPath
Working with the Coordinator pattern
Understanding the Coordinator's principles
Building the Coordinator object
Adding CoordinatorView
Calling the coordinator straight from the view
Navigating with columns with NavigationSplitView
Creating NavigationSplitView
Moving to three columns
Summary
Chapter 5: Enhancing iOS Applications with WidgetKit
Technical requirements
The idea of widgets
Understanding how widgets work
Adding a widget
Configuring our widget
Working with static configuration
Understanding the Timeline Provider for Widgets
Building our widget UI
Working with timeline entries
Adding animations
Customize our widget
Using the AppEntity in our Widget
Keeping our widgets up to date
Reload widgets using the WidgetCenter
Go to the network for updates
Interacting with our widget
Opening a specific screen using links
Adding interactive capabilities
Adding a control widget
Summary
Chapter 6: SwiftUI Animations and SF Symbols
Technical requirements
The importance of animations
Understanding the concept of SwiftUI animations
Performing basic animations
Using the animation view modifier
Using the withAnimation function
Bringing some life to our animations with spring animations
Performing advanced animations
Performing transitions
Executing keyframe animations
Animating SF Symbols
Modifying symbol colors
Localizing our symbols
Summary
Chapter 7: Improving Feature Exploration with TipKit
Technical requirements
Learning the importance of tips
Understanding the basics of TipKit
What do tips look like?
Adding our first tip
Dismissing tips
Defining the tip ID
Customizing our tips
Customizing our tips' appearance
Adding actions
Adding tips rules
Adding a rule based on a state
Adding a rule based on events
Grouping tips with TipGroup
Customizing display frequency
Setting the max display count for a specific tip
Setting our tips' display frequency
Summary
Chapter 8: Connecting and Fetching Data from the Network
Technical requirements
Understanding mobile networking
Handling an HTTP request
Basic HTTP request methods
Working with URLSession
Handling the response
Integrating network calls within app flows
Just-in-time fetching
Read-through cache
Incremental loading
Full data sync with delta updates
Exploring Networking and Combine
Summary
Chapter 9: Creating Dynamic Graphs with Swift Charts
Technical requirements
Why charts?
Introducing the Swift Charts framework
Creating charts
Creating BarMark chart
Creating LineMark charts
Creating a SectorMark chart
Creating an AreaMark chart
Creating a PointMark chart
Visualizing functions with Charts
Allowing interaction using ChartProxy
Adding an overlay to our chart
Responding to the user's gesture
Finding the closest data point to the user's touch
Conforming to the Plottable protocol
Summary
Part 2: Refine your iOS Development with Advanced Techniques
Chapter 10: Swift Macros
Technical requirements
What is a Swift macro?
Exploring SwiftSyntax
Parsing and AST
Setting up SwiftSyntax
Building our Abstract Syntax Tree
Creating our first Swift macro
Adding a new Swift macro
Examining our Swift Macros package structure
Declaring our macro
Implementing the macro
Handling macros errors
Adding tests
Practice exercises
Summary
Chapter 11: Creating Pipelines with Combine
Technical requirements
Why use Combine?
Going over the basics
Starting with the publisher
Setting up the subscriber
Connecting operators
Delving into Combine components
Creating a custom publisher
Working with Subjects
Creating a custom subscriber
Connecting the custom publisher and subscriber
Working with operators
Learning about Combine using examples
Managing UIKit-based view state in a view model
Performing searches from multiple sources
Validating forms
Summary
Chapter 12: Being Smart with Apple Intelligence and ML
Technical requirements
Going over the basics of AI and machine learning
Learning the differences between AI and machine learning
Delving into the ML model
Training the model
Apple intelligence and ML
Exploring built-in ML frameworks
Interpreting text using NLP
Analyzing images using the Vision framework
Classifying audio using the Sound Analysis framework
Performing a semantic search with Core Spotlight
Integrating custom models using CoreML
Getting to know the Create ML application
Building our Spam Classifier model
Using our model with Core ML
Where to go from here
Summary
Chapter 13: Exposing Your App to Siri with App Intents
Technical requirements
Understanding the App Intents concept
Creating a simple app intent
Running the intent with the Shortcuts app
Creating an app shortcut
Adding a parameter to our app intent
Returning a custom view
Having multiple result types
Adding confirmation and conditions
Formalizing our content using app entities
Conforming to AppEntity
Creating an Open a task intent
Chaining app intents
Integrating our intent to other intents
Adjusting our app intents to work with Apple Intelligence
Exploring the Assistant Schema
Creating AssistantEntity
Summary
Chapter 14: Improving the App Quality with Swift Testing
Technical requirements
Understanding the importance of testing
Learning the testing history in Apple platforms
Exploring the Swift Testing basics
Adding a basic test
Providing names to our test functions
Enabling and disabling tests
Tagging our test functions
Working with arguments
Managing our tests
Going over the testing structure
Grouping our test functions into test suites
Building test plans
Setting up a Scheme
Tips to write testable code
Writing pure functions
Separating your code based on concerns
Performing mocking using protocols
Summary
Chapter 15: Exploring Architectures for iOS
Technical requirements
Understanding the importance of architecture
Learning what exactly architecture is
Going over the different architectures
Separating our project into layers
Separating our project into modules
Combining the multi-layer architecture with modules
Building hexagonal architecture
Comparing the different architectures
By separation of concerns
By testing
By maintenance and scalability
Summary
Index
Other Books You May Enjoy

Systemvoraussetzungen

Als PDF speichern Als Link merken