1, Start Here
For New iOS Developers
For iOS 6 Developers
Source Code Download
Errata
Joining the Apple iOS 7 Developer Program
Registered Apple Developer
Downloading Xcode and the iOS 7 SDK
iOS Developer Program
When to Enroll in the iOS Developer Program?
Enrolling in the iOS Developer Program
Installing Xcode 5 and the iOS 7 SDK
Identifying if you have an Intel or PowerPC based Mac
Installing Xcode 5 and the iOS 7 SDK
Starting Xcode
Creating a Simple iOS 7 App
Starting Xcode 5
Creating the iOS App User Interface
Changing Component Properties
Adding Objects to the User Interface
Building and Running an iOS 7 App in Xcode 5
Dealing with Build Errors
Testing Different Screen Sizes
Testing User Interface Appearance in Different iOS Versions
Monitoring Application Performance
Testing Apps on iOS 7 Devices with Xcode 5
Configuring Xcode with Apple IDs
Generating Signing Identities
Adding a Device to the Developer Portal
Running an Application on a Registered Device
Creating an Interactive iOS 7 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
Writing iOS 7 Code to Hide the Keyboard
Creating the Example App
Hiding the Keyboard when the User Touches the Return Key
Hiding the Keyboard when the User Taps the Background
An Introduction to Auto Layout in iOS 7
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
Working with iOS 7 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
Resolving Auto Layout Problems
An iOS 7 Auto Layout Example
Preparing the Project
Designing the User Interface
Adding Auto Layout Constraints
Adjusting Constraint Priorities
Testing the Application
Implementing iOS 7 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
Implementing Cross-Hierarchy Auto Layout Constraints in iOS 7
The Example Application
Establishing Outlets
Writing the Code to Remove the Old Constraint
Adding the Cross Hierarchy Constraint
Testing the Application
Understanding the iOS 7 Auto Layout Visual Format Language
Introducing the Visual Format Language
Visual Language Format Examples
Using the constraintsWithVisualFormat: Method
Using Storyboards in Xcode 5
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
Using Xcode 5 Storyboards to Create an iOS 7 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
An Overview of iOS 7 Table Views and Xcode 5 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
Using Xcode 5 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
Implementing iOS 7 TableView Navigation using Storyboards in Xcode 5
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
Using an Xcode 5 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
An iPad iOS 7 Split View and Popover Example
An Overview of Split View and Popovers
About the Example iPad Split View and Popover Project
Creating the Project
Reviewing the Project
Configuring Master View Items
Configuring the Detail View Controller
Connecting Master Selections to the Detail View
Popover Implementation
Testing the Application
Implementing a Page based iOS 7 Application using UIPageViewController
The UIPageViewController Class
The UIPageViewController DataSource
Navigation Orientation
Spine Location
The UIPageViewController Delegate Protocol
An Example iOS 7 UIPageViewController Application
The Xcode Page-based Application Template
Creating the Project
Adding the Content View Controller
Creating the Data Model
Running the UIPageViewController Application
Using the iOS 7 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 Date Picker Application
An iOS 7 UIPickerView Example
Creating the iOS 7 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
Working with Directories on iOS 7
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
Working with Files on iOS 7
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
iOS 7 Directory Handling and File I/O – 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
Preparing an iOS 7 App to use iCloud Storage
What is iCloud?
iCloud Data Storage Services
Preparing an Application to Use iCloud Storage
Enabling iCloud Support for an iOS 7 Application
Reviewing the iCloud Entitlements File
Manually Creating the Entitlements File
Accessing Multiple Ubiquity Containers
Ubiquity Container URLs
Managing Files using the iOS 7 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
Using iCloud Storage in an iOS 7 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
Reviewing iCloud Activities in the Xcode Debugging Debug Navigator
Making a Local File Ubiquitous
Synchronizing iOS 7 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
iOS 7 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
iOS 7 Database Implementation using SQLite
What is SQLite?
Structured Query Language (SQL)
Trying SQLite on MacOS X
Preparing an iOS 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
An Example SQLite based iOS 7 Application
About the Example SQLite 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
Working with iOS 7 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
An iOS 7 Core Data Tutorial
The Core Data Example Application
Creating a Core Data based Application
Creating the Entity Description
Adding a Storyboard to the Project
Adding a View Controller
Designing the User Interface
Saving Data to the Persistent Store using Core Data
Retrieving Data from the Persistent Store using Core Data
Building and Running the Example Application
An Overview of iOS 7 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
An Example iOS 7 Touch, Multitouch and Tap Application
The Example iOS 7 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
Detecting iOS 7 Touch Screen Gesture Motions
The Example iOS 7 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
Identifying Gestures using iOS 7 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
An iOS 7 Gesture Recognition Tutorial
Creating the Gesture Recognition Project
Designing the User Interface
Implementing the Action Methods
Testing the Gesture Recognition Application
An Overview of iOS 7 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
An iOS 7 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
Subclassing and Extending the iOS 7 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
Testing the Application
Drawing iOS 7 2D Graphics 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
An iOS 7 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 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 Shadows
Drawing Gradients
Drawing an Image into a Graphics Context
Image Filtering with the Core Image Framework
Basic iOS 7 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
iOS 7 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 7 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
An iOS 7 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
An Introduction to iOS 7 Sprite Kit 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
An Example Sprite Kit Game Hierarchy
The Sprite Kit Game Rendering Loop
An iOS 7 Sprite Kit Game Tutorial
About the Sprite Kit Demo Game
Creating the SpriteKitDemo Project
Reviewing the SpriteKit Game Template Project
Creating the Game Scene Classes
Implementing the Welcome Scene
Transitioning to the Archery Scene
Preparing the Archery Scene
Adding the Texture Atlas
Obtaining a Texture from the Atlas
Preparing the Animation Texture Atlas
Animating the Archer Sprite Node
Creating the Arrow Sprite Node
Shooting the Arrow
Adding the Ball Sprite Node
An iOS 7 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
An iOS 7 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
Integrating iAds into an iOS 7 App
iOS Advertising Options
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
Going Live with iAds
iOS 7 Multitasking, Background Transfer Service and Fetching
Understanding iOS Application States
A Brief Overview of the Multitasking Application Lifecycle
Checking for Multitasking Support
Enabling Multitasking for an iOS Application
Supported Forms of Background Execution
An Overview of Background Fetch
An Overview of Remote Notifications
An Overview of Local Notifications
An Overview of Background Transfer Service
The Rules of Background Execution
An iOS 7 Background Transfer Service Tutorial
Creating the Example Project
The handleEventsForBackgroundURLSession Method
Designing the User Interface
Configuring the View Controller
Implementing the Session Delegate Methods
Testing the Application
Scheduling iOS 7 Local Notifications
Creating the Local Notification App Project
Adding a Sound File to the Project
Locating the Application Delegate Method
Scheduling the Local Notification
Testing the Application
Cancelling Scheduled Notifications
Immediate Triggering of a Local Notification
An Overview of iOS 7 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
An iOS 7 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
Integrating Maps into iOS 7 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
An Example iOS 7 MKMapItem Application
Creating the MapItem Project
Designing the User Interface
Converting the Destination using Forward Geocoding
Launching the Map
Building and Running the Application
Getting Location Information using the iOS 7 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
An Example iOS 7 Location Application
Creating the Example iOS 7 Location Project
Designing the User Interface
Creating the CLLocationManager Object
Implementing the Action Method
Implementing the Application Delegate Methods
Building and Running the Location Application
Working with Maps on iOS 7 with 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
Configuring the Map View
Changing the MapView Region
Changing the Map Type
Testing the MapView Application
Updating the Map View based on User Movement
Working with MapKit Local Search in iOS 7
An Overview of iOS 7 Local Search
Adding Local Search to the MapSample Application
Adding the Local Search Text Field
Performing the Local Search
Testing the Application
Using MKDirections to get iOS 7 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
Using iOS 7 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 the Location-based Reminder Screen
Creating a Location-based Reminder
Testing the Application
Accessing the iOS 7 Camera and Photo Library
The UIImagePickerController Class
Creating and Configuring a UIImagePickerController Instance
Configuring the UIImagePickerController Delegate
Detecting Device Capabilities
Saving Movies and Images
An Example iOS 7 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
Video Playback from within an iOS 7 Application
An Overview of the MPMoviePlayerController Class
Supported Video Formats
The iOS Movie Player Example Application
Designing the User Interface
Declaring the MoviePlayer Instance
Implementing the Action Method
The Target-Action Notification Method
Build and Run the Application
Playing Audio on iOS 7 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
Recording Audio on iOS 7 with AVAudioRecorder
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
Integrating Twitter and Facebook into iOS 7 Applications
The UIActivityViewController class
The Social Framework
Accounts Framework
Using the UIActivityViewController Class
Using the SLComposeViewController Class
An iOS 7 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
iOS 7 Facebook and Twitter Integration using SLRequest
Using SLRequest and the Account Framework
Twitter Integration using SLRequest
Facebook Integration using SLRequest
An iOS 7 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
Building and Running the Application
Making Store Purchases with the iOS 7 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
Building In-App Purchasing into iOS 7 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
Preparing an iOS 7 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
An iOS 7 In-App Purchase Tutorial
The Application User Interface
Designing the Storyboard
Creating the Purchase View Controller
Completing the InAppDemoViewController Class
Completing the PurchaseViewController Class
Testing the Application
Troubleshooting
Configuring and Creating App Store Hosted Content for iOS 7 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
Preparing and Submitting an iOS 7 Application to the App Store
Verifying the iOS Distribution Certificate
Adding Icons and Launch Images to the Application
Targeting 32-bit and 64-bit Architectures
Archiving the Application for Distribution
Configuring the Application in iTunes Connect
Validating and Submitting the Application
Promoting your iOS Apps using iAd Workbench
An Overview of iAd Workbench
Creating a New iAds Campaign
Campaign Targeting Options
Designing the Banner
