Difference between revisions of "IOS 8 App Development Essentials"

Learn SwiftUI and take your iOS Development to the Next Level
SwiftUI Essentials – iOS 16 Edition book is now available in Print ($39.99) and eBook ($29.99) editions. Learn more...

1. Start Here
2. Joining the Apple iOS 8 Developer Program
   • Registered Apple Developer
   • Downloading Xcode 6 and the iOS 8 SDK
   • iOS Developer Program
   • When to Enroll in the iOS Developer Program?
   • Enrolling in the iOS Developer Program
     
     
3. Installing Xcode 6 and the iOS 8 SDK
   • Identifying if you have an Intel or PowerPC based Mac
   • Installing Xcode 6 and the iOS 8 SDK
     
     
4. A Guided Tour of Xcode 6
   • Starting Xcode 6
   • Creating the iOS App User Interface
   • Changing Component Properties
   • Adding Objects to the User Interface
   • Building and Running an iOS 8 App in Xcode 6
   • Dealing with Build Errors
   • Monitoring Application Performance
   • An Exploded View of the User Interface Layout Hierarchy
     
     
5. Testing Apps on iOS 8 Devices with Xcode 6
   • Configuring Xcode with Apple IDs
   • Generating Signing Identities
   • Device Registration
   • Manually Adding Test Devices
   • Running an Application on a Registered Device
     
     
6. An Introduction to Swift Playgrounds
   • What is a Swift Playground?
   • Creating a New Swift Playground
   • A Basic Swift Playground Example
   • Playground Timelines
   • Working with UIKit in Playgrounds
   • When to Use Swift Playgrounds
     
     
7. Swift Data Types, Constants and Variables
   • Using a Swift Playground
   • Swift Data Types
   • Integer Data Types
   • Floating Point Data Types
   • Bool Data Type
   • Character Data Type
   • String Data Type
   • Special Characters/Escape Sequences
   • Swift Variables
   • Swift Constants
   • Declaring Constants and Variables
   • Type Annotations and Type Inference
   • Type Casting and Type Checking
   • The Swift Tuple
   • The Swift Optional Type
     
     
8. Swift Operators and Expressions
   • Expression Syntax in Swift
   • The Basic Assignment Operator
   • Swift Arithmetic Operators
   • Compound Assignment Operators
   • Increment and Decrement Operators
   • Comparison Operators
   • Boolean Logical Operators
   • Range Operators
   • The Ternary Operator
   • Bitwise Operators
   • Bitwise NOT
   • Bitwise AND
   • Bitwise OR
   • Bitwise XOR
   • Bitwise Left Shift
   • Bitwise Right Shift
   • Compound Bitwise Operators
     
     
9. Swift Flow Control
   • Looping Flow Control
   • The Swift for Statement
   • The Condition-Increment for Loop
   • The for-in Loop
   • The while Loop
   • The do ... while loop
   • Breaking from Loops
   • The continue Statement
   • Conditional Flow Control
   • Using the if Statement
   • Using if ... else … Statements
   • Using if ... else if ... Statements
     
     
10. The Swift Switch Statement
    • Why Use a switch Statement?
    • Using the switch Statement Syntax
    • A Swift switch Statement Example
    • Combining case Statements
    • Range Matching in a switch Statement
    • Using the where statement
    • Fallthrough
      
      
11. An Overview of Swift Functions and Closures
    • What is a Function?
    • How to Declare a Swift Function
    • Calling a Swift Function
    • Declaring External Parameter Names
    • Declaring Default Function Parameters
    • Returning Multiple Results from a Function
    • Variable Numbers of Function Parameters
    • Parameters as Variables
    • Working with In-Out Parameters
    • Functions as Parameters
    • Closure Expressions
    • Closures in Swift
      
      
12. The Basics of Object Oriented Programming in Swift
    • What is an Object?
    • What is a Class?
    • Declaring a Swift Class
    • Adding Instance Properties to a Class
    • Defining Methods
    • Declaring and Initializing a Class Instance
    • Initializing and Deinitializing a Class Instance
    • Calling Methods and Accessing Properties
    • Stored and Computed Properties
    • Using self in Swift
      
      
13. An Introduction to Swift Inheritance
    • Inheritance, Classes and Subclasses
    • A Swift Inheritance Example
    • Extending the Functionality of a Subclass
    • Overriding Inherited Methods
    • Initializing the Subclass
    • Using the SavingsAccount Class
      
      
