Contents
Contents at a Glance
About the Authors
About the Technical Reviewer
Acknowledgments
Preface
Chapter 1: Welcome to the Jungle
What This Book Is
What You Need
Developer Options
What You Need to Know
What's Different About Coding for iOS?
Only One Active Application
Only One Window
Limited Access
Limited Response Time
Limited Screen Size
Limited System Resources
No Garbage Collection, but…
Some New Stuff
A Different Approach
What's in This Book
What's New in This Update?
Are You Ready?
Chapter 2: Appeasing the Tiki Gods
Setting Up Your Project in Xcode
The Xcode Workspace Window
A Closer Look at Our Project
Introducing Xcode's Interface Builder
What's in the Nib File?
The Library
Adding a Label to the View
Changing Attributes
Some iPhone Polish—Finishing Touches
Bring It on Home
Chapter 3: Handling Basic Interaction
The Model-View-Controller Paradigm
Creating Our Project
Looking at the View Controller
Understanding Outlets and Actions
Cleaning Up the View Controller
Designing the User Interface
Trying It Out
Looking at the Application Delegate
Bring It on Home
Chapter 4: More User Interface Fun
A Screen Full of Controls
Active, Static, and Passive Controls
Creating the Application
Implementing the Image View and Text Fields
Adding the Image View
Resizing the Image View
Setting View Attributes
Adding the Text Fields
Creating and Connecting Outlets
Closing the Keyboard
Closing the Keyboard When Done Is Tapped
Touching the Background to Close the Keyboard
Adding the Slider and Label
Creating and Connecting the Actions and Outlets
Implementing the Action Method
Implementing the Switches, Button, and Segmented Control
Implementing the Switch Actions
Implementing the Segmented Control Action
Implementing the Action Sheet and Alert
Conforming to the Action Sheet Delegate Method
Showing the Action Sheet
Spiffing Up the Button
Using the viewDidLoad Method
Control States
Stretchable Images
Crossing the Finish Line
Chapter 5: Autorotation and Autosizing
The Mechanics of Autorotation
Points, Pixels, and the Retina Display
Autorotation Approaches
Handling Rotation Using Autosize Attributes
Configuring Supported Orientations
Specifying Rotation Support
Designing an Interface with Autosize Attributes
Using the Size Inspector's Autosize Attributes
Setting the Buttons' Autosize Attributes
Restructuring a View When Rotated
Creating and Connecting Outlets
Moving the Buttons on Rotation
Swapping Views
Designing the Two Views
Implementing the Swap
Changing Outlet Collections
Rotating Out of Here
Chapter 6: Multiview Applications
Common Types of Multiview Apps
The Architecture of a Multiview Application
The Root Controller
Anatomy of a Content View
Building View Switcher
Creating Our View Controller and Nib Files
Modifying the App Delegate
Modifying BIDSwitchViewController.h
Adding a View Controller
Building a View with a Toolbar
Writing the Root View Controller
Implementing the Content Views
Animating the Transition
Switching Off
Chapter 7: Tab Bars and Pickers
The Pickers Application
Delegates and Data Sources
Setting Up the Tab Bar Framework
Creating the Files
Adding the Root View Controller
Creating TabBarController.xib
The Initial Test Run
Implementing the Date Picker
Implementing the Single-Component Picker
Declaring Outlets and Actions
Building the View
Implementing the Controller As a Data Source and Delegate
Implementing a Multicomponent Picker
Declaring Outlets and Actions
Building the View
Implementing the Controller
Implementing Dependent Components
Creating a Simple Game with a Custom Picker
Writing the Controller Header File
Building the View
Adding Image Resources
Implementing the Controller
Final Details
Linking in the Audio Toolbox Framework
Final Spin
Chapter 8: Introduction to Table Views
Table View Basics
Table Views and Table View Cells
Grouped and Plain Tables
Implementing a Simple Table
Designing the View
Writing the Controller
Adding an Image
Using Table View Cell Styles
Setting the Indent Level
Handling Row Selection
Changing the Font Size and Row Height
Customizing Table View Cells
Adding Subviews to the Table View Cell
Creating a UITableViewCell Subclass
Loading a UITableViewCell from a Nib
Grouped and Indexed Sections
Building the View
Importing the Data
Implementing the Controller
Adding an Index
Implementing a Search Bar
Rethinking the Design
A Deep Mutable Copy
Updating the Controller Header File
Modifying the View
Modifying the Controller Implementation
Putting It All on the Table
Chapter 9: Navigation Controllers and Table Views
Navigation Controller Basics
Stacky Goodness
A Stack of Controllers
Nav, a Hierarchical Application in Six Parts
Meet the Subcontrollers
The Nav Application's Skeleton
Adding the Images to the Project
First Subcontroller: The Disclosure Button View
Second Subcontroller: The Checklist
Third Subcontroller: Controls on Table Rows
Fourth Subcontroller: Movable Rows
Fifth Subcontroller: Deletable Rows
Sixth Subcontroller: An Editable Detail Pane
But There's One More Thing. . .
Breaking the Tape
Chapter 10: Storyboards
Creating a Simple Storyboard
Dynamic Prototype Cells
Dynamic Table Content, Storyboard-Style
Editing Prototype Cells
Good Old Table View Data Source
Will It Load?
Static Cells
Going Static
So Long, Good Old Table View Data Source
You Say Segue, I Say Segue
Creating Segue Navigator
Filling the Blank Slate
First Transition
A Slightly More Useful Task List
Viewing Task Details
Make More Segues, Please
Passing a Task from the List
Handling Task Details
Passing Back Details
Making the List Receive the Details
If Only We Could End with a Smooth Transition
Chapter 11: iPad Considerations
Split Views and Popovers
Creating a SplitView Project
The Storyboard Defines the Structure
The Code Defines the Functionality
Here Come the Presidents
Creating Your Own Popover
iPad Wrap-Up
Chapter 12: Application Settings and User Defaults
Getting to Know Your Settings Bundle
The AppSettings Application
Creating the Project
Working with the Settings Bundle
Reading Settings in Our Application
Registering Default Values
Changing Defaults from Our Application
Keeping It Real
Beam Me Up, Scotty
Chapter 13: Basic Data Persistence
Your Application's Sandbox
Getting the Documents Directory
Getting the tmp Directory
File-Saving Strategies
Single-File Persistence
Multiple-File Persistence
Using Property Lists
Property List Serialization
The First Version of the Persistence Application
Archiving Model Objects
Conforming to NSCoding
Implementing NSCopying
Archiving and Unarchiving Data Objects
The Archiving Application
Using iOS's Embedded SQLite3
Creating or Opening the Database
Using Bind Variables
The SQLite3 Application
Using Core Data
Entities and Managed Objects
The Core Data Application
Persistence Rewarded
Chapter 14: Hey! You! Get onto iCloud!
Managing Document Storage with UIDocument
Building TinyPix
Creating BIDTinyPixDocument
Code Master
Initial Storyboarding
Creating BIDTinyPixView
Storyboard Detailing
Adding iCloud Support
Creating a Provisioning Profile
Enabling iCloud Entitlements
How to Query
Save Where?
Storing Preferences on iCloud
What We Didn't Cover
Chapter 15: Grand Central Dispatch, Background Processing, and You
Grand Central Dispatch
Introducing SlowWorker
Threading Basics
Units of Work
GCD: Low-Level Queueing
Becoming a Blockhead
Improving SlowWorker
Background Processing
Application Life Cycle
State-Change Notifications
Creating State Lab
Exploring Execution States
Making Use of Execution State Changes
Handling the Inactive State
Handling the Background State
Grand Central Dispatch, Over and Out
Chapter 16: Drawing with Quartz and OpenGL
Two Views of a Graphical World
The Quartz 2D Approach to Drawing
Quartz 2D's Graphics Contexts
The Coordinate System
Specifying Colors
Drawing Images in Context
Drawing Shapes: Polygons, Lines, and Curves
Quartz 2D Tool Sampler: Patterns, Gradients, and Dash Patterns
The QuartzFun Application
Setting Up the QuartzFun Application
Adding Quartz 2D Drawing Code
Optimizing the QuartzFun Application
The GLFun Application
Setting Up the GLFun Application
Creating BIDGLFunView
Updating BIDViewController
Updating the Nib
Finishing GLFun
Drawing to a Close
Chapter 17: Taps, Touches, and Gestures
Multitouch Terminology
The Responder Chain
Responding to Events
Forwarding an Event: Keeping the Responder Chain Alive
The Multitouch Architecture
The Four Touch Notification Methods
The TouchExplorer Application
The Swipes Application
Automatic Gesture Recognition
Implementing Multiple Swipes
Detecting Multiple Taps
Detecting Pinches
Defining Custom Gestures
The CheckPlease Application
The CheckPlease Touch Methods
Garçon? Check, Please!
Chapter 18: Where Am I? Finding Your Way with Core Location
The Location Manager
Setting the Desired Accuracy
Setting the Distance Filter
Starting the Location Manager
Using the Location Manager Wisely
The Location Manager Delegate
Getting Location Updates
Getting Latitude and Longitude Using CLLocation
Error Notifications
Trying Out Core Location
Updating Location Manager
Determining Distance Traveled
Wherever You Go, There You Are
Chapter 19: Whee! Gyro and Accelerometer!
Accelerometer Physics
Don’t Forget Rotation
Core Motion and the Motion Manager
Event-Based Motion
Proactive Motion Access
Accelerometer Results
Detecting Shakes
Baked-In Shaking
Shake and Break
Accelerometer As Directional Controller
Rolling Marbles
Writing the Ball View
Calculating Ball Movement
Rolling On
Chapter 20: The Camera and Photo Library
Using the Image Picker and UIImagePickerController
Implementing the Image Picker Controller Delegate
Road Testing the Camera and Library
Designing the Interface
Implementing the Camera View Controller
It’s a Snap!
Chapter 21: Application Localization
Localization Architecture
Strings Files
What’s in a Strings File?
The Localized String Macro
Real-World iOS: Localizing Your Application
Setting Up LocalizeMe
Trying Out LocalizeMe
Localizing the Nib
Localizing an Image
Generating and Localizing a Strings File
Localizing the App Display Name
Auf Wiedersehen
Chapter 22: Where to Next?
Apple’s Documentation
Mailing Lists
Discussion Forums
Web Sites
Blogs
Conferences
Follow the Authors
Farewell
Index
