iOS 13 programming for beginners : get started with building iOS apps with Swift 5 and Xcode 11

Title Page
Copyright and Credits
About Packt
Contributors
Table of Contents
Preface
Section1: Swift
Getting Familiar with Xcode
	Technical requirements
	Downloading and installing Xcode from the App Store
	Understanding the Xcode user interface
	Running the app in the Simulator
		Understanding the No Device and Build Only Device menu items
	Using an iOS 13 device for development
		Trusting the Developer App certificate on your iOS device
		Connecting an iOS device wirelessly
	Summary
Simple Values and Types
	Technical requirements
	Understanding Swift playgrounds
		Customizing fonts and colors
	Exploring data types
		Storing integers
		Storing floating-point numbers
		Storing Booleans
		Storing strings
		Using common data types in the playground
	Exploring constants and variables
	Understanding type inference and type safety
		Using type annotation to specify a type
		Type safety
	Exploring operators
		Using arithmetic operators
		Using compound assignment operators
		Using comparison operators
		Using logical operators
		Performing string operations
	Using the print() instruction
	Summary
Conditionals and Optionals
	Technical requirements
	Introducing conditionals
		Using if statements
		Using switch statements
	Introducing optionals
		Using optionals and optional binding
	Summary
Range Operators and Loops
	Technical requirements
	Range operators
	Loops
		The for-in loop
		The while loop
		The repeat-while loop
	Summary
Collection Types
	Technical requirements
	Understanding arrays
		Creating an array
		Checking the number of elements in an array
		Adding a new item to an array
		Accessing an array element
		Assigning a new value to an index
		Removing an item from an array
		Iterating over an array
	Understanding dictionaries
		Creating a dictionary
		Checking the number of elements in a dictionary
		Adding a new item to a dictionary
		Accessing a dictionary element
		Assigning a new value to a key
		Removing an item from a dictionary
		Iterating over a dictionary
	Understanding sets
		Creating a set
		Checking the number of elements in a set
		Adding a new item to a set
		Checking whether a set contains an item
		Removing an item from a set
		Iterating over a set
		Set operations
		Set membership and equality
	Summary
Functions and Closures
	Technical requirements
	Understanding functions
		Creating a function
		Using custom argument labels
		Using nested functions
		Using functions as return types
		Using functions as parameters
		Using a guard statement to exit a function early
	Understanding closures
		Simplifying closures
	Summary
Classes, Structures, and Enumerations
	Technical requirements
	Understanding classes
		Creating a class declaration
		Making an instance of the class
		Making a subclass
		Overriding a superclass method
	Understanding structures
		Creating a structure declaration
		Making an instance of the struct
		Value types versus references types
		Deciding which to use
	Understanding enumerations
		Creating an enumeration
	Summary
Protocols, Extensions, and Error Handling
	Technical requirements
	Understanding protocols
		Creating a protocol declaration
	Understanding extensions
		Adopting a protocol via an extension
		Creating an array of different types of objects
	Exploring error handling
	Summary
Section 2: Design
Setting Up the Basic Structure
	Technical requirements
	Useful terms
	Touring the Let's Eat app
		Using the Explore screen
		Using the Locations screen
		Using the Restaurant List screen
		Using the Restaurant Detail screen
		Using the Review Form screen
		Using the Map screen
	Creating a new Xcode project
	Setting up a Tab Bar Controller Scene and Launch screen 
		Setting the titles of the Tab Bar's buttons 
		Embedding view controllers in navigation controllers
		Adding the Assets.xcassets file
		Configuring the Launch screen's background color
		Adding a logo and constraints to the Launch screen
		Adding the icons for the Explore and Map buttons
	Summary
Building Your App Structure in Storyboard
	Technical requirements
	Adding a collection view to the Explore screen
		Adding a Cocoa Touch Class file to your project
	Connecting outlets in storyboard to the view controller
	Configuring data source methods for the collection view
		Setting the delegate and data source properties of the collection view
		Adopting the UICollectionViewDataSource and UICollectionViewDelegate protocols
	Adding a section header to the collection view
	Creating a custom color
	Configuring the collection view cell and section header size
	Presenting a view modally
		Adding a button to the collection view header
		Adding a new view controller scene
		Adding the Cancel and Done buttons to the navigation bar
	Summary
Finishing Up Your App Structure in Storyboard
	Technical requirements
	Adding a table view to the Locations screen
	Implementing the Restaurant List screen
		Declaring the RestaurantListViewController class
		Adopting the delegate and data source protocols
		Presenting the Restaurant List screen
	Implementing the Restaurant Detail screen
	Implementing the Review Form screen
	Implementing the Map screen
	Summary
Modifying and Configuring Cells
	Technical requirements
	Modifying the Explore screen section header
		Adding Auto Layout to the Explore screen's section header
	Modifying the exploreCell collection view cell
	Modifying the restaurantCell collection view cell
		Adding Auto Layout constraints to the restaurantCell collection view cell
	Configuring the locationCell table view cell
	Summary
Section 3: Code
Getting Started with MVC and Collection Views
	Technical requirements
	Understanding the MVC design pattern
	Exploring controllers and classes
		Understanding collection views
		Revisiting the Explore and Restaurant List screens
	Summary