14. Working with Array and Dictionary Collections in Swift
    • Mutable and Immutable Collections
    • Swift Array Initialization
    • Working with Arrays in Swift
    • Array Item Count
    • Accessing Array Items
    • Appending Items to an Array
    • Inserting and Deleting Array Items
    • Array Iteration
    • Swift Dictionary Collections
    • Swift Dictionary Initialization
    • Dictionary Item Count
    • Accessing and Updating Dictionary Items
    • Adding and Removing Dictionary Entries
    • Dictionary Iteration
      
      
15. The iOS 8 Application and Development Architecture
    • An Overview of the iOS 8 Operating System Architecture
    • Model View Controller (MVC)
    • The Target-Action pattern, IBOutlets and IBActions
    • Subclassing
    • Delegation
      
      
16. Creating an Interactive iOS 8 App
    • Creating the New Project
    • Creating the User Interface
    • Building and Running the Sample Application
    • Adding Actions and Outlets
    • Building and Running the Finished Application
    • Hiding the Keyboard
      
      
17. Understanding iOS 8 Views, Windows and the View Hierarchy
    • An Overview of Views
    • The UIWindow Class
    • The View Hierarchy
    • View Types
    • The Window
    • Container Views
    • Controls
    • Display Views
    • Text and Web Views
    • Navigation Views and Tab Bars
    • Alert Views
      
      
18. An Introduction to Auto Layout in iOS 8
    • An Overview of Auto Layout
    • Alignment Rects
    • Intrinsic Content Size
    • Content Hugging and Compression Resistance Priorities
    • Three Ways to Create Constraints
    • Constraints in more Detail
      
      
19. Working with iOS 8 Auto Layout Constraints in Interface Builder
    • A Simple Example of Auto Layout in Action
    • Enabling and Disabling Auto Layout in Interface Builder
    • The Auto Layout Features of Interface Builder
    • Suggested Constraints
    • Visual Cues
    • Highlighting Constraint Problems
    • Viewing, Editing and Deleting Constraints
    • Creating New Constraints in Interface Builder
    • Adding Aspect Ratio Constraints
    • Resolving Auto Layout Problems
      
      
20. An iOS 8 Auto Layout Example
    • Preparing the Project
    • Designing the User Interface
    • Adding Auto Layout Constraints
    • Adjusting Constraint Priorities
    • Testing the Application
      
      
21. Implementing iOS 8 Auto Layout Constraints in Swift Code
    • Creating Constraints in Code
    • Adding a Constraint to a View
    • Turning off Auto Resizing Translation
    • An Example Application
    • Creating the Views
    • Creating and Adding the Constraints
    • Removing Constraints
      
      
22. Implementing Cross-Hierarchy Auto Layout Constraints in iOS 8
    • The Example Application
    • Establishing Outlets
    • Writing the Code to Remove the Old Constraint
    • Adding the Cross Hierarchy Constraint
    • Testing the Application
      
      
23. Understanding the iOS 8 Auto Layout Visual Format Language in Swift
    • The Example Application
    • Establishing Outlets
    • Writing the Code to Remove the Old Constraint
    • Adding the Cross Hierarchy Constraint
    • Testing the Application
      
      
24. Using Size Classes to Design Universal iOS User Interfaces
    • Understanding Size Classes
    • Size Classes in Interface Builder
    • Setting “Any” Defaults
    • Working with Size Classes in Interface Builder
    • A Universal User Interface Tutorial
    • Designing the iPad Layout
    • Adding Universal Image Assets
    • Designing the iPhone Layout
    • Adding a Size Class Specific Image File
    • Removing Redundant Constraints
    • Previewing Layouts
    • Testing the Application
      
      
25. Using Storyboards in Xcode 6
    • Creating the Storyboard Example Project
    • Accessing the Storyboard
    • Adding Scenes to the Storyboard
    • Configuring Storyboard Segues
    • Configuring Storyboard Transitions
    • Associating a View Controller with a Scene
    • Passing Data Between Scenes
    • Unwinding Storyboard Segues
    • Triggering a Storyboard Segue Programmatically
      
      
26. Using Xcode 6 Storyboards to Create an iOS 8 Tab Bar Application
    • An Overview of the Tab Bar
    • Understanding View Controllers in a Multiview Application
    • Setting up the Tab Bar Example Application
    • Reviewing the Project Files
    • Adding the View Controllers for the Content Views
    • Adding the Tab Bar Controller to the Storyboard
    • Designing the View Controller User interfaces
    • Configuring the Tab Bar Items
    • Building and Running the Application
      
      
27. An Overview of iOS 8 Table Views and Xcode 6 Storyboards
    • An Overview of the Table View
    • Static vs. Dynamic Table Views
    • The Table View Delegate and dataSource
    • Table View Styles
    • Self-Sizing Table Cells
    • Dynamic Type
    • Table View Cell Styles
    • Table View Cell Reuse
      
      
