Difference between revisions of "IPhone iOS 6 Development Essentials"

Revision as of 16:37, 9 October 2012

© 2012 Neil Smyth / Payload Media. This eBook is provided for personal use only. Unauthorized use, reproduction and/or distribution strictly prohibited. All rights reserved.

Table of Contents

1. The Basics of Modern Objective-C
   • Default Property Synthesis
   • Method Ordering
   • NSNumber Literals
   • Array Literals
   • Dictionary Literals
     
     
2. An Introduction to Auto Layout in iOS 6
   • 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
     
     
3. Working with iOS 6 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
   • Automatic Constraints
   • Visual Cues
   • Viewing and Editing Constraints Details
   • Creating New Constraints in Interface Builder
     
     
4. An iPhone iOS 6 Auto Layout Example
   • Preparing the Project
   • Designing the User Interface
   • Adjusting Constraint Priorities
   • Alignment and Width Equality
   • Testing the Application
     
     
5. Implementing iOS 6 Auto Layout Constraints in 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
     
     
6. Implementing Cross-Hierarchy Auto Layout Constraints in iOS 6
   • The Example Application
   • Establishing Outlets
   • Writing the Code to Remove the Old Constraint
   • Adding the Cross Hierarchy Constraint
   • Testing the Application
     
     
7. Understanding the iOS 6 Auto Layout Visual Format Language
   • Introducing the Visual Format Language
   • Visual Language Format Examples
   • Using the constraintsWithVisualFormat: Method
     
     
8. Using Xcode Storyboarding
   • 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
     
     
9. Using Xcode Storyboards to create an iOS 6 iPhone 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
   • Renaming the Initial View Controller
   • Adding the View Controller for the Second Content View
   • Adding the Tab Bar Controller to the Storyboard
   • Adding a Second View Controller to the Storyboard
   • Designing the View Controller User interfaces
   • Configuring the Tab Bar Items
   • Building and Running the Application
     
     
10. An Overview of iOS 6 Table Views and Xcode Storyboards
    • An Overview of the Table View
    • Static vs. Dynamic Table Views
    • The Table View Delegate and dataSource
    • Table View Styles
    • Table View Cell Styles
    • Table View Cell Reuse
      
      
11. Using Xcode Storyboards 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 CarTableViewCell Class
    • Creating the Table View Datasource
    • Downloading and Adding the Image Files
    • Compiling and Running the Application
      
      
12. Implementing TableView Navigation using Xcode Storyboards
    • Understanding the Navigation Controller
    • Adding the New Scene to the Storyboard
    • Adding a Navigation Controller
    • Establishing the Storyboard Segue
    • Modifying the CarDetailViewController Class
    • Using prepareForSegue: to Pass Data between Storyboard Scenes
    • Testing the Application
      
      
13. Using an Xcode Storyboard to Create a Static Table View
    • An Overview of the Static Table Project
    • Creating the Project
    • Adding a Table View Controller
    • Changing the Table View Content Type
    • Designing the Static Table
    • Adding Items to the Table Cells
    • Modifying the StaticTableViewController Class
    • Building and Running the Application
      
      
14. Implementing a Page based iOS 6 iPhone Application using UIPageViewController
    • The UIPageViewController Class
    • The UIPageViewController DataSource
    • Navigation Orientation
    • Spine Location
    • The UIPageViewController Delegate Protocol
      
      
15. An Example iOS 6 iPhone 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
      
      
16. Using the UIPickerView and UIDatePicker Components
    • The DatePicker and PickerView Components
    • A DatePicker Example
    • Designing the User Interface
    • Coding the Date Picker Example Functionality
    • Building and Running the iPhone Date Picker Application
      
      
17. An iOS 6 iPhone UIPickerView Example
    • Creating the iOS 6 PickerView Project
    • UIPickerView Delegate and DataSource
    • The PickerViewController.h File
    • Designing the User Interface
    • Initializing the Arrays
    • Implementing the DataSource Protocol
    • Implementing the Delegate Protocol
    • Hiding the Keyboard
    • Testing the Application
      
      
18. Working with Directories on iOS 6
    • The Application Documents Directory
    • The Objective-C NSFileManager, NSFileHandle and NSData Classes
    • Understanding Pathnames in Objective-C
    • Obtaining a Reference to the Default NSFileManager Object
    • Identifying the Current Working Directory
    • Identifying the Documents Directory
    • Identifying the Temporary Directory
    • Changing Directory
    • Creating a New Directory
    • Deleting a Directory
    • Listing the Contents of a Directory
    • Getting the Attributes of a File or Directory
      
      
19. Working with iPhone Files on iOS 6
    • 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
      
      
20. iOS 6 iPhone Directory Handling and File I/O – A Worked Example
    • The Example iPhone 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
      
      