Getting Data into Collection Views
	Technical requirements
	Understanding model objects
		Understanding .plist files
		Creating a structure to represent a cuisine
		Implementing a data manager class to read data from a .plist
		Using the data manager to initialize ExploreItem instances
	Displaying data in a collection view
		Connecting the outlets in exploreCell
		Implementing additional data manager methods
		Updating the data source methods in ExploreViewController
	Summary
Getting Started with Table Views
	Technical requirements
	Understanding table views
	Creating LocationViewController
		Connecting the table view to LocationViewController
		Adding the data source and delegate methods
	Adding location data for the table view
		Creating a property list (.plist) file
		Adding data to the .plist file
	Creating LocationDataManager
		Displaying data in a table view using LocationDataManager
	Cleaning up the user interface
	Summary
Getting Started with MapKit
	Technical requirements
	Understanding and creating annotations
		Introducing MKAnnotation
		Creating the RestaurantItem class
		Creating MapDataManager
		Creating the DataManager protocol
		Refactoring MapDataManager
		Refactoring ExploreDataManager
	Adding annotations to a map view
		Creating MapViewController
		Connecting the outlets for the map view to MapViewController
		Setting the map view region to be displayed
		Displaying annotations on the map view
		Creating custom annotations
	Going from the Map screen to the Restaurant Detail screen 
		Creating and configuring a storyboard reference
		Performing the showDetail segue
		Passing data to the Restaurant Detail screen
	Organizing your code
		Refactoring ExploreViewController
		Using the // MARK: syntax
		Refactoring RestaurantListViewController
		Refactoring LocationViewController
		Refactoring MapViewController
	Summary
Getting Started with JSON Files
	Technical requirements
	Getting data from JSON files
		What is an API?
		Understanding the JSON format
		Creating RestaurantAPIManager
	Using data from JSON files in your app
		Storing a user-selected location in LocationViewController
		Adding a view controller for the section header in the Explore screen
		Connecting the section header's label to ExploreViewController
		Adding an unwind action method to the Done button
		Selecting only one location in the Location screen
		Passing location and cuisine information to RestaurantListViewController
		Creating a view controller for the cells on the Restaurant List screen
		Connecting the outlets for RestaurantCell
		Creating RestaurantDataManager
		Configuring MapDataManager to use RestaurantDataManager
		Displaying a custom UIView to indicate no data available
		Displaying a list of restaurants on the Restaurant List screen
	Summary
Displaying Data in a Static Table View
	Technical requirements
	Setting up outlets for RestaurantDetailViewController
	Displaying data in the static table view
	Passing data from RestaurantListViewController to RestaurantDetailViewController
	Summary
Getting Started with Custom UIControls
	Technical requirements
	Creating a custom UIControl object
	Displaying stars in your custom UIControl object
	Adding support for touch events
	Implementing an unwind method for the Cancel button
	Creating ReviewFormViewController
	Summary
Getting Started with Cameras and Photo Libraries
	Technical requirements
	Understanding filters
	Creating a scrolling list of filters
		Creating a view controller for the filter cell
		Creating a View Controller for the Photo Filter screen
	Getting permission to use the camera or photo library
	Summary
Understanding Core Data
	Technical requirements
	Introducing Core Data
	Implementing Core Data components for your app
		Creating a data model
		Creating ReviewItem
		Creating RestaurantPhotoItem
		Creating a Core Data manager
	Creating ReviewDataManager
	Summary
Saving and Loading from Core Data
	Technical requirements
	Understanding how saving and loading works
		Adding a restaurantID property to RestaurantItem
	Updating ReviewFormViewController to save reviews
		Passing RestaurantID to ReviewFormViewController
	Updating PhotoFilterViewController to save photos
	Displaying saved reviews and photos on the Restaurant Detail screen
	Calculating a restaurant's overall rating
	Summary
Section 4: Features
Getting Started with Dark Mode
	Technical requirements
	Turning on Dark Mode in the simulator
	Updating the Launch screen to work with Dark Mode
	Updating the Explore screen to work with Dark Mode
	Updating the Restaurant List screen to work with Dark Mode
	Updating the Restaurant Detail screen to work with Dark Mode
		Updating the Reviews View Controller scene and NoDataView to work with Dark Mode
		Updating the Photo Reviews View Controller Scene to work with Dark Mode
	Summary
Getting Started with Mac Catalyst
	Technical requirements
	Cleaning up the design
	Updating the app to work on iPad
		Checking device type
		Updating ExploreViewController for iPad
		Updating RestaurantListViewController for iPad
		Updating the Restaurant Detail screen for iPad
	Updating the app to work on macOS
	Summary
Getting Started with SwiftUI
	Technical requirements
	Creating a SwiftUI project
	Working with text
	Combining Views using Stacks
	Working with images
	Using UIKit and SwiftUI Views together
	Composing the Restaurant Detail screen
	Summary
Getting Started with Sign In with Apple
	Technical requirements
	Adding a login screen
	Displaying a Sign in with Apple button
	Implementing delegate methods and button actions
	Passing user information to ExploreViewController
	Summary
Testing and Submitting Your App to the App Store
	Technical requirements
	Getting an Apple Developer account
	Generating a certificate signing request
	Creating development and distribution certificates
	Registering an App ID
	Registering your devices
	Creating provisioning profiles
	Creating icons for your app
	Creating screenshots for your app
	Creating an App Store listing
	Creating an archive build
	Completing the information in App Store Connect
	Testing your app
		Testing your app internally
		Testing your app externally
	Summary
Other Books You May Enjoy
Index