28. Using Storyboards and Swift to Build Dynamic TableViews with Prototype Table View Cells
    • Creating the Example Project
    • Adding the TableView Controller to the Storyboard
    • Creating the UITableViewController and UITableViewCell Subclasses
    • Declaring the Cell Reuse Identifier
    • Designing a Storyboard UITableView Prototype Cell
    • Modifying the AttractionTableViewCell Class
    • Creating the Table View Datasource
    • Downloading and Adding the Image Files
    • Compiling and Running the Application
      
      
29. Implementing iOS 8 TableView Navigation using Storyboards in Xcode 6 and Swift
    • Understanding the Navigation Controller
    • Adding the New Scene to the Storyboard
    • Adding a Navigation Controller
    • Establishing the Storyboard Segue
    • Modifying the AttractionDetailViewController Class
    • Using prepareForSegue to Pass Data between Storyboard Scenes
    • Testing the Application
      
      
30. An iOS 8 Swift Split View Master-Detail Example
    • An Overview of Split View and Popovers
    • About the Example Split View Project
    • Creating the Project
    • Reviewing the Project
    • Configuring Master View Items
    • Configuring the Detail View Controller
    • Connecting Master Selections to the Detail View
    • Modifying the DetailViewController Class
    • Testing the Application
      
      
31. Implementing a Swift Page based iOS 8 Application using UIPageViewController
    • The UIPageViewController Class
    • The UIPageViewController DataSource
    • Navigation Orientation
    • Spine Location
    • The UIPageViewController Delegate Protocol
      
      
32. An Example Swift iOS 8 UIPageViewController Application
    • The Xcode Page-based Application Template
    • Creating the Project
    • Adding the Content View Controller
    • Creating the Data Model
    • Initializing the UIPageViewController
    • Running the UIPageViewController Application
      
      
33. Working with Directories in Swift on iOS 8
    • The Application Documents Directory
    • The NSFileManager, NSFileHandle and NSData Classes
    • Understanding Pathnames in Swift
    • Obtaining a Reference to the Default NSFileManager Object
    • Identifying the Current Working Directory
    • Identifying the Documents Directory
    • Identifying the Temporary Directory
    • Changing Directory
    • Deleting a Directory
    • Listing the Contents of a Directory
    • Getting the Attributes of a File or Directory
      
      
34. Working with Files in Swift on iOS 8
    • Creating an NSFileManager Instance
    • Checking for the Existence of a File
    • Comparing the Contents of Two Files
    • Checking if a File is Readable/Writable/Executable/Deletable
    • Moving/Renaming a File
    • Copying a File
    • Removing a File
    • Creating a Symbolic Link
    • Reading and Writing Files with NSFileManager
    • Working with Files using the NSFileHandle Class
    • Creating an NSFileHandle Object
    • NSFileHandle File Offsets and Seeking
    • Reading Data from a File
    • Writing Data to a File
    • Truncating a File
      
      
35. iOS 8 Directory Handling and File I/O in Swift – A Worked Example
    • The Example Application
    • Setting up the Application Project
    • Designing the User Interface
    • Checking the Data File on Application Startup
    • Implementing the Action Method
    • Building and Running the Example
      
      
36. Preparing an iOS 8 App to use iCloud Storage
    • iCloud Data Storage Services
    • Preparing an Application to Use iCloud Storage
    • Enabling iCloud Support for an iOS 8 Application
    • Reviewing the iCloud Entitlements File
    • Accessing Multiple Ubiquity Containers
    • Ubiquity Container URLs
      
      
37. Managing Files using the iOS 8 UIDocument Class
    • An Overview of the UIDocument Class
    • Subclassing the UIDocument Class
    • Conflict Resolution and Document States
    • The UIDocument Example Application
    • Creating a UIDocument Subclass
    • Designing the User Interface
    • Implementing the Application Data Structure
    • Implementing the contentsForType Method
    • Implementing the loadFromContents Method
    • Loading the Document at App Launch
    • Saving Content to the Document
    • Testing the Application
      
      
38. Using iCloud Storage in an iOS 8 Application
    • iCloud Usage Guidelines
    • Preparing the iCloudStore Application for iCloud Access
    • Configuring the View Controller
    • Implementing the viewDidLoad Method
    • Implementing the metadataQueryDidFinishGathering Method
    • Implementing the saveDocument Method
    • Enabling iCloud Document and Data Storage
    • Running the iCloud Application
    • Reviewing and Deleting iCloud Based Documents
    • Making a Local File Ubiquitous
      
      