21. Preparing an iOS 6 App to use iCloud Storage
    • What is iCloud?
    • iCloud Data Storage Services
    • Preparing an Application to Use iCloud Storage
    • Creating an iOS 6 iCloud enabled App ID
    • Creating and Installing an iCloud Enabled Provisioning Profile
    • Creating an iCloud Entitlements File
    • Manually Creating the Entitlements File
    • Accessing Multiple Ubiquity Containers
    • Ubiquity Container URLs
      
      
22. Managing Files using the iOS 6 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
      
      
23. Using iCloud Storage in an iOS 6 iPhone 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 on an iPhone
    • Running the iCloud Application
    • Reviewing and Deleting iCloud Based Documents
    • Making a Local File Ubiquitous
      
      
24. Synchronizing iPhone iOS 6 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
      
      
25. iOS 6 iPhone Data Persistence using Archiving
    • 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
      
      
26. iOS 6 iPhone Database Implementation using SQLite
    • What is SQLite?
    • Structured Query Language (SQL)
    • Trying SQLite on MacOS X
    • Preparing an iPhone Application Project for SQLite Integration
    • Key SQLite Functions
    • Declaring a SQLite Database
    • Opening or Creating a Database
    • Preparing and Executing a SQL Statement
    • Creating a Database Table
    • Extracting Data from a Database Table
    • Closing a SQLite Database
      
      
27. An Example SQLite based iOS 6 iPhone Application
    • About the Example SQLite iPhone Application
    • Creating and Preparing the SQLite Application Project
    • Importing sqlite3.h and declaring the Database Reference
    • 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
      
      
28. Working with iOS 6 iPhone Databases 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
    • Creating a Managed Object
    • Getting and Setting the Attributes of a Managed Object
    • Fetching Managed Objects
    • Retrieving Managed Objects based on Criteria
      
      
29. An iOS 6 iPhone Core Data Tutorial
30. An Overview of iOS 6 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
      
      
31. An iPhone iOS 6 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
    • Deleting Collection View Items
      
      
32. Subclassing and Extending the iOS 6 Collection View Flow Layout
    • 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
    • Adding the QuartzCore Framework to the Project
    • Testing the Application
      
      
33. Drawing iOS 6 iPhone 2D Graphics with Quartz
    • Introducing Core Graphics and Quartz 2D
    • The drawRect Method
    • Points, Coordinates and Pixels
    • The Graphics Context
    • Working with Colors in Quartz 2D
      
      
34. An iOS 6 iPhone Graphics Tutorial using Quartz 2D and Core Image
    • The iOS iPhone Drawing Example Application
    • Creating the New Project
    • Creating the UIView Subclass
    • Locating the drawRect Method in the UIView Subclass
    • Drawing a Line
    • Drawing Paths
    • 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 an Image into a Graphics Context
    • Image Filtering with the Core Image Framework
      
      
35. Basic iOS 6 iPhone 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 Interface File
    • Drawing in the UIView
    • Detecting Screen Touches and Performing the Animation
    • Building and Running the Animation Application
      
      
36. Integrating iAds into an iOS 6 iPhone App
    • iOS iPhone Advertising Options
    • iAds Advertisement Formats
    • Basic Rules for the Display of iAds
    • Creating an Example iAds iPhone Application
    • Adding the iAds Framework to the Xcode Project
    • Configuring the View Controller
    • Designing the User Interface
    • Creating the Banner Ad
    • Displaying the Ad
    • Implementing the Delegate Methods
      
      
37. An Overview of iOS 6 iPhone Multitasking
    • Understanding iOS Application States
    • A Brief Overview of the Multitasking Application Lifecycle
    • Disabling Multitasking for an iOS Application
    • Checking for Multitasking Support
    • Supported Forms of Background Execution
    • The Rules of Background Execution
    • Scheduling Local Notifications
      
      
38. Scheduling iOS 6 iPhone Local Notifications
    • Creating the Local Notification iPhone App Project
    • Locating the Application Delegate Method
    • Adding a Sound File to the Project
    • Scheduling the Local Notification
    • Testing the Application
    • Cancelling Scheduled Notifications
    • Immediate Triggering of a Local Notification
      
      
39. An Overview of iOS 6 Application State Preservation and Restoration
    • The Preservation and Restoration Process
    • Opting In to Preservation and Restoration
    • Assigning Restoration Identifiers
    • Default Preservation Features of UIKit
    • Saving and Restoring Additional State Information
    • Understanding the Restoration Process
    • Saving General Application State
      
      
40. An iOS 6 iPhone State Preservation and Restoration Tutorial
    • Creating the Example Application
    • Trying the Application without State Preservation
    • Opting-in to State Preservation
    • Setting Restoration Identifiers
    • Encoding and Decoding View Controller State
    • Adding a Navigation Controller to the Storyboard
    • Adding the Third View Controller
    • Creating the Restoration Class
      
      
41. Integrating Maps into iPhone iOS 6 Applications using MKMapItem
    • 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
      
      
42. An Example iOS 6 iPhone MKMapItem Application
    • Creating the MapItem Project
    • Designing the User Interface
    • Converting the Destination using Forward Geocoding
    • Launching the Map
    • Adding Build Libraries
    • Building and Running the Application
      
      
