Mastering IOS 14 programming build professional-grade IOS 14 applications with Swift 5. 3 and Xcode 12. 4
Mastering iOS 14 Programming is the fourth book in the Mastering iOS series, which started back in 2016 with iOS 10. In this latest edition, you'll learn how to build robust iOS apps by harnessing advanced techniques and making the best use of iOS 14's features.
| Otros Autores: | , , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
London, England :
Packt Publishing, Limited
[2021]
|
| Edición: | Fourth edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631731606719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- Contributors
- Table of Contents
- Preface
- Chapter 1: What's New in iOS 14?
- Technical requirements
- Introducing App Clips
- App Clip user journey
- App Clips invocation methods
- App Clips guidelines
- Introducing WidgetKit
- Widgets options
- Widget guidelines
- Improvements in augmented reality
- Improvements in machine learning
- Core ML Model Deployment, collections, and targeted deployments
- Model encryption
- Improvements in user privacy
- Introducing Swift 5.2
- Key path expressions as functions
- Callable values of user-defined nominal types
- Subscripts can now declare default arguments
- Lazy filtering order is now reversed
- New and improved diagnostics
- Introducing Swift 5.3
- Multi-pattern catch clauses
- Multiple trailing closures
- Synthesized comparable conformance for enum types
- Increase availability of implicit self in escaping closures when reference cycles are unlikely to occur
- Type-based program entry points - @main
- Use where clauses on contextually generic declarations
- Enum cases as protocol witnesses
- Refine didSet semantics
- Float16
- Summary
- Further reading
- Chapter 2: Working with Dark Mode
- Technical requirements
- What is Dark Mode?
- Understanding why we would need Dark Mode
- Core developer concepts of Dark Mode
- Dark mode from inside Xcode
- Working with views in Dark Mode
- What are adaptive colors?
- What are semantic colors?
- Using the programmatic approach
- Working with the asset catalog for Dark Mode
- Using custom adaptive colors
- Using custom adaptive images
- Further exploring Dark Mode
- Using Dark Mode with SwiftUI
- Programatically handling changes with trait collection
- Specifying an appearance for views, ViewControllers, and windows
- Accessibility in Dark Mode
- Summary.
- Further reading
- Chapter 3: Using Lists and Tables
- Technical requirements
- Working with UITableView
- Setting up the project
- Fetching contacts data
- Prepping UITableView to display our contacts
- Understanding protocols and delegation
- Conforming to the UITableView protocols
- Understanding the custom UITableViewCell override and the reuse identifier
- Exploring UITableView further
- Further understanding reuse identifiers
- Prefetching in table views
- Cell selection in table views
- Working with UICollectionView
- Setting up our collection view
- Implementing layout with UICollectionViewDelegateFlowLayout
- Exploring UICollectionView further
- Implementing a custom UICollectionViewLayout
- Cell selection in collection views
- Working with lists in SwiftUI
- Creating our first SwiftUI project
- Building a list in SwiftUI
- The equivalent to creating a custom cell in SwiftUI
- Summary
- Further reading
- Chapter 4: Creating a Detail Page
- Technical requirements
- Implementing navigation with segues
- Creating our new details view
- Implementing and understanding segues
- Creating a manual segue
- Creating our layouts with UIStackView
- Containing labels in a stack view
- Passing data between view controllers
- Updating the data loading
- Passing the model to the details page
- Updating our outlets
- Best practices - creating a view model
- Summary
- Further reading
- Chapter 5: Immersing Your Users with Animation
- Technical requirements
- Using UIView.animate and UIViewPropertyAnimator
- Creating our first animation
- Working with multiple animations
- Refactoring with UIViewPropertyAnimator
- Understanding and controlling animation progress
- Interactions with a pan gesture recognizer
- Adding vibrancy to animations
- Adding dynamism with UIKit Dynamics.
- Customizing view controller transitions
- Implementing a custom modal presentation transition
- Summary
- Chapter 6: Understanding the Swift Type System
- Technical requirements
- Understanding available types in Swift
- Working with reference types
- Working with value types
- Understanding structs
- Understanding enums
- Understanding differences in types
- Comparing value types to reference types
- Differences in usage
- Deciding which type to use
- When should I use a reference type?
- When to use a value type
- Summary
- Chapter 7: Flexible Code with Protocols, Generics, and Extensions
- Technical requirements
- Understanding and implementing protocols
- Defining your own protocols
- Checking for traits instead of types
- Extending your protocols with default behavior
- Improving your protocols with associated types
- Adding flexibility with generics
- Summary
- Chapter 8: Adding Core Data to Your App
- Technical requirements
- Understanding the Core Data stack
- Adding Core Data to an existing application
- Creating a Core Data model
- Creating the models
- Defining relationships
- Using your entities
- Persisting data and reacting to data changes
- Understanding data persistence
- Persisting your models
- Refactoring the persistence code
- Reading data with a simple fetch request
- Filtering data with predicates
- Reacting to database changes
- Understanding the use of multiple instances of NSManagedObjectContext
- Refactoring the persisting code
- Summary
- Further reading
- Chapter 9: Fetching and Displaying Data from the Network
- Technical requirements
- Fetching data from the web with URLSession
- Understanding the basics of URLSession
- Working with JSON in Swift
- Updating Core Data objects with fetched data
- Implementing the fetch logic
- Updating a movie with a popularity rating.
- Visualizing multiple threads
- Summary
- Chapter 10: Making Smarter Apps with Core ML
- Technical requirements
- Understanding machine learning and Core ML
- Understanding what machine learning is
- Understanding Core ML
- Combining Core ML and computer vision
- Understanding the Vision framework
- Implementing an image classifier
- Training your own models with Create ML
- Training a Natural Language model
- Training a Vision model
- Updating models remotely with Model Deployment
- Using the Core ML API to retrieve collections of models
- Preparing and deploying the model
- Encrypting Core ML models
- Summary
- Chapter 11: Adding Media to Your App
- Technical requirements
- Playing audio and video
- Creating a simple video player
- Creating an audio player
- Playing media in the background
- Recording video and taking pictures
- Taking and storing a picture
- Recording and storing video
- Manipulating photos with Core Image
- Summary
- Chapter 12: Improving Apps with Location Services
- Technical requirements
- Requesting a user's location
- Asking for permission to access location data
- Obtaining a user's location
- Subscribing to location changes
- Setting up geofences
- Summary
- Chapter 13: Working with the Combine Framework
- Technical requirements
- Understanding the Combine framework
- Understanding Publisher
- Understanding Subscriber
- Understanding Operators
- Understanding Subject
- Combining Publishers, Subscribers, and Operators
- Using Operators to build error-proof streams
- Summary
- Chapter 14: Creating an App Clip for Your App
- Technical requirements
- Introducing App Clips
- App Clip User Journey
- App Clips Invocation Methods
- Developing your first App Clip
- Creating the App Clip's Target
- Sharing resources and code with the App Clip
- Using Active Compilation Conditions.
- Configuring, linking, and triggering your App Clip
- Testing your App Clip Experiences
- Summary
- Chapter 15: Recognition with Vision Framework
- Technical requirements
- Introduction to the Vision framework
- Recognizing text in images
- Region of interest
- Recognizing hand landmarks in real time
- Understanding hand landmarks
- Implementing hand detection
- Summary
- Chapter 16: Creating Your First Widget
- Technical requirements
- Introducing widgets and WidgetKit
- Widget options
- Widget guidelines
- Developing your first widget
- Creating a widget extension
- Implementing multiple-size widgets
- Providing the widget with data and configuration
- Refreshing the widget's data
- Summary
- Chapter 17: Using Augmented Reality
- Understanding ARKit
- Understanding how ARKit renders content
- Understanding how ARKit tracks the physical environment
- Using ARKit Quick Look
- Implementing the ARKit Quick Look view controller
- Exploring SpriteKit
- Creating a SpriteKit scene
- Exploring SceneKit
- Creating a basic SceneKit scene
- Implementing an Augmented Reality gallery
- Adding image tracking
- Preparing images for tracking
- Building the image tracking experience
- Placing your own content in 3D space
- Summary
- Chapter 18: Creating a macOS app with Catalyst
- Technical requirements
- Discovering Mac Catalyst
- Exploring new Mac Catalyst features
- Building your first Mac Catalyst app
- Exploring the iPad app
- Scaling your iPad app for Mac
- Optimizing your iPad app for Mac
- Summary
- Chapter 19: Ensuring App Quality with Tests
- Testing logic with XCTest
- Understanding what it means to test code
- Setting up a test suite with XCTest
- Optimizing code for testability
- Introducing the question loader
- Mocking API responses
- Using models for consistency.
- Gaining insights through code coverage.