39. Synchronizing iOS 8 Key-Value Data using iCloud
    • An Overview of iCloud Key-Value Data Storage
    • Sharing Data Between Applications
    • Data Storage Restrictions
    • Conflict Resolution
    • Receiving Notification of Key-Value Changes
    • An iCloud Key-Value Data Storage Example
    • Enabling the Application for iCloud Key Value Data Storage
    • Designing the User Interface
    • Implementing the View Controller
    • Modifying the viewDidLoad Method
    • Implementing the Notification Method
    • Implementing the saveData Method
    • Testing the Application
      
      
40. iOS 8 Data Persistence using Archiving and Swift
    • An Overview of Archiving
    • The Archiving Example Application
    • Designing the User Interface
    • Checking for the Existence of the Archive File on Startup
    • Archiving Object Data in the Action Method
    • Testing the Application
      
      
41. Swift iOS 8 Database Implementation using SQLite
    • What is SQLite?
    • Structured Query Language (SQL)
    • Trying SQLite on MacOS X
    • Preparing an iOS Application Project for SQLite Integration
    • SQLite, Swift and Wrappers
    • Key FMDB Classes
    • Creating and Opening a Database
    • Creating a Database Table
    • Extracting Data from a Database Table
    • Closing a SQLite Database
      
      
42. An Example SQLite based iOS 8 Application using Swift and FMDB
    • About the Example SQLite Application
    • Creating and Preparing the SQLite Application Project
    • Checking Out the FMDB Source Code
    • Designing the User Interface
    • Creating the Database and Table
    • Implementing the Code to Save Data to the SQLite Database
    • Implementing Code to Extract Data from the SQLite Database
    • Building and Running the Application
      
      
43. iOS 8 Databases in Swift using Core Data
    • The Core Data Stack
    • Managed Objects
    • Managed Object Context
    • Managed Object Model
    • Persistent Store Coordinator
    • Persistent Object Store
    • Defining an Entity Description
    • Obtaining the Managed Object Context
    • Getting an Entity Description
    • Generating a Managed Object Subclass
    • Setting the Attributes of a Managed Object
    • Saving a Managed Object
    • Fetching Managed Objects
    • Retrieving Managed Objects based on Criteria
    • Accessing the Data in a Retrieved Managed Object
      
      
44. An iOS 8 Swift Core Data Tutorial
    • The Core Data Example Application
    • Creating a Core Data based Application
    • Creating the Entity Description
    • Generating the Managed Object Subclass
    • Modifying the Entity Class Name
    • Designing the User Interface
    • Accessing the Managed Object Context
    • Saving Data to the Persistent Store using Core Data
    • Retrieving Data from the Persistent Store using Core Data
    • Building and Running the Example Application
      
      
45. An Introduction to CloudKit Data Storage on iOS 8
    • An Overview of CloudKit
    • CloudKit Containers
    • CloudKit Public Database
    • CloudKit Private Databases
    • Data Storage and Transfer Quotas
    • CloudKit Records
    • CloudKit Record IDs
    • CloudKit References
    • CloudKit Assets
    • Record Zones
    • CloudKit Subscriptions
    • Obtaining iCloud User Information
    • CloudKit Dashboard
      
      
46. An iOS 8 CloudKit Example
    • About the Example CloudKit Project
    • Creating the CloudKit Example Project
    • Designing the User Interface
    • Establishing Outlets and Actions
    • Accessing the Public Database
    • Hiding the Keyboard
    • Implementing the selectPhoto method
    • Saving a Record to the Cloud Database
    • Implementing the notifyUser Method
    • Testing the Record Saving Method
    • Searching for Cloud Database Records
    • Updating Cloud Database Records
    • Deleting a Cloud Record
    • Testing the Application
      
      
47. An iOS 8 CloudKit Subscription Example
    • Push Notifications and CloudKit Subscriptions
    • Registering an App to Receive Push Notifications
    • Configuring a CloudKit Subscription
    • Handling Remote Notifications
    • Implementing the didReceiveRemoteNotification Method
    • Fetching a Record From a Cloud Database
    • Implementing the didFinishLaunchingWithOptions Method
    • Testing the Application
      
      
48. An Overview of iOS 8 Multitouch, Taps and Gestures
    • The Responder Chain
    • Forwarding an Event to the Next Responder
    • Gestures
    • Taps
    • Touches
    • Touch Notification Methods
    • touchesBegan method
    • touchesMoved method
    • touchesEnded method
    • touchesCancelled method
      
      