43. Getting iPhone Location Information using the iOS 6 Core Location Framework
    • The Basics of Core Location
    • Configuring the Desired Location Accuracy
    • Configuring the Distance Filter
    • The Location Manager Delegate
    • Obtaining Location Information from CLLocation Objects
    • Longitude and Latitude
    • Accuracy
    • Altitude
    • Calculating Distances
    • Location Information and Multitasking
      
      
44. An Example iOS 6 iPhone Location Application
    • Creating the Example iOS 6 iPhone Location Project
    • Adding the Core Location Framework to the Project
    • Designing the User Interface
    • Creating the CLLocationManager Object
    • Implementing the Action Method
    • Implementing the Application Delegate Methods
    • Building and Running the iPhone Location Application
      
      
45. Working with Apple Maps on the iPhone with MapKit and the MKMapView Class
    • About the MapKit Framework
    • Understanding Map Regions
    • About the iPhone MKMapView Tutorial
    • Creating the iPhone Map Tutorial
    • Adding the MapKit Framework to the Xcode Project
    • Creating the MKMapView Instance and Toolbar
    • Configuring the Map View
    • Changing the MapView Region
    • Changing the Map Type
    • Testing the iPhone MapView Application
    • Updating the Map View based on User Movement
    • Adding Basic Annotations to a Map View
      
      
46. Using iOS 6 Event Kit to Create Date and Location Based Reminders
    • An Overview of the Event Kit Framework
    • The EKEventStore Class
    • Accessing Calendars in the Database
    • Accessing Current Reminders
    • 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 Location-based Reminder Screen
    • Creating a Location-based Reminder
    • Adding the Core Location and Event Kit Frameworks
    • Testing the Application
      
      
47. Accessing the iPhone Camera and Photo Library
    • The iOS 6 UIImagePickerController Class
    • Creating and Configuring a UIImagePickerController Instance
    • Configuring the UIImagePickerController Delegate
    • Detecting Device Capabilities
    • Saving Movies and Images
      
      
48. An Example iOS 6 iPhone Camera Application
    • An Overview of the Application
    • Creating the Camera Project
    • Adding Framework Support
    • Designing the User Interface
    • Implementing the Action Methods
    • Writing the Delegate Methods
    • Building and Running the Application
      
      
49. Video Playback from within an iOS 6 iPhone Application
    • An Overview of the MPMoviePlayerController Class
    • Supported Video Formats
    • The iPhone Movie Player Example Application
    • Adding the MediaPlayer Framework to the Project
    • Designing the User Interface
    • Declaring the MoviePlayer Instance
    • Implementing the Action Method
    • The Target-Action Notification Method
    • Build and Run the Application
      
      
50. Playing Audio on an iPhone using AVAudioPlayer
    • Supported Audio Formats
    • Receiving Playback Notifications
    • Controlling and Monitoring Playback
    • Creating the iPhone Audio Example Application
    • Adding the AVFoundation Framework
    • 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
      
      
51. Recording Audio on an iPhone with AVAudioRecorder
    • An Overview of the iPhone 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
      
      
52. Integrating Twitter and Facebook into iPhone iOS 6 Applications
    • The iOS 6 UIActivityController class
    • The Social Framework
    • iOS 6 Accounts Framework
    • Using the UIActivityViewController Class
    • Using the SLComposeViewController Class
      
      
53. An iPhone iOS 6 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
    • Adding the Social Framework to the Build Phases
    • Running the Social Application
      
      
54. iPhone iOS 6 Facebook and Twitter Integration using SLRequest
    • Using SLRequest and the Account Framework
    • Twitter Integration using SLRequest
    • Facebook Integration using SLRequest
      
      
55. An iOS 6 iPhone Twitter Integration Tutorial using SLRequest
    • Creating the TwitterApp Project
    • Designing the User Interface
    • Modifying the Interface File
    • Accessing the Twitter API
    • Calling the getTimeLine Method
    • The Table View Delegate Methods
    • Adding Account and Social Framework to the Build Phases
    • Building and Running the Application
      
      
56. Making Store Purchases 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
    • Adding the Store Kit Framework to the Build Phases
    • Testing the Application
      
      
57. Building In-App Purchasing into iPhone iOS 6 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
      
      
58. Preparing an iOS 6 Application for In-App Purchases
    • About the Example Application
    • Creating the App ID
    • Creating the Provisioning Profile
    • Creating the Xcode Project
    • Installing the Provisioning Profile
    • Configuring Code Signing
    • Configuring the Application in iTunes Connect
    • Creating an In-App Purchase Item
      
      
59. An iPhone iOS 6 In-App Purchase Tutorial
    • The Application User Interface
    • Designing the Storyboard
    • Creating the Purchase View Controller
    • Completing the InAppDemoViewController Class
    • Completing the PurchaseViewController Class
    • Adding the StoreKit Framework to the Build
    • Testing the Application
    • Troubleshooting
      
      
60. Configuring and Creating App Store Hosted Content for iOS 6 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