Beginning iOS 5 Development · Exploring the iOS SDK by Dave Mark, Jack Nutting, Jeff LaMarche -- Read -- Imperial Library of Trantor

Index

Cover Title Copyright Dedication Contents at a Glance Contents 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 Outlets Actions

Cleaning Up the View Controller

Designing the User Interface Adding the Buttons and Action Method Adding the Label and Outlet Writing the Action Method 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 CreatingTabBarController.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 The Master View Controller The Detail View Controller

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

← Prev
Back
Next →

← Prev
Back
Next →