49. An Example Swift iOS 8 Touch, Multitouch and Tap Application
    • The Example iOS 8 Tap and Touch Application
    • Creating the Example iOS Touch Project
    • Designing the User Interface
    • Enabling Multitouch on the View
    • Implementing the touchesBegan Method
    • Implementing the touchesMoved Method
    • Implementing the touchesEnded Method
    • Getting the Coordinates of a Touch
    • Building and Running the Touch Example Application
      
      
50. Detecting iOS 8 Touch Screen Gesture Motions in Swift
    • The Example iOS 8 Gesture Application
    • Creating the Example Project
    • Designing the Application User Interface
    • Implementing the touchesBegan Method
    • Implementing the touchesMoved Method
    • Implementing the touchesEnded Method
    • Building and Running the Gesture Example
      
      
51. Identifying Gestures using iOS 8 Gesture Recognizers
    • The UIGestureRecognizer Class
    • Recognizer Action Messages
    • Discrete and Continuous Gestures
    • Obtaining Data from a Gesture
    • Recognizing Tap Gestures
    • Recognizing Pinch Gestures
    • Detecting Rotation Gestures
    • Recognizing Pan and Dragging Gestures
    • Recognizing Swipe Gestures
    • Recognizing Long Touch (Touch and Hold) Gestures
      
      
52. An iOS 8 Swift Gesture Recognition Tutorial
    • Creating the Gesture Recognition Project
    • Designing the User Interface
    • Implementing the Action Methods
    • Testing the Gesture Recognition Application
      
      
53. Implementing TouchID Authentication in iOS 8 Apps
    • The Local Authentication Framework
    • Checking for TouchID Availability
    • Evaluating TouchID Policy
    • A TouchID Example Project
    • Checking for TouchID Availability
    • Seeking TouchID Authentication
    • Testing the Application
      
      
54. An Overview of iOS 8 Collection View and Flow Layout
    • An Overview of Collection Views
    • The UICollectionView Class
    • The UICollectionViewCell Class
    • The UICollectionReusableView Class
    • The UICollectionViewFlowLayout Class
    • The UICollectionViewLayoutAttributes Class
    • The UICollectionViewDataSource Protocol
    • The UICollectionViewDelegate Protocol
    • The UICollectionViewDelegateFlowLayout Protocol
    • Cell and View Reuse
      
      
55. A Swift iOS 8 Storyboard-based Collection View Tutorial
    • Creating the Collection View Example Project
    • Removing the Template View Controller
    • Adding a Collection View Controller to the Storyboard
    • Adding the Collection View Cell Class to the Project
    • Designing the Cell Prototype
    • Implementing the Data Model
    • Implementing the Data Source
    • Testing the Application
    • Setting Sizes for Cell Items
    • Changing Scroll Direction
    • Implementing a Supplementary View
    • Implementing the Supplementary View Protocol Methods
      
      
56. Subclassing and Extending the iOS 8 Collection View Flow Layout in Swift
    • About the Example Layout Class
    • Subclassing the UICollectionViewFlowLayout Class
    • Extending the New Layout Class
    • Implementing the layoutAttributesForItemAtIndexPath Method
    • Implementing the layoutAttributesForElementsInRect Method
    • Implementing the modifyLayoutAttributes Method
    • Adding the New Layout and Pinch Gesture Recognizer
    • Implementing the Pinch Recognizer
    • Avoiding Image Clipping
    • Testing the Application
      
      
57. Drawing iOS 8 2D Graphics in Swift with Core Graphics
    • Introducing Core Graphics and Quartz 2D
    • The drawRect Method
    • Points, Coordinates and Pixels
    • The Graphics Context
    • Working with Colors in Quartz 2D
      
      
58. Interface Builder Live Views and iOS 8 Embedded Frameworks
    • Embedded Frameworks
    • Interface Builder Live Views
    • Creating the Example Project
    • Adding an Embedded Framework
    • Implementing the Drawing Code in the Framework
    • Making the View Designable
    • Making Variables Inspectable
      
      
59. An iOS 8 Swift Graphics Tutorial using Core Graphics and Core Image
    • The iOS Drawing Example Application
    • Creating the New Project
    • Creating the UIView Subclass
    • Locating the drawRect Method in the UIView Subclass
    • Drawing a Line
    • Drawing a Rectangle
    • Drawing an Ellipse or Circle
    • Filling a Path with a Color
    • Drawing an Arc
    • Drawing a Cubic Bézier Curve
    • Drawing a Quadratic Bézier Curve
    • Dashed Line Drawing
    • Drawing Shadows
    • Drawing Gradients
    • Drawing an Image into a Graphics Context
    • Image Filtering with the Core Image Framework
      
      
