iOS 7 App Development Essentials
$12.99
Minimum price
$14.99
Suggested price

iOS 7 App Development Essentials

Developing iOS 7 Apps for the iPhone and iPad

About the Book

Beginning with the basics, this book provides an outline of the steps necessary to set up an iOS development environment. An introduction to the architecture of iOS 7 and programming in Objective-C is provided, followed by an in-depth look at the design of iOS applications and user interfaces. 

More advanced topics such as file handling, database management, in-app purchases, graphics drawing and animation are also covered, as are touch screen handling, gesture recognition, multitasking, iAds integration, location management, local notifications, camera access and video and audio playback support. Other features are also covered including Auto Layout, Twitter and Facebook integration, event reminders, App Store hosted in-app purchase content, collection views and much more. 

New features of iOS 7 are also covered, including Sprite Kit-based 2D game development, local map search and user interface animation using UIKit Dynamics.

Assuming you are ready to download the iOS 7 SDK and Xcode, have an Intel-based Mac and some ideas for some apps to develop, you are ready to get started.

About the Author

Table of Contents

  • 1. Start Here
    • 1.1 For New iOS Developers
    • 1.2 For iOS 6 Developers
    • 1.3 Source Code Download
    • 1.4 Feedback
    • 1.5 Errata
  • 2. Joining the Apple iOS Developer Program
    • 2.1 Registered Apple Developer
    • 2.2 Downloading Xcode and the iOS 7 SDK
    • 2.3 iOS Developer Program
    • 2.4 When to Enroll in the iOS Developer Program?
    • 2.5 Enrolling in the iOS Developer Program
    • 2.6 Summary
  • 3. Installing Xcode 5 and the iOS 7 SDK
    • 3.1 Identifying if you have an Intel or PowerPC based Mac
    • 3.2 Installing Xcode 5 and the iOS 7 SDK
    • 3.3 Starting Xcode
  • 4. Creating a Simple iOS 7 App
    • 4.1 Starting Xcode 5
    • 4.2 Creating the iOS App User Interface
    • 4.3 Changing Component Properties
    • 4.4 Adding Objects to the User Interface
    • 4.5 Building and Running an iOS 7 App in Xcode 5
    • 4.6 Dealing with Build Errors
    • 4.7 Testing Different Screen Sizes
    • 4.8 Testing User Interface Appearance in Different iOS Versions
    • 4.9 Monitoring Application Performance
    • 4.10 Summary
  • 5. iOS 7 Architecture and SDK Frameworks
    • 5.1 iPhone OS becomes iOS
    • 5.2 An Overview of the iOS 7 Architecture
    • 5.3 The Cocoa Touch Layer
    • 5.4 The iOS Media Layer
    • 5.5 The iOS Core Services Layer
    • 5.6 Foundation Framework (Foundation.framework)
    • 5.7 The iOS Core OS Layer
  • 6. Testing Apps on iOS 7 Devices with Xcode 5
    • 6.1 Configuring Xcode with Apple IDs
    • 6.2 Generating Signing Identities
    • 6.3 Adding a Device to the Developer Portal
    • 6.4 Running an Application on a Registered Device
    • 6.5 Summary
  • 7. The Basics of Objective-C Programming
    • 7.1 Objective-C Data Types and Variables
    • 7.2 Objective-C Expressions
    • 7.3 Objective-C Flow Control with if and else
    • 7.4 Looping with the for Statement
    • 7.5 Objective-C Looping with do and while
    • 7.6 Objective-C do … while loops
  • 8. The Basics of Object Oriented Programming in Objective-C
    • 8.1 What is an Object?
    • 8.2 What is a Class?
    • 8.3 Declaring an Objective-C Class Interface
    • 8.4 Adding Instance Variables to a Class
    • 8.5 Define Class Methods
    • 8.6 Declaring an Objective-C Class Implementation
    • 8.7 Declaring and Initializing a Class Instance
    • 8.8 Automatic Reference Counting (ARC)
    • 8.9 Calling Methods and Accessing Instance Data
    • 8.10 Objective-C and Dot Notation
    • 8.11 How Variables are Stored
    • 8.12 An Overview of Indirection
    • 8.13 Indirection and Objects
    • 8.14 Indirection and Object Copying
    • 8.15 Creating the Program Section
    • 8.16 Bringing it all Together
    • 8.17 Structuring Object-Oriented Objective-C Code
  • 9. The Basics of Modern Objective-C
    • 9.1 Default Property Synthesis
    • 9.2 Method Ordering
    • 9.3 NSNumber Literals
    • 9.4 Array Literals
    • 9.5 Dictionary Literals
    • 9.6 Summary
  • 10. An Overview of the iOS 7 Application Development Architecture
    • 10.1 Model View Controller (MVC)
    • 10.2 The Target-Action pattern, IBOutlets and IBActions
    • 10.3 Subclassing
    • 10.4 Delegation
    • 10.5 Summary
  • 11. Creating an Interactive iOS 7 App
    • 11.1 Creating the New Project
    • 11.2 Creating the User Interface
    • 11.3 Building and Running the Sample Application
    • 11.4 Adding Actions and Outlets
    • 11.5 Building and Running the Finished Application
    • 11.6 Summary
  • 12. Writing iOS 7 Code to Hide the Keyboard
    • 12.1 Creating the Example App
    • 12.2 Hiding the Keyboard when the User Touches the Return Key
    • 12.3 Hiding the Keyboard when the User Taps the Background
    • 12.4 Summary
  • 13. Understanding iOS 7 Views, Windows and the View Hierarchy
    • 13.1 An Overview of Views
    • 13.2 The UIWindow Class
    • 13.3 The View Hierarchy
    • 13.4 View Types
    • 13.5 Summary
  • 14. An Introduction to Auto Layout in iOS 7
    • 14.1 An Overview of Auto Layout
    • 14.2 Alignment Rects
    • 14.3 Intrinsic Content Size
    • 14.4 Content Hugging and Compression Resistance Priorities
    • 14.5 Three Ways to Create Constraints
    • 14.6 Constraints in more Detail
    • 14.7 Summary
  • 15. Working with iOS 7 Auto Layout Constraints in Interface Builder
    • 15.1 A Simple Example of Auto Layout in Action
    • 15.2 Enabling and Disabling Auto Layout in Interface Builder
    • 15.3 The Auto Layout Features of Interface Builder
    • 15.4 Creating New Constraints in Interface Builder
    • 15.5 Resolving Auto Layout Problems
    • 15.6 Summary
  • 16. An iOS 7 Auto Layout Example
    • 16.1 Preparing the Project
    • 16.2 Designing the User Interface
    • 16.3 Adding Auto Layout Constraints
    • 16.4 Adjusting Constraint Priorities
    • 16.5 Testing the Application
    • 16.6 Summary
  • 17. Implementing iOS 7 Auto Layout Constraints in Code
    • 17.1 Creating Constraints in Code
    • 17.2 Adding a Constraint to a View
    • 17.3 Turning off Auto Resizing Translation
    • 17.4 An Example Application
    • 17.5 Creating the Views
    • 17.6 Creating and Adding the Constraints
    • 17.7 Removing Constraints
    • 17.8 Summary
  • 18. Implementing Cross-Hierarchy Auto Layout Constraints in iOS 7
    • 18.1 The Example Application
    • 18.2 Establishing Outlets
    • 18.3 Writing the Code to Remove the Old Constraint
    • 18.4 Adding the Cross Hierarchy Constraint
    • 18.5 Testing the Application
    • 18.6 Summary
  • 19. Understanding the iOS 7 Auto Layout Visual Format Language
    • 19.1 Introducing the Visual Format Language
    • 19.2 Visual Language Format Examples
    • 19.3 Using the constraintsWithVisualFormat: Method
    • 19.4 Summary
  • 20. Using Storyboards in Xcode 5
    • 20.1 Creating the Storyboard Example Project
    • 20.2 Accessing the Storyboard
    • 20.3 Adding Scenes to the Storyboard
    • 20.4 Configuring Storyboard Segues
    • 20.5 Configuring Storyboard Transitions
    • 20.6 Associating a View Controller with a Scene
    • 20.7 Passing Data Between Scenes
    • 20.8 Unwinding Storyboard Segues
    • 20.9 Triggering a Storyboard Segue Programmatically
    • 20.10 Summary
  • 21. Using Xcode 5 Storyboards to Create an iOS 7 Tab Bar Application
    • 21.1 An Overview of the Tab Bar
    • 21.2 Understanding View Controllers in a Multiview Application
    • 21.3 Setting up the Tab Bar Example Application
    • 21.4 Reviewing the Project Files
    • 21.5 Renaming the Initial View Controller
    • 21.6 Adding the View Controller for the Second Content View
    • 21.7 Adding the Tab Bar Controller to the Storyboard
    • 21.8 Adding a Second View Controller to the Storyboard
    • 21.9 Designing the View Controller User interfaces
    • 21.10 Configuring the Tab Bar Items
    • 21.11 Building and Running the Application
    • 21.12 Summary
  • 22. An Overview of iOS 7 Table Views and Xcode 5 Storyboards
    • 22.1 An Overview of the Table View
    • 22.2 Static vs. Dynamic Table Views
    • 22.3 The Table View Delegate and dataSource
    • 22.4 Table View Styles
    • 22.5 Table View Cell Styles
    • 22.6 Table View Cell Reuse
    • 22.7 Summary
  • 23. Using Xcode 5 Storyboards to Build Dynamic TableViews with Prototype Table View Cells
    • 23.1 Creating the Example Project
    • 23.2 Adding the TableView Controller to the Storyboard
    • 23.3 Creating the UITableViewController and UITableViewCell Subclasses
    • 23.4 Declaring the Cell Reuse Identifier
    • 23.5 Designing a Storyboard UITableView Prototype Cell
    • 23.6 Modifying the CarTableViewCell Class
    • 23.7 Creating the Table View Datasource
    • 23.8 Downloading and Adding the Image Files
    • 23.9 Compiling and Running the Application
    • 23.10 Summary
  • 24. Implementing iOS 7 TableView Navigation using Storyboards in Xcode 5
    • 24.1 Understanding the Navigation Controller
    • 24.2 Adding the New Scene to the Storyboard
    • 24.3 Adding a Navigation Controller
    • 24.4 Establishing the Storyboard Segue
    • 24.5 Modifying the CarDetailViewController Class
    • 24.6 Using prepareForSegue: to Pass Data between Storyboard Scenes
    • 24.7 Testing the Application
    • 24.8 Summary
  • 25. Using an Xcode 5 Storyboard to Create a Static Table View
    • 25.1 An Overview of the Static Table Project
    • 25.2 Creating the Project
    • 25.3 Adding a Table View Controller
    • 25.4 Changing the Table View Content Type
    • 25.5 Designing the Static Table
    • 25.6 Adding Items to the Table Cells
    • 25.7 Modifying the StaticTableViewController Class
    • 25.8 Building and Running the Application
    • 25.9 Summary
  • 26. An iPad iOS 7 Split View and Popover Example
    • 26.1 An Overview of Split View and Popovers
    • 26.2 About the Example iPad Split View and Popover Project
    • 26.3 Creating the Project
    • 26.4 Reviewing the Project
    • 26.5 Configuring Master View Items
    • 26.6 Configuring the Detail View Controller
    • 26.7 Connecting Master Selections to the Detail View
    • 26.8 Popover Implementation
    • 26.9 Testing the Application
    • 26.10 Summary
  • 27. Implementing a Page based iOS 7 Application using UIPageViewController
    • 27.1 The UIPageViewController Class
    • 27.2 The UIPageViewController DataSource
    • 27.3 Navigation Orientation
    • 27.4 Spine Location
    • 27.5 The UIPageViewController Delegate Protocol
    • 27.6 Summary
  • 28. An Example iOS 7 UIPageViewController Application
    • 28.1 The Xcode Page-based Application Template
    • 28.2 Creating the Project
    • 28.3 Adding the Content View Controller
    • 28.4 Creating the Data Model
    • 28.5 Initializing the UIPageViewController
    • 28.6 Running the UIPageViewController Application
    • 28.7 Summary
  • 29. Using the iOS 7 UIPickerView and UIDatePicker Components
    • 29.1 The DatePicker and PickerView Components
    • 29.2 A DatePicker Example
    • 29.3 Designing the User Interface
    • 29.4 Coding the Date Picker Example Functionality
    • 29.5 Building and Running the Date Picker Application
  • 30. An iOS 7 UIPickerView Example
    • 30.1 Creating the iOS 7 PickerView Project
    • 30.2 UIPickerView Delegate and DataSource
    • 30.3 The PickerViewController.h File
    • 30.4 Designing the User Interface
    • 30.5 Initializing the Arrays
    • 30.6 Implementing the DataSource Protocol
    • 30.7 Implementing the Delegate Protocol
    • 30.8 Hiding the Keyboard
    • 30.9 Testing the Application
  • 31. Working with Directories on iOS 7
    • 31.1 The Application Documents Directory
    • 31.2 The Objective-C NSFileManager, NSFileHandle and NSData Classes
    • 31.3 Understanding Pathnames in Objective-C
    • 31.4 Obtaining a Reference to the Default NSFileManager Object
    • 31.5 Identifying the Current Working Directory
    • 31.6 Identifying the Documents Directory
    • 31.7 Identifying the Temporary Directory
    • 31.8 Changing Directory
    • 31.9 Creating a New Directory
    • 31.10 Deleting a Directory
    • 31.11 Listing the Contents of a Directory
    • 31.12 Getting the Attributes of a File or Directory
  • 32. Working with Files on iOS 7
    • 32.1 Creating an NSFileManager Instance
    • 32.2 Checking for the Existence of a File
    • 32.3 Comparing the Contents of Two Files
    • 32.4 Checking if a File is Readable/Writable/Executable/Deletable
    • 32.5 Moving/Renaming a File
    • 32.6 Copying a File
    • 32.7 Removing a File
    • 32.8 Creating a Symbolic Link
    • 32.9 Reading and Writing Files with NSFileManager
    • 32.10 Working with Files using the NSFileHandle Class
    • 32.11 Creating an NSFileHandle Object
    • 32.12 NSFileHandle File Offsets and Seeking
    • 32.13 Reading Data from a File
    • 32.14 Writing Data to a File
    • 32.15 Truncating a File
    • 32.16 Summary
  • 33. iOS 7 Directory Handling and File I/O - A Worked Example
    • 33.1 The Example Application
    • 33.2 Setting up the Application Project
    • 33.3 Designing the User Interface
    • 33.4 Checking the Data File on Application Startup
    • 33.5 Implementing the Action Method
    • 33.6 Building and Running the Example
  • 34. Preparing an iOS 7 App to use iCloud Storage
    • 34.1 What is iCloud?
    • 34.2 iCloud Data Storage Services
    • 34.3 Preparing an Application to Use iCloud Storage
    • 34.4 Enabling iCloud Support for an iOS 7 Application
    • 34.5 Reviewing the iCloud Entitlements File
    • 34.6 Manually Creating the Entitlements File
    • 34.7 Accessing Multiple Ubiquity Containers
    • 34.8 Ubiquity Container URLs
    • 34.9 Summary
  • 35. Managing Files using the iOS 7 UIDocument Class
    • 35.1 An Overview of the UIDocument Class
    • 35.2 Subclassing the UIDocument Class
    • 35.3 Conflict Resolution and Document States
    • 35.4 The UIDocument Example Application
    • 35.5 Creating a UIDocument Subclass
    • 35.6 Designing the User Interface
    • 35.7 Implementing the Application Data Structure
    • 35.8 Implementing the contentsForType Method
    • 35.9 Implementing the loadFromContents Method
    • 35.10 Loading the Document at App Launch
    • 35.11 Saving Content to the Document
    • 35.12 Testing the Application
    • 35.13 Summary
  • 36. Using iCloud Storage in an iOS 7 Application
    • 36.1 iCloud Usage Guidelines
    • 36.2 Preparing the iCloudStore Application for iCloud Access
    • 36.3 Configuring the View Controller
    • 36.4 Implementing the viewDidLoad Method
    • 36.5 Implementing the metadataQueryDidFinishGathering: Method
    • 36.6 Implementing the saveDocument__ Method
    • 36.7 Enabling iCloud Document and Data Storage
    • 36.8 Running the iCloud Application
    • 36.9 Reviewing and Deleting iCloud Based Documents
    • 36.10 Reviewing iCloud Activities in the Xcode Debugging Debug Navigator
    • 36.11 Making a Local File Ubiquitous
    • 36.12 Summary
  • 37. Synchronizing iOS 7 Key-Value Data using iCloud
    • 37.1 An Overview of iCloud Key-Value Data Storage
    • 37.2 Sharing Data Between Applications
    • 37.3 Data Storage Restrictions
    • 37.4 Conflict Resolution
    • 37.5 Receiving Notification of Key-Value Changes
    • 37.6 An iCloud Key-Value Data Storage Example
    • 37.7 Enabling the Application for iCloud Key Value Data Storage
    • 37.8 Designing the User Interface
    • 37.9 Implementing the View Controller
    • 37.10 Modifying the viewDidLoad Method
    • 37.11 Implementing the Notification Method
    • 37.12 Implementing the saveData Method
    • 37.13 Testing the Application
  • 38. iOS 7 Data Persistence using Archiving
    • 38.1 An Overview of Archiving
    • 38.2 The Archiving Example Application
    • 38.3 Designing the User Interface
    • 38.4 Checking for the Existence of the Archive File on Startup
    • 38.5 Archiving Object Data in the Action Method
    • 38.6 Testing the Application
    • 38.7 Summary
  • 39. iOS 7 Database Implementation using SQLite
    • 39.1 What is SQLite?
    • 39.2 Structured Query Language (SQL)
    • 39.3 Trying SQLite on MacOS X
    • 39.4 Preparing an iOS Application Project for SQLite Integration
    • 39.5 Key SQLite Functions
    • 39.6 Declaring a SQLite Database
    • 39.7 Opening or Creating a Database
    • 39.8 Preparing and Executing a SQL Statement
    • 39.9 Creating a Database Table
    • 39.10 Extracting Data from a Database Table
    • 39.11 Closing a SQLite Database
    • 39.12 Summary
  • 40. An Example SQLite based iOS 7 Application
    • 40.1 About the Example SQLite Application
    • 40.2 Creating and Preparing the SQLite Application Project
    • 40.3 Importing sqlite3.h and declaring the Database Reference
    • 40.4 Designing the User Interface
    • 40.5 Creating the Database and Table
    • 40.6 Implementing the Code to Save Data to the SQLite Database
    • 40.7 Implementing Code to Extract Data from the SQLite Database
    • 40.8 Building and Running the Application
    • 40.9 Summary
  • 41. Working with iOS 7 Databases using Core Data
    • 41.1 The Core Data Stack
    • 41.2 Managed Objects
    • 41.3 Managed Object Context
    • 41.4 Managed Object Model
    • 41.5 Persistent Store Coordinator
    • 41.6 Persistent Object Store
    • 41.7 Defining an Entity Description
    • 41.8 Obtaining the Managed Object Context
    • 41.9 Getting an Entity Description
    • 41.10 Creating a Managed Object
    • 41.11 Getting and Setting the Attributes of a Managed Object
    • 41.12 Fetching Managed Objects
    • 41.13 Retrieving Managed Objects based on Criteria
    • 41.14 Summary
  • 42. An iOS 7 Core Data Tutorial
    • 42.1 The Core Data Example Application
    • 42.2 Creating a Core Data based Application
    • 42.3 Creating the Entity Description
    • 42.4 Adding a Storyboard to the Project
    • 42.5 Adding a View Controller
    • 42.6 Designing the User Interface
    • 42.7 Saving Data to the Persistent Store using Core Data
    • 42.8 Retrieving Data from the Persistent Store using Core Data
    • 42.9 Building and Running the Example Application
    • 42.10 Summary
  • 43. An Overview of iOS 7 Multitouch, Taps and Gestures
    • 43.1 The Responder Chain
    • 43.2 Forwarding an Event to the Next Responder
    • 43.3 Gestures
    • 43.4 Taps
    • 43.5 Touches
    • 43.6 Touch Notification Methods
    • 43.7 Summary
  • 44. An Example iOS 7 Touch, Multitouch and Tap Application
    • 44.1 The Example iOS 7 Tap and Touch Application
    • 44.2 Creating the Example iOS Touch Project
    • 44.3 Designing the User Interface
    • 44.4 Enabling Multitouch on the View
    • 44.5 Implementing the touchesBegan Method
    • 44.6 Implementing the touchesMoved Method
    • 44.7 Implementing the touchesEnded Method
    • 44.8 Getting the Coordinates of a Touch
    • 44.9 Building and Running the Touch Example Application
  • 45. Detecting iOS 7 Touch Screen Gesture Motions
    • 45.1 The Example iOS 7 Gesture Application
    • 45.2 Creating the Example Project
    • 45.3 Designing the Application User Interface
    • 45.4 Implementing the touchesBegan Method
    • 45.5 Implementing the touchesMoved Method
    • 45.6 Implementing the touchesEnded Method
    • 45.7 Building and Running the Gesture Example
    • 45.8 Summary
  • 46. Identifying Gestures using iOS 7 Gesture Recognizers
    • 46.1 The UIGestureRecognizer Class
    • 46.2 Recognizer Action Messages
    • 46.3 Discrete and Continuous Gestures
    • 46.4 Obtaining Data from a Gesture
    • 46.5 Recognizing Tap Gestures
    • 46.6 Recognizing Pinch Gestures
    • 46.7 Detecting Rotation Gestures
    • 46.8 Recognizing Pan and Dragging Gestures
    • 46.9 Recognizing Swipe Gestures
    • 46.10 Recognizing Long Touch (Touch and Hold) Gestures
    • 46.11 Summary
  • 47. An iOS 7 Gesture Recognition Tutorial
    • 47.1 Creating the Gesture Recognition Project
    • 47.2 Designing the User Interface
    • 47.3 Implementing the Action Methods
    • 47.4 Testing the Gesture Recognition Application
  • 48. An Overview of iOS 7 Collection View and Flow Layout
    • 48.1 An Overview of Collection Views
    • 48.2 The UICollectionView Class
    • 48.3 The UICollectionViewCell Class
    • 48.4 The UICollectionReusableView Class
    • 48.5 The UICollectionViewFlowLayout Class
    • 48.6 The UICollectionViewLayoutAttributes Class
    • 48.7 The UICollectionViewDataSource Protocol
    • 48.8 The UICollectionViewDelegate Protocol
    • 48.9 The UICollectionViewDelegateFlowLayout Protocol
    • 48.10 Cell and View Reuse
    • 48.11 Summary
  • 49. An iOS 7 Storyboard-based Collection View Tutorial
    • 49.1 Creating the Collection View Example Project
    • 49.2 Removing the Template View Controller
    • 49.3 Adding a Collection View Controller to the Storyboard
    • 49.4 Adding the Collection View Cell Class to the Project
    • 49.5 Designing the Cell Prototype
    • 49.6 Implementing the Data Model
    • 49.7 Implementing the Data Source
    • 49.8 Testing the Application
    • 49.9 Setting Sizes for Cell Items
    • 49.10 Changing Scroll Direction
    • 49.11 Implementing a Supplementary View
    • 49.12 Implementing the Supplementary View Protocol Methods
    • 49.13 Deleting Collection View Items
    • 49.14 Summary
  • 50. Subclassing and Extending the iOS 7 Collection View Flow Layout
    • 50.1 About the Example Layout Class
    • 50.2 Subclassing the UICollectionViewFlowLayout Class
    • 50.3 Extending the New Layout Class
    • 50.4 Implementing the layoutAttributesForItemAtIndexPath: Method
    • 50.5 Implementing the layoutAttributesForElementsInRect: Method
    • 50.6 Implementing the modifyLayoutAttributes: Method
    • 50.7 Adding the New Layout and Pinch Gesture Recognizer
    • 50.8 Implementing the Pinch Recognizer
    • 50.9 Avoiding Image Clipping
    • 50.10 Testing the Application
    • 50.11 Summary
  • 51. Drawing iOS 7 2D Graphics with Core Graphics
    • 51.1 Introducing Core Graphics and Quartz 2D
    • 51.2 The drawRect Method
    • 51.3 Points, Coordinates and Pixels
    • 51.4 The Graphics Context
    • 51.5 Working with Colors in Quartz 2D
    • 51.6 Summary
  • 52. An iOS 7 Graphics Tutorial using Core Graphics and Core Image
    • 52.1 The iOS Drawing Example Application
    • 52.2 Creating the New Project
    • 52.3 Creating the UIView Subclass
    • 52.4 Locating the drawRect Method in the UIView Subclass
    • 52.5 Drawing a Line
    • 52.6 Drawing Paths
    • 52.7 Drawing a Rectangle
    • 52.8 Drawing an Ellipse or Circle
    • 52.9 Filling a Path with a Color
    • 52.10 Drawing an Arc
    • 52.11 Drawing a Cubic Bézier Curve
    • 52.12 Drawing a Quadratic Bézier Curve
    • 52.13 Dashed Line Drawing
    • 52.14 Drawing Shadows
    • 52.15 Drawing Gradients
    • 52.16 Drawing an Image into a Graphics Context
    • 52.17 Image Filtering with the Core Image Framework
    • 52.18 Summary
  • 53. Basic iOS 7 Animation using Core Animation
    • 53.1 UIView Core Animation Blocks
    • 53.2 Understanding Animation Curves
    • 53.3 Receiving Notification of Animation Completion
    • 53.4 Performing Affine Transformations
    • 53.5 Combining Transformations
    • 53.6 Creating the Animation Example Application
    • 53.7 Implementing the Interface File
    • 53.8 Drawing in the UIView
    • 53.9 Detecting Screen Touches and Performing the Animation
    • 53.10 Building and Running the Animation Application
    • 53.11 Summary
  • 54. iOS 7 UIKit Dynamics - An Overview
    • 54.1 Understanding UIKit Dynamics
    • 54.2 The UIKit Dynamics Architecture
    • 54.3 Implementing UIKit Dynamics in an iOS 7 Application
    • 54.4 Dynamic Animator Initialization
    • 54.5 Configuring Gravity Behavior
    • 54.6 Configuring Collision Behavior
    • 54.7 Configuring Attachment Behavior
    • 54.8 Configuring Snap Behavior
    • 54.9 Configuring Push Behavior
    • 54.10 The UIDynamicItemBehavior Class
    • 54.11 Combining Behaviors to Create a Custom Behavior
    • 54.12 Summary
  • 55. An iOS 7 UIKit Dynamics Tutorial
    • 55.1 Creating the UIKit Dynamics Example Project
    • 55.2 Adding the Dynamic Items
    • 55.3 Creating the Dynamic Animator Instance
    • 55.4 Adding Gravity to the Views
    • 55.5 Implementing Collision Behavior
    • 55.6 Attaching a View to an Anchor Point
    • 55.7 Implementing a Spring Attachment Between two Views
    • 55.8 Summary
  • 56. An Introduction to iOS 7 Sprite Kit Programming
    • 56.1 What is Sprite Kit?
    • 56.2 The Key Components of a Sprite Kit Game
    • 56.3 An Example Sprite Kit Game Hierarchy
    • 56.4 The Sprite Kit Game Rendering Loop
    • 56.5 Summary
  • 57. An iOS 7 Sprite Kit Game Tutorial
    • 57.1 About the Sprite Kit Demo Game
    • 57.2 Creating the SpriteKitDemo Project
    • 57.3 Reviewing the SpriteKit Game Template Project
    • 57.4 Creating the Game Scene Classes
    • 57.5 Implementing the Welcome Scene
    • 57.6 Transitioning to the Archery Scene
    • 57.7 Preparing the Archery Scene
    • 57.8 Adding the Texture Atlas
    • 57.9 Obtaining a Texture from the Atlas
    • 57.10 Preparing the Animation Texture Atlas
    • 57.11 Animating the Archer Sprite Node
    • 57.12 Creating the Arrow Sprite Node
    • 57.13 Shooting the Arrow
    • 57.14 Adding the Ball Sprite Node
    • 57.15 Summary
  • 58. An iOS 7 Sprite Kit Collision Handling Tutorial
    • 58.1 Defining the Category Bit Masks
    • 58.2 Assigning the Category Masks to the Sprite Nodes
    • 58.3 Configuring the Collision and Contact Masks
    • 58.4 Implementing the Contact Delegate
    • 58.5 Implementing a Physics Joint Between Nodes
    • 58.6 Game Over
    • 58.7 Summary
  • 59. An iOS 7 Sprite Kit Particle Emitter Tutorial
    • 59.1 What is the Particle Emitter?
    • 59.2 The Particle Emitter Editor
    • 59.3 The SKEmitterNode Class
    • 59.4 Using the Particle Emitter Editor
    • 59.5 Particle Emitter Node Properties
    • 59.6 Experimenting with the Particle Emitter Editor
    • 59.7 Bursting a Ball using Particle Emitter Effects
    • 59.8 Adding the Burst Particle Emitter Effect
    • 59.9 Summary
  • 60. Integrating iAds into an iOS 7 App
    • 60.1 iOS Advertising Options
    • 60.2 Preparing to Run iAds within an Application
    • 60.3 iAd Advertisement Formats
    • 60.4 Creating an Example iAds Application
    • 60.5 Adding the iAds Framework to the Xcode Project
    • 60.6 Enabling Banner Ads
    • 60.7 Adding a Medium Rectangle Ad
    • 60.8 Implementing an Interstitial Ad
    • 60.9 Configuring iAds Test Settings
    • 60.10 Going Live with iAds
    • 60.11 Summary
  • 61. iOS 7 Multitasking, Background Transfer Service and Fetching
    • 61.1 Understanding iOS Application States
    • 61.2 A Brief Overview of the Multitasking Application Lifecycle
    • 61.3 Checking for Multitasking Support
    • 61.4 Enabling Multitasking for an iOS Application
    • 61.5 Supported Forms of Background Execution
    • 61.6 An Overview of Background Fetch
    • 61.7 An Overview of Remote Notifications
    • 61.8 An Overview of Local Notifications
    • 61.9 An Overview of Background Transfer Service
    • 61.10 The Rules of Background Execution
    • 61.11 Summary
  • 62. An iOS 7 Background Transfer Service Tutorial
    • 62.1 Creating the Example Project
    • 62.2 The handleEventsForBackgroundURLSession Method
    • 62.3 Designing the User Interface
    • 62.4 Configuring the View Controller
    • 62.5 Implementing the Session Delegate Methods
    • 62.6 Testing the Application
    • 62.7 Summary
  • 63. Scheduling iOS 7 Local Notifications
    • 63.1 Creating the Local Notification App Project
    • 63.2 Adding a Sound File to the Project
    • 63.3 Locating the Application Delegate Method
    • 63.4 Scheduling the Local Notification
    • 63.5 Testing the Application
    • 63.6 Cancelling Scheduled Notifications
    • 63.7 Immediate Triggering of a Local Notification
    • 63.8 Summary
  • 64. An Overview of iOS 7 Application State Preservation and Restoration
    • 64.1 The Preservation and Restoration Process
    • 64.2 Opting In to Preservation and Restoration
    • 64.3 Assigning Restoration Identifiers
    • 64.4 Default Preservation Features of UIKit
    • 64.5 Saving and Restoring Additional State Information
    • 64.6 Understanding the Restoration Process
    • 64.7 Saving General Application State
    • 64.8 Summary
  • 65. An iOS 7 State Preservation and Restoration Tutorial
    • 65.1 Creating the Example Application
    • 65.2 Trying the Application without State Preservation
    • 65.3 Opting-in to State Preservation
    • 65.4 Setting Restoration Identifiers
    • 65.5 Encoding and Decoding View Controller State
    • 65.6 Adding a Navigation Controller to the Storyboard
    • 65.7 Adding the Third View Controller
    • 65.8 Creating the Restoration Class
    • 65.9 Summary
  • 66. Integrating Maps into iOS 7 Applications using MKMapItem
    • 66.1 MKMapItem and MKPlacemark Classes
    • 66.2 An Introduction to Forward and Reverse Geocoding
    • 66.3 Creating MKPlacemark Instances
    • 66.4 Working with MKMapItem
    • 66.5 MKMapItem Options and Enabling Turn-by-Turn Directions
    • 66.6 Adding Item Details to an MKMapItem
    • 66.7 Summary
  • 67. An Example iOS 7 MKMapItem Application
    • 67.1 Creating the MapItem Project
    • 67.2 Designing the User Interface
    • 67.3 Converting the Destination using Forward Geocoding
    • 67.4 Launching the Map
    • 67.5 Building and Running the Application
    • 67.6 Summary
  • 68. Getting Location Information using the iOS 7 Core Location Framework
    • 68.1 The Basics of Core Location
    • 68.2 Configuring the Desired Location Accuracy
    • 68.3 Configuring the Distance Filter
    • 68.4 The Location Manager Delegate
    • 68.5 Obtaining Location Information from CLLocation Objects
    • 68.6 Calculating Distances
    • 68.7 Location Information and Multitasking
    • 68.8 Summary
  • 69. An Example iOS 7 Location Application
    • 69.1 Creating the Example iOS 7 Location Project
    • 69.2 Designing the User Interface
    • 69.3 Creating the CLLocationManager Object
    • 69.4 Implementing the Action Method
    • 69.5 Implementing the Application Delegate Methods
    • 69.6 Building and Running the Location Application
  • 70. Working with Maps on iOS 7 with MapKit and the MKMapView Class
    • 70.1 About the MapKit Framework
    • 70.2 Understanding Map Regions
    • 70.3 About the MKMapView Tutorial
    • 70.4 Creating the Map Project
    • 70.5 Adding the MapKit Framework to the Xcode Project
    • 70.6 Adding the Navigation Controller
    • 70.7 Creating the MKMapView Instance and Toolbar
    • 70.8 Configuring the Map View
    • 70.9 Changing the MapView Region
    • 70.10 Changing the Map Type
    • 70.11 Testing the MapView Application
    • 70.12 Updating the Map View based on User Movement
    • 70.13 Summary
  • 71. Working with MapKit Local Search in iOS 7
    • 71.1 An Overview of iOS 7 Local Search
    • 71.2 Adding Local Search to the MapSample Application
    • 71.3 Adding the Local Search Text Field
    • 71.4 Performing the Local Search
    • 71.5 Testing the Application
    • 71.6 Summary
  • 72. Using MKDirections to get iOS 7 Map Directions and Routes
    • 72.1 An Overview of MKDirections
    • 72.2 Adding Directions and Routes to the MapSample Application
    • 72.3 Adding the New Classes to the Project
    • 72.4 Configuring the Results Table View
    • 72.5 Implementing the Result Table View Segue
    • 72.6 Adding the Route Scene
    • 72.7 Getting the Route and Directions
    • 72.8 Establishing the Route Segue
    • 72.9 Testing the Application
    • 72.10 Summary
  • 73. Using iOS 7 Event Kit to Create Date and Location Based Reminders
    • 73.1 An Overview of the Event Kit Framework
    • 73.2 The EKEventStore Class
    • 73.3 Accessing Calendars in the Database
    • 73.4 Accessing Current Reminders
    • 73.5 Creating Reminders
    • 73.6 Creating Alarms
    • 73.7 Creating the Example Project
    • 73.8 Designing the User Interface for the Date/Time Based Reminder Screen
    • 73.9 Implementing the Reminder Code
    • 73.10 Hiding the Keyboard
    • 73.11 Designing the Location-based Reminder Screen
    • 73.12 Creating a Location-based Reminder
    • 73.13 Testing the Application
    • 73.14 Summary
  • 74. Accessing the iOS 7 Camera and Photo Library
    • 74.1 The UIImagePickerController Class
    • 74.2 Creating and Configuring a UIImagePickerController Instance
    • 74.3 Configuring the UIImagePickerController Delegate
    • 74.4 Detecting Device Capabilities
    • 74.5 Saving Movies and Images
    • 74.6 Summary
  • 75. An Example iOS 7 iPhone Camera Application
    • 75.1 An Overview of the Application
    • 75.2 Creating the Camera Project
    • 75.3 Designing the User Interface
    • 75.4 Implementing the Action Methods
    • 75.5 Writing the Delegate Methods
    • 75.6 Building and Running the Application
  • 76. Video Playback from within an iOS 7 Application
    • 76.1 An Overview of the MPMoviePlayerController Class
    • 76.2 Supported Video Formats
    • 76.3 The iOS Movie Player Example Application
    • 76.4 Designing the User Interface
    • 76.5 Declaring the MoviePlayer Instance
    • 76.6 Implementing the Action Method
    • 76.7 The Target-Action Notification Method
    • 76.8 Build and Run the Application
  • 77. Playing Audio on iOS 7 using AVAudioPlayer
    • 77.1 Supported Audio Formats
    • 77.2 Receiving Playback Notifications
    • 77.3 Controlling and Monitoring Playback
    • 77.4 Creating the Audio Example Application
    • 77.5 Adding an Audio File to the Project Resources
    • 77.6 Designing the User Interface
    • 77.7 Implementing the Action Methods
    • 77.8 Creating and Initializing the AVAudioPlayer Object
    • 77.9 Implementing the AVAudioPlayerDelegate Protocol Methods
    • 77.10 Building and Running the Application
  • 78. Recording Audio on iOS 7 with AVAudioRecorder
    • 78.1 An Overview of the AVAudioRecorder Tutorial
    • 78.2 Creating the Recorder Project
    • 78.3 Designing the User Interface
    • 78.4 Creating the AVAudioRecorder Instance
    • 78.5 Implementing the Action Methods
    • 78.6 Implementing the Delegate Methods
    • 78.7 Testing the Application
  • 79. Integrating Twitter and Facebook into iOS 7 Applications
    • 79.1 The UIActivityViewController class
    • 79.2 The Social Framework
    • 79.3 Accounts Framework
    • 79.4 Using the UIActivityViewController Class
    • 79.5 Using the SLComposeViewController Class
    • 79.6 Summary
  • 80. An iOS 7 Facebook Integration Tutorial using UIActivityViewController
    • 80.1 Creating the Facebook Social App
    • 80.2 Designing the User Interface
    • 80.3 Creating Outlets and Actions
    • 80.4 Implementing the selectImage and Delegate Methods
    • 80.5 Hiding the Keyboard
    • 80.6 Posting the Message to Facebook
    • 80.7 Running the Social Application
    • 80.8 Summary
  • 81. iOS 7 Facebook and Twitter Integration using SLRequest
    • 81.1 Using SLRequest and the Account Framework
    • 81.2 Twitter Integration using SLRequest
    • 81.3 Facebook Integration using SLRequest
    • 81.4 Summary
  • 82. An iOS 7 Twitter Integration Tutorial using SLRequest
    • 82.1 Creating the TwitterApp Project
    • 82.2 Designing the User Interface
    • 82.3 Modifying the Interface File
    • 82.4 Accessing the Twitter API
    • 82.5 Calling the getTimeLine Method
    • 82.6 The Table View Delegate Methods
    • 82.7 Building and Running the Application
    • 82.8 Summary
  • 83. Making Store Purchases with the SKStoreProductViewController Class
    • 83.1 The SKStoreProductViewController Class
    • 83.2 Creating the Example Project
    • 83.3 Creating the User Interface
    • 83.4 Displaying the Store Kit Product View Controller
    • 83.5 Implementing the Delegate Method
    • 83.6 Adding the Store Kit Framework to the Build Phases
    • 83.7 Testing the Application
    • 83.8 Summary
  • 84. Building In-App Purchasing into iOS 7 Applications
    • 84.1 In-App Purchase Options
    • 84.2 Uploading App Store Hosted Content
    • 84.3 Configuring In-App Purchase Items
    • 84.4 Sending a Product Request
    • 84.5 Accessing the Payment Queue
    • 84.6 The Transaction Observer Object
    • 84.7 Initiating the Purchase
    • 84.8 The Transaction Process
    • 84.9 Transaction Restoration Process
    • 84.10 Testing In-App Purchases
    • 84.11 Summary
  • 85. Preparing an iOS 7 Application for In-App Purchases
    • 85.1 About the Example Application
    • 85.2 Creating the Xcode Project
    • 85.3 Registering and enabling the App ID for In App Purchasing
    • 85.4 Configuring the Application in iTunes Connect
    • 85.5 Creating an In-App Purchase Item
    • 85.6 Summary
  • 86. An iOS 7 In-App Purchase Tutorial
    • 86.1 The Application User Interface
    • 86.2 Designing the Storyboard
    • 86.3 Creating the Purchase View Controller
    • 86.4 Completing the InAppDemoViewController Class
    • 86.5 Completing the PurchaseViewController Class
    • 86.6 Testing the Application
    • 86.7 Troubleshooting
    • 86.8 Summary
  • 87. Configuring and Creating App Store Hosted Content for iOS 7 In-App Purchases
    • 87.1 Configuring an Application for In-App Purchase Hosted Content
    • 87.2 The Anatomy of an In-App Purchase Hosted Content Package
    • 87.3 Creating an In-App Purchase Hosted Content Package
    • 87.4 Archiving the Hosted Content Package
    • 87.5 Validating the Hosted Content Package
    • 87.6 Uploading the Hosted Content Package
    • 87.7 Summary
  • 88. Preparing and Submitting an iOS 7 Application to the App Store
    • 88.1 Verifying the iOS Distribution Certificate
    • 88.2 Adding Icons and Launch Images to the Application
    • 88.3 Targeting 32-bit and 64-bit Architectures
    • 88.4 Archiving the Application for Distribution
    • 88.5 Configuring the Application in iTunes Connect
    • 88.6 Validating and Submitting the Application
  • 89. Promoting your iOS Apps using iAd Workbench
    • 89.1 An Overview of iAd Workbench
    • 89.2 Creating a New iAds Campaign
    • 89.3 Campaign Targeting Options
    • 89.4 Designing the Banner
    • 89.5 Summary

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.

You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!

So, there's no reason not to click the Add to Cart button, is there?

See full terms...

80% Royalties. Earn $16 on a $20 book.

We pay 80% royalties. That's not a typo: you earn $16 on a $20 sale. If we sell 5000 non-refunded copies of your book or course for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earnedover $13 millionwriting, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub

Publish Early, Publish Often

  • Path
  • There are many paths, but the one you're on right now on Leanpub is...
  • › Ios7devessentials

*   *   *

Leanpub is copyright © 2010-2024 Ruboss Technology Corp.
All rights reserved.

This site is protected by reCAPTCHA
and the Google Privacy Policy and Terms of Service apply.