60. Basic iOS 8 Swift Animation using Core Animation
    • UIView Core Animation Blocks
    • Understanding Animation Curves
    • Receiving Notification of Animation Completion
    • Performing Affine Transformations
    • Combining Transformations
    • Creating the Animation Example Application
    • Implementing the Variables
    • Drawing in the UIView
    • Detecting Screen Touches and Performing the Animation
    • Building and Running the Animation Application
      
      
61. iOS 8 UIKit Dynamics – An Overview
    • Understanding UIKit Dynamics
    • The UIKit Dynamics Architecture
    • Dynamic Items
    • Dynamic Behaviors
    • The Reference View
    • The Dynamic Animator
    • Implementing UIKit Dynamics in an iOS 8 Application
    • Dynamic Animator Initialization
    • Configuring Gravity Behavior
    • Configuring Collision Behavior
    • Configuring Attachment Behavior
    • Configuring Snap Behavior
    • Configuring Push Behavior
    • The UIDynamicItemBehavior Class
    • Combining Behaviors to Create a Custom Behavior
      
      
62. A Swift iOS 8 UIKit Dynamics Tutorial
    • Creating the UIKit Dynamics Example Project
    • Adding the Dynamic Items
    • Creating the Dynamic Animator Instance
    • Adding Gravity to the Views
    • Implementing Collision Behavior
    • Attaching a View to an Anchor Point
    • Implementing a Spring Attachment Between two Views
      
      
63. An Introduction to iOS 8 Sprite Kit Game Programming
    • What is Sprite Kit?
    • The Key Components of a Sprite Kit Game
    • Sprite Kit View
    • Scenes
    • Nodes
    • Physics Bodies
    • Physics World
    • Actions
    • Transitions
    • Texture Atlas
    • Constraints
    • An Example Sprite Kit Game Hierarchy
    • The Sprite Kit Game Rendering Loop
    • The Sprite Kit Level Editor
      
      
64. An iOS 8 Swift Sprite Kit Level Editor Game Tutorial
    • About the Sprite Kit Demo Game
    • Creating the SpriteKitDemo Project
    • Reviewing the SpriteKit Game Template Project
    • Restricting Interface Orientation
    • Modifying the GameScene SpriteKit Scene File
    • Creating the Archery Scene
    • Transitioning to the Archery Scene
    • Adding the Texture Atlas
    • Designing the Archery Scene
    • Preparing the Archery Scene
    • Preparing the Animation Texture Atlas
    • Animating the Archer Sprite Node
    • Creating the Arrow Sprite Node
    • Shooting the Arrow
    • Adding the Ball Sprite Node
      
      
65. A Swift iOS 8 Sprite Kit Collision Handling Tutorial
    • Defining the Category Bit Masks
    • Assigning the Category Masks to the Sprite Nodes
    • Configuring the Collision and Contact Masks
    • Implementing the Contact Delegate
    • Implementing a Physics Joint Between Nodes
    • Game Over
      
      
66. An iOS 8 Sprite Kit Particle Emitter Tutorial
    • What is the Particle Emitter?
    • The Particle Emitter Editor
    • The SKEmitterNode Class
    • Using the Particle Emitter Editor
    • Particle Emitter Node Properties
    • Background
    • Particle Texture
    • Particle Birthrate
    • Particle Life Cycle
    • Particle Position Range
    • Angle
    • Particle Speed
    • Particle Acceleration
    • Particle Scale
    • Particle Rotation
    • Particle Color
    • Particle Blend Mode
    • Experimenting with the Particle Emitter Editor
    • Bursting a Ball using Particle Emitter Effects
    • Adding the Burst Particle Emitter Effect
      
      
67. Integrating iAds into an iOS 8 App using Swift
    • Preparing to Run iAds within an Application
    • iAd Advertisement Formats
    • Banner Ads
    • Interstitial Ads
    • Medium Rectangle Ads
    • Pre-Roll Video Ads
    • Creating an Example iAds Application
    • Adding the iAds Framework to the Xcode Project
    • Enabling Banner Ads
    • Adding a Medium Rectangle Ad
    • Implementing an Interstitial Ad
    • Configuring iAds Test Settings
      
      
68. Integrating Maps into iOS 8 Applications using MKMapItem and Swift
    • MKMapItem and MKPlacemark Classes
    • An Introduction to Forward and Reverse Geocoding
    • Creating MKPlacemark Instances
    • Working with MKMapItem
    • MKMapItem Options and Enabling Turn-by-Turn Directions
    • Adding Item Details to an MKMapItem
      
      
69. An Example Swift iOS 8 MKMapItem Application
    • Creating the MapItem Project
    • Designing the User Interface
    • Converting the Destination using Forward Geocoding
    • Launching the Map
    • Building and Running the Application
      
      
70. Getting Location Information using the iOS 8 Core Location Framework in Swift
    • The Core Location Manager
    • Requesting Location Access Authorization
    • Configuring the Desired Location Accuracy
    • Configuring the Distance Filter
    • The Location Manager Delegate
    • Starting Location Updates
    • Obtaining Location Information from CLLocation Objects
    • Longitude and Latitude
    • Accuracy
    • Altitude
    • Calculating Distances
    • Location Information and Multitasking
      
      
71. A Swift Example iOS 8 Location Application
    • Creating the Example iOS 8 Location Project
    • Designing the User Interface
    • Configuring the CLLocationManager Object
    • Setting up the Usage Description Key
    • Implementing the Action Method
    • Implementing the Application Delegate Methods
    • Building and Running the Location Application
      
      
72. Working with Maps on iOS 8 with Swift, MapKit and the MKMapView Class
    • About the MapKit Framework
    • Understanding Map Regions
    • About the MKMapView Tutorial
    • Creating the Map Project
    • Adding the MapKit Framework to the Xcode Project
    • Adding the Navigation Controller
    • Creating the MKMapView Instance and Toolbar
    • Obtaining Location Information Permission
    • Setting up the Usage Description Key
    • Configuring the Map View
    • Changing the MapView Region
    • Changing the Map Type
    • Testing the MapView Application
    • Updating the Map View based on User Movement
      
      
73. Working with MapKit Local Search in iOS 8 and Swift
    • An Overview of iOS 8 Local Search
    • Adding Local Search to the MapSample Application
    • Adding the Local Search Text Field
    • Performing the Local Search
    • Testing the Application
      
      
74. Using MKDirections to get iOS 8 Map Directions and Routes
    • An Overview of MKDirections
    • Adding Directions and Routes to the MapSample Application
    • Adding the New Classes to the Project
    • Configuring the Results Table View
    • Implementing the Result Table View Segue
    • Adding the Route Scene
    • Getting the Route and Directions
    • Establishing the Route Segue
    • Testing the Application
      
      
75. An Introduction to Extensions in iOS 8
    • iOS Extensions – An Overview
    • Extension Types
    • Today Extension
    • Share Extension
    • Action Extension
    • Photo Editing Extension
    • Document Provider Extension
    • Custom Keyboard Extension
    • Creating Extensions
      
      
76. An iOS 8 Today Extension Widget Tutorial
    • About the Example Extension Widget
    • Creating the Example Project
    • Adding the Extension to the Project
    • Reviewing the Extension Files
    • Designing the Widget User Interface
    • Setting the Preferred Content Size in Code
    • Modifying the Widget View Controller
    • Testing the Extension
    • Opening the Containing App from the Extension
      
      
77. Creating an iOS 8 Photo Editing Extension
    • Creating a Photo Editing Extension
    • Accessing the Photo Editing Extension
    • Configuring the Info.plist File
    • Designing the User Interface
    • The PHContentEditingController Protocol
    • Photo Extensions and Adjustment Data
    • Receiving the Content
    • Implementing the Filter Actions
    • Returning the Image to the Photos App
    • Testing the Application
      
      
78. Creating an iOS 8 Action Extension
    • An Overview of Action Extensions
    • About the Action Extension Example
    • Creating the Action Extension Project
    • Adding the Action Extension Target
    • Configuring the Action Extension
    • Designing the Action Extension User Interface
    • Receiving the Content
    • Returning the Modified Data to the Host App
    • Testing the Extension
      
      
79. Receiving Data from an iOS 8 Action Extension
    • Creating the Example Project
    • Designing the User Interface
    • Importing the Mobile Core Services Framework
    • Adding a Share Button to the Application
    • Receiving Data from an Extension
    • Testing the Application
      
      
80. Using iOS 8 Event Kit and Swift to Create Date and Location Based Reminders
    • An Overview of the Event Kit Framework
    • The EKEventStore Class
    • Accessing Calendars in the Database
    • Creating Reminders
    • Creating Alarms
    • Creating the Example Project
    • Designing the User Interface for the Date/Time Based Reminder Screen
    • Implementing the Reminder Code
    • Hiding the Keyboard
    • Designing the Location-based Reminder Screen
    • Creating a Location-based Reminder
    • Setting up the Usage Description Key
    • Testing the Application
      
      
81. Accessing the iOS 8 Camera and Photo Library in Swift
    • The UIImagePickerController Class
    • Creating and Configuring a UIImagePickerController Instance
    • Configuring the UIImagePickerController Delegate
    • Detecting Device Capabilities
    • Saving Movies and Images
      
      
82. An Example Swift iOS 8 iPhone Camera Application
    • An Overview of the Application
    • Creating the Camera Project
    • Designing the User Interface
    • Implementing the Action Methods
    • Writing the Delegate Methods
    • Building and Running the Application
      
      
83. iOS 8 Video Playback using AVPlayer and AVPlayerViewController
    • The AVPlayer and AVPlayerViewController Classes
    • The iOS Movie Player Example Application
    • Adding the AVKit Framework to the Xcode Project
    • Designing the User Interface
    • Initializing Video Playback
    • Build and Run the Application
    • Creating AVPlayerViewController Instance from Code
      
      
84. Playing Audio on iOS 8 using AVAudioPlayer
    • Supported Audio Formats
    • Receiving Playback Notifications
    • Controlling and Monitoring Playback
    • Creating the Audio Example Application
    • Adding an Audio File to the Project Resources
    • Designing the User Interface
    • Implementing the Action Methods
    • Creating and Initializing the AVAudioPlayer Object
    • Implementing the AVAudioPlayerDelegate Protocol Methods
    • Building and Running the Application
      
      
85. Recording Audio on iOS 8 with AVAudioRecorder in Swift
    • An Overview of the AVAudioRecorder Tutorial
    • Creating the Recorder Project
    • Designing the User Interface
    • Creating the AVAudioRecorder Instance
    • Implementing the Action Methods
    • Implementing the Delegate Methods
    • Testing the Application
      
      
86. Integrating Twitter and Facebook into iOS 8 Applications using Swift
    • The UIActivityViewController class
    • The Social Framework
    • Accounts Framework
    • Using the UIActivityViewController Class
    • Using the SLComposeViewController Class
      
      
87. An iOS 8 Swift Facebook Integration Tutorial using UIActivityViewController
    • Creating the Facebook Social App
    • Designing the User Interface
    • Creating Outlets and Actions
    • Implementing the selectImage and Delegate Methods
    • Hiding the Keyboard
    • Posting the Message to Facebook
    • Running the Social Application
      
      
88. iOS 8 Facebook and Twitter Integration using SLRequest and Swift
    • Using SLRequest and the Account Framework
    • Twitter Integration using SLRequest
    • Facebook Integration using SLRequest
      
      
89. An Swift iOS 8 Twitter Integration Tutorial using SLRequest
    • Creating the TwitterApp Project
    • Designing the User Interface
    • Modifying the View Controller Class
    • Accessing the Twitter API
    • Calling the getTimeLine Method
    • The Table View Delegate Methods
    • Building and Running the Application
      
      
90. Making Store Purchases in Swift with the SKStoreProductViewController Class
    • The SKStoreProductViewController Class
    • Creating the Example Project
    • Creating the User Interface
    • Displaying the Store Kit Product View Controller
    • Implementing the Delegate Method
    • Testing the Application
      
      
91. Building In-App Purchasing into iOS 8 Swift Applications
    • In-App Purchase Options
    • Uploading App Store Hosted Content
    • Configuring In-App Purchase Items
    • Sending a Product Request
    • Accessing the Payment Queue
    • The Transaction Observer Object
    • Initiating the Purchase
    • The Transaction Process
    • Transaction Restoration Process
    • Testing In-App Purchases
      
      
92. Preparing an iOS 8 Application for In-App Purchases
    • About the Example Application
    • Creating the Xcode Project
    • Registering and Enabling the App ID for In App Purchasing
    • Configuring the Application in iTunes Connect
    • Creating an In-App Purchase Item
      
      
93. An iOS 8 Swift In-App Purchase Tutorial
    • The Application User Interface
    • Designing the Storyboard
    • Creating the Purchase View Controller Class
    • Storing the Home View Controller in the App Delegate Class
    • Completing the ViewController Class
    • Completing the PurchaseViewController Class
    • Testing the Application
    • Troubleshooting
      
      
94. Configuring and Creating App Store Hosted Content for iOS 8 In-App Purchases
    • Configuring an Application for In-App Purchase Hosted Content
    • The Anatomy of an In-App Purchase Hosted Content Package
    • Creating an In-App Purchase Hosted Content Package
    • Archiving the Hosted Content Package
    • Validating the Hosted Content Package
    • Uploading the Hosted Content Package
      
      

Learn SwiftUI and take your iOS Development to the Next Level
SwiftUI Essentials – iOS 16 Edition book is now available in Print ($39.99) and eBook ($29.99) editions. Learn more...