programming ios 7, 4th edition

www.it-ebooks.info
www.it-ebooks.info
Matt Neuburg
FOURTH EDITION
Programming iOS 7
www.it-ebooks.info
Programming iOS 7, Fourth Edition
by Matt Neuburg
Copyright © 2014 Matt Neuburg. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are
also available for most titles (). For more information, contact our corporate/
institutional sales department: (800) 998-9938 or
Editor: Rachel Roumeliotis
Production Editor: Kristen Brown
Proofreader: O’Reilly Production Services
Indexer: Matt Neuburg
Cover Designer: Randy Comer
Interior Designer: David Futato
Illustrator: Matt Neuburg
May 2011:
First Edition
March 2012:
Second Edition
March 2013: Third Edition
December 2013:
Fourth Edition
Revision History for the Fourth Edition:
2013-12-09: First release
See for release details.

Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly
Media, Inc. Programming iOS 7, the image of a kingbird, and related trade dress are trademarks of O’Reilly
Media, Inc.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as
trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trade‐
mark claim, the designations have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the publisher and author assume no
responsibility for errors or omissions, or for damages resulting from the use of the information contained
herein.
ISBN: 978-1-449-37234-7
[LSI]
www.it-ebooks.info
Table of Contents
Preface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xv
Part I. Views
1.
Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
The Window 4
Experimenting With Views 7
Subview and Superview 8
Visibility and Opacity 11
Frame 12
Bounds and Center 13
Transform 16
Layout 22
Autoresizing 23
Autolayout 27
Constraints in the Nib 38
Order of Layout Events 45
Autolayout and View Transforms 46

2.
Drawing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
UIImage and UIImageView 49
Resizable Images 53
Image Rendering Mode 56
Graphics Contexts 58
UIImage Drawing 61
CGImage Drawing 63
Snapshots 66
CIFilter and CIImage 68
Drawing a UIView 72
iii
www.it-ebooks.info
Graphics Context Settings 74
Paths and Shapes 75
Clipping 79
Gradients 80
Colors and Patterns 82
Graphics Context Transforms 84
Shadows 86
Erasing 87
Points and Pixels 88
Content Mode 89
3.
Layers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
View and Layer 92
Layers and Sublayers 94
Manipulating the Layer Hierarchy 97
Positioning a Sublayer 98
CAScrollLayer 99

Layout of Sublayers 99
Drawing in a Layer 100
Content Resizing and Positioning 104
Layers that Draw Themselves 106
Transforms 108
Depth 111
Shadows, Borders, and Masks 115
Layer Efficiency 116
Layers and Key–Value Coding 118
4.
Animation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Drawing, Animation, and Threading 122
UIImageView and UIImage Animation 125
View Animation 126
Block-Based View Animation 127
View Animation Options 129
Springing View Animation 134
Keyframe View Animation 134
Transitions 136
Implicit Layer Animation 138
Animation Transactions 140
Media Timing Functions 141
Core Animation 143
CABasicAnimation and Its Inheritance 143
Using a CABasicAnimation 145
iv | Table of Contents
www.it-ebooks.info
Keyframe Animation 149
Making a Property Animatable 150
Grouped Animations 151

Transitions 155
Animations List 157
Actions 159
What an Action Is 160
Action Search 160
Hooking Into the Action Search 162
Nonproperty Actions 164
Emitter Layers 166
CIFilter Transitions 171
UIKit Dynamics 174
Motion Effects 180
Animation and Autolayout 181
5. Touches. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Touch Events and Views 186
Receiving Touches 187
Restricting Touches 189
Interpreting Touches 190
Gesture Recognizers 195
Gesture Recognizer Classes 195
Gesture Recognizer Conflicts 200
Subclassing Gesture Recognizers 203
Gesture Recognizer Delegate 205
Gesture Recognizers in the Nib 207
Touch Delivery 208
Hit-Testing 208
Initial Touch Event Delivery 214
Gesture Recognizer and View 214
Touch Exclusion Logic 216
Gesture Recognition Logic 216
Touches and the Responder Chain 218

Part II. Interface
6.
View Controllers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
View Controller Responsibilities 224
View Controller Hierarchy 225
View Controller Creation 231
Table of Contents | v
www.it-ebooks.info
How a View Controller Gets Its View 234
Manual View 235
Generic Automatic View 237
View in a Separate Nib 238
Nib-Instantiated View Controller 241
Storyboard-Instantiated View Controller 243
View Resizing and the Status Bar 245
Rotation 251
Rotation and Layout Events 254
Initial Orientation 258
Presented View Controller 261
Presenting a View 262
Communication With a Presented View Controller 264
Presented View Animation 267
Presentation Styles 268
Rotation of a Presented View 271
Presenting a View in Response to Rotation 273
Tab Bar Controllers 274
Tab Bar Items 276
Configuring a Tab Bar Controller 277
Navigation Controllers 279
Bar Button Items 282

Navigation Items and Toolbar Items 284
Configuring a Navigation Controller 287
Custom Transition Animations 290
Noninteractive Custom Transition Animation 291
Interactive Custom Transition Animation 294
Custom Presented View Controller Transition 301
Transition Coordinator 308
Page View Controller 310
Container View Controllers 315
Storyboards 320
Segues 322
Container Views 324
Unwind Segues 325
View Controller Lifetime Events 329
Incoherencies in View Controller Events 332
Appear and Disappear Events 332
Manual Event Forwarding to a Child View Controller 333
View Controller Memory Management 335
State Restoration 337
How to Test State Restoration 338
vi | Table of Contents
www.it-ebooks.info
Participating in State Restoration 339
Restoration ID, Identifier Path, and Restoration Class 341
Restoring View Controller State 348
Restoration Order of Operations 353
Restoration of Other Objects 355
Snapshot Suppression 357
7.
Scroll Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

Creating a Scroll View in Code 360
Using a Content View 363
Scroll View in a Nib 365
Scrolling 367
Paging 371
Tiling 373
Zooming 375
Zooming Programmatically 376
Zooming with Detail 377
Scroll View Delegate 380
Scroll View Touches 382
Floating Scroll View Subviews 386
Scroll View Performance 387
8.
Table Views and Collection Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Table View Cells 392
Built-In Cell Styles 393
Registering a Cell Class 399
Custom Cells 401
Table View Data 408
The Three Big Questions 409
Reusing Cells 411
Table View Sections 413
Section Index 418
Refreshing Table View Data 419
Variable Row Heights 423
Table View Cell Selection 426
Managing Cell Selection 426
Responding to Cell Selection 427
Navigation From a Table View 429

Cell Choice and Static Tables 430
Table View Scrolling and Layout 432
Table View State Restoration 432
Table View Searching 433
Table of Contents | vii
www.it-ebooks.info
Table View Editing 442
Deleting Table Items 445
Editable Content in Table Items 446
Inserting Table Items 448
Rearranging Table Items 450
Dynamic Table Items 451
Table View Menus 453
Collection Views 455
Collection View Classes 459
Using a Collection View 462
Custom Collection View Layouts 465
Switching Layouts 469
Collection Views and UIKit Dynamics 470
9.
Popovers and Split Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
Preparing a Popover 475
Popover Size 476
Popover Appearance Customization 477
Summoning and Dismissing a Popover 480
Popover Segues 480
Managing a Popover Controller 481
Dismissing a Popover 482
Popovers During Rotation or Backgrounding 485
Popovers and Presented Views 486

Automatic Popovers 487
Split Views 489
Using a Split View 489
Split Views in a Storyboard 491
Other Split View Configurations 492
10.
Text. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Fonts 494
Fonts and Dynamic Type 494
Font Descriptors 497
Attributed Strings 499
Attributed String Attributes 500
Making an Attributed String 503
Modifying and Querying an Attributed String 508
Measuring and Drawing an Attributed String 509
Labels 511
Number of Lines 511
Wrapping and Truncation 512
viii | Table of Contents
www.it-ebooks.info
Label Resizing 513
Customized Label Drawing 514
Text Fields 515
Summoning and Dismissing the Keyboard 517
Keyboard Covers Text Field 519
Configuring the Keyboard 524
Text Field Delegate and Control Event Messages 525
Text Field Menu 528
Text Views 530
Text View as Scroll View 531

Text View and Keyboard 532
Text Kit 534
Text Container 535
Alternative Text Kit Stack Architectures 538
Layout Manager 540
Text Kit Without a Text View 543
11. Web Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
Web View Content 550
Loading Web View Content 554
Designing Web View Content 556
Paginated Web Views 558
Web View State Restoration 558
Communicating with a Web View 559
12.
Controls and Other Views. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
UIActivityIndicatorView 563
UIProgressView 565
UIPickerView 567
UISearchBar 569
UIControl 574
UISwitch 578
UIStepper 579
UIPageControl 581
UIDatePicker 581
UISlider 584
UISegmentedControl 587
UIButton 590
Custom Controls 595
Bars 598
Bar Position and Bar Metrics 599

Bar Appearance 601
Table of Contents | ix
www.it-ebooks.info
UIBarButtonItem 602
UINavigationBar 604
UIToolbar 607
UITabBar 607
Tint Color 612
Appearance Proxy 614
13.
Modal Dialogs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
Alert View 620
Action Sheet 622
Dialog Alternatives 627
Local Notifications 628
Activity View 632
Part III. Some Frameworks
14. Audio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
System Sounds 639
Audio Session 640
Interruptions 643
Routing Changes 645
Audio Player 646
Remote Control of Your Sound 648
Playing Sound in the Background 651
Further Topics in Sound 654
15.
Video. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
MPMoviePlayerController 658
MPMoviePlayerViewController 664

UIVideoEditorController 665
Introduction to AV Foundation 668
Some AV Foundation Building Blocks 668
Displaying a Movie 669
Synchronizing Video With Animation 671
Building Media 672
Further Exploration of AV Foundation 673
16.
Music Library. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
Exploring the Music Library 675
Querying the Music Library 676
Persistence and Change in the Music Library 680
x | Table of Contents
www.it-ebooks.info
Music Player 681
MPVolumeView 684
Playing Songs With AV Foundation 686
Music Picker 688
17. Photo Library and Image Capture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
Choosing From the Photo Library 693
Assets Library Framework 697
Using the Camera 701
Customizing the Image Capture Interface 703
Image Capture With AV Foundation 705
18.
Address Book. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709
Address Book Database 709
Address Book Interface 714
ABPeoplePickerNavigationController 715
ABPersonViewController 717

ABNewPersonViewController 718
ABUnknownPersonViewController 719
19.
Calendar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 721
Calendar Database 721
Creating Calendars and Events 725
Recurrence 727
Fetching Events 729
Reminders 731
Proximity Alarms 732
Calendar Interface 732
EKEventViewController 733
EKEventEditViewController 735
EKCalendarChooser 736
20.
Mail and Messages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739
Mail Message 739
Text Message 741
Twitter Post 742
21.
Maps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743
Displaying a Map 743
Annotations 746
Custom Annotation View 747
Custom Annotation Class 751
Table of Contents | xi
www.it-ebooks.info
Other Annotation Features 752
Overlays 754
Custom Overlay Class 755

Custom Overlay Renderer 758
Other Overlay Features 760
Map Kit and Current Location 761
Communicating With the Maps App 762
Geocoding, Searching, and Directions 764
Geocoding 764
Searching 766
Directions 766
22. Sensors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769
Core Location 770
Basic Location Determination 771
Heading 775
Background Location 776
Acceleration and Attitude 779
Shake Events 780
Raw Acceleration 781
Gyroscope 785
Part IV. Final Topics
23.
Persistent Storage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793
The Sandbox 793
Basic File Operations 794
Saving and Reading Files 796
User Defaults 798
File Sharing 799
Document Types 800
Handing Off a Document 803
Document Architecture 806
iCloud 811
XML 814

SQLite 821
Core Data 821
Image File Formats 827
24.
Basic Networking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831
HTTP Requests 831
xii | Table of Contents
www.it-ebooks.info
Simple HTTP Request 833
Formal HTTP Request 834
Multiple Tasks 839
Background Downloads 845
Background App Refresh 847
In-App Purchases 848
Bonjour 852
25.
Threads. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 855
Main Thread 855
Why Threading Is Hard 858
Three Ways of Threading 860
Manual Threads 861
NSOperation 863
Grand Central Dispatch 867
Threads and App Backgrounding 872
26.
Undo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 875
Undo Manager 875
Target–Action Undo 876
Undo Grouping 878
Invocation Undo 879

Undo Interface 880
Shake-To-Edit 880
Undo Menu 881
A. Application Lifetime Events. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 889
Table of Contents | xiii
www.it-ebooks.info
www.it-ebooks.info
Aut lego vel scribo; doceo scrutorve sophian.
—Sedulius Scottus
Preface
This book, now in its fourth edition, has grown in size to encompass the growth in its
subject, until it can grow no more. The previous editions — Programming iOS 4 (May
2011), Programming iOS 5 (March 2012), and Programming iOS 6 (March 2013) — were
approximately 800 pp., 950 pp., and 1150 pp. in length, respectively, not because I had
more to say each time, but because Apple, as it added features to iOS 4 to make iOS 5,
and to iOS 5 to make iOS 6, had given me more to describe.
Now iOS 7 has come along with even more new features, and drastic action was needed.
Accordingly, the book has been ripped violently but neatly in two — neatly, because
there was already a perfectly natural place to do the ripping, namely right after the end
of what used to be Part III (Chapter 13). There are now two books:
• A new book, iOS 7 Programming Fundamentals, comprising chapters 1–13 of the
earlier books.
• This book, Programming iOS 7, comprising chapters 14–40 of the earlier books.
The truth is that this is a division I had wanted to make even before Programming iOS
4 was published — indeed, before it was even conceived of. My original proposal to
O’Reilly Media, back in early 2010, had been for a book to be called Fundamentals of
Cocoa Programming, intended to cover very much the same material as iOS 7 Program‐
ming Fundamentals covers now. But the proposal was accepted only on condition that
it be extended to cover much more of Cocoa Touch (iOS) programming; so I complied

and set to work on this longer project, and later, despite my impassioned pleas in the
autumn of 2010, I was unable to persuade the publisher to break up the lengthy manu‐
script into two: by that time, all the king’s horses and all the king’s men could no longer
crack Humpty Dumpty apart.
The new situation, therefore, is just what I always wanted in the first place — but not
quite, because what I most desired was a single book in two volumes. My idea was that
xv
www.it-ebooks.info
the books would have the same title, distinguished as Volume I and Volume II, with
successive numbering of pages and chapters: if Volume I ended, say, with Chapter 13
and page 400, then Volume II would start with Chapter 14 and page 401. To this de‐
lightfully Victorian extreme, I’m sorry to say, O’Reilly Media were implacably opposed.
Thus, Programming iOS 7, though it starts with its own Chapter 1 and page 1, never‐
theless still picks up exactly where iOS 7 Programming Fundamentals leaves off. They
complement and supplement one another. Those who desire a complete grounding in
the knowledge needed to begin writing iOS apps with a solid and rigorous understand‐
ing of what they are doing and where they are heading will, I hope, obtain both books.
At the same time, the two-book architecture should, I believe, render the size and scope
of each book individually more acceptable and attractive to more readers.
Those who feel that they know already all there is to know about C, Objective-C, Xcode,
and the linguistic and architectural basis of the Cocoa framework, or who are content
to pick up such underpinnings as they go along, need no longer (as some in the past
have done) complain that the book is occupied with 13 preliminary chapters before the
reader starts really writing any significant iOS code, because those 13 chapters have now
been abstracted into a separate volume, iOS 7 Programming Fundamentals, and this
book, Programming iOS 7, now begins, like Homer’s Iliad, in the middle of the story,
with the reader jumping with all four feet into views and view controllers, and with a
knowledge of the language and the Xcode IDE already presupposed. And if such a reader
subsequently changes his or her mind and decides that a thorough grounding in those
underpinnings might in fact be desirable, iOS 7 Programming Fundamentals will still

be available and awaiting study.
Moreover, the existence of iOS 7 Programming Fundamentals means that I, as author
and teacher, can make the same assumption in this edition about you, as reader and
student, that I made in previous editions — namely, that you have a command of the
material in that book. If you find yourself mystified by terminology or concepts used in
this book, then it might be wise to stop reading it and take up iOS 7 Programming
Fundamentals first! In it, I explain such things as:
• The Objective-C language, starting with C and building up to the object-oriented
concepts and mechanics of classes and instances in Objective-C itself.
• Xcode, the world in which all iOS programming ultimately takes place, including
what an Xcode project is and how it is transformed into an app, and how to work
comfortably and nimbly with Xcode to consult the documentation and to write,
navigate, and debug code, as well as how to bring your app through the subsequent
stages of running on a device and submission to the App Store. There is also a very
important chapter on nibs and the nib editor (Interface Builder), including outlets
and actions as well as the mechanics of nib loading. (However, some additional
important nib-related topics, such as autolayout constraints and storyboard segues,
are discussed in this book.)
xvi | Preface
www.it-ebooks.info
• The Cocoa Touch framework, which provides important foundational classes and
adds linguistic and architectural devices such as categories, protocols, delegation,
and notifications, as well as the pervasive responsibilities of memory management,
plus key–value coding and key–value observing.
With those basics having been laid down in iOS 7 Programming Fundamentals, this
book, Programming iOS 7, assumes that you already know Objective-C and how to work
with Xcode to edit code and nibs, make properties and outlets and actions, and so forth,
and proceeds to explain the constituents of practical iOS app construction:
• Part I describes views, the fundamental units of an iOS app’s interface. Views are
what the user can see and touch in an iOS app. To make something appear before

the user’s eyes, you need a view. To let the user interact with your app, you need a
view. This part of the book explains how views are created, arranged, drawn, layered,
animated, and touched.
• Part II starts by discussing view controllers. Perhaps the most remarkable and im‐
portant feature of iOS programming, view controllers enable views to come and go
coherently within the interface, thus allowing a single-windowed app running on
what may be a tiny screen to contain multiple screens of material. This part of the
book talks about all the ways in which view controllers can be manipulated in order
to make their views appear. It also describes every kind of view provided by the
Cocoa framework — the built-in “widgets” with which you’ll construct an app’s
interface.
• Part III surveys many of the secondary frameworks provided by iOS. These are
clumps of code, sometimes with built-in interface, that are not part of your app by
default, but are there for the asking if you need them, allowing you to work with
such things as sound, video, user libraries, mail, maps, and the device’s sensors.
•
Part IV wraps up the book with some miscellaneous but important topics: files,
networking, threading, and how to implement Undo and Redo.
• Appendix A summarizes the most important lifetime event messages sent to your
app delegate.
Someone who has read this book (and who, it goes without saying, is conversant with
the material in iOS 7 Programming Fundamentals) will, I believe, be capable of writing
a real-life iOS app, and to do so with a clear understanding of what he or she is doing
and where the app is going as it grows and develops. The book itself doesn’t show how
to write any particularly interesting iOS apps (though it is backed by dozens of example
projects that you can download from my GitHub site, />Programming-iOS-Book-Examples), but it does constantly use my own real apps and
real programming situations to illustrate and motivate its explanations.
Just as important, this book is intended to prepare you for your own further explorations.
In the case of some topics, especially in Part III and Part IV, I guide you past the initial
Preface | xvii

www.it-ebooks.info
barrier of no knowledge into an understanding of the topic, its concepts, its capabilities,
and its documentation, along with some code examples; but the topic itself may be so
huge that there is room only to introduce it here. Your feet, nevertheless, will now be
set firmly on the path, and you will know enough that you can now proceed further
down that path on your own whenever the need or interest arises.
Indeed, there is always more to learn about iOS. iOS is vast! It is all too easy to find areas
of iOS that have had to be ruled outside the scope of this book. In Part IV, for example,
I peek at Core Data, and demonstrate its use in code, but a true study of Core Data would
require an entire book of its own (and such books exist); so, having opened the door, I
quickly close it again, lest this book suddenly double in size. By the same token, many
areas of iOS are not treated at all in this book:
OpenGL
An open source C library for drawing, including 3D drawing, that takes full ad‐
vantage of graphics hardware. This is often the most efficient way to draw, especially
when animation is involved. iOS incorporates a simplified version of OpenGL called
OpenGL ES. See Apple’s OpenGL Programming Guide for iOS. Open GL interface
configuration, texture loading, shading, and calculation are simplified by the GLKit
framework; see the GLKit Framework Reference.
Sprite Kit
New in iOS 7, Sprite Kit provides a built-in framework for designing 2D animated
games.
Accelerate
Certain computation-intensive processes will benefit from the vector-based Accel‐
erate framework. See the vDSP Programming Guide.
Game Kit
The Game Kit framework covers three areas that can enhance your user’s game
experience: Wireless or Bluetooth communication directly between devices (peer-
to-peer); voice communication across an existing network connection; and Game
Center, which facilitates these and many other aspects of interplayer communica‐

tion, such as posting and viewing high scores and setting up combinations of players
who wish to compete. See the Game Kit Programming Guide.
Advertising
The iAD framework lets your free app attempt to make money by displaying ad‐
vertisements provided by Apple. See the iAD Programming Guide.
Newsstand
Your app may represent a subscription to something like a newspaper or magazine.
See the Newsstand Kit Framework Reference.
Printing
See the “Printing” chapter of the Drawing and Printing Guide for iOS.
xviii | Preface
www.it-ebooks.info
Security
This book does not discuss security topics such as keychains, certificates, and en‐
cryption. See the Security Overview and the Security framework.
Accessibility
VoiceOver assists visually impaired users by describing the interface aloud. To par‐
ticipate, views must be configured to describe themselves usefully. Built-in views
already do this to a large extent, and you can extend this functionality. See the
Accessibility Programming Guide for iOS.
Telephone
The Core Telephony framework lets your app get information about a particular
cellular carrier and call.
Pass Kit
The Pass Kit framework allows creation of downloadable passes to go into the user’s
Passbook app. See the Passbook Programming Guide.
External accessories
The user can attach an external accessory to the device, either directly via USB or
wirelessly via Bluetooth. Your app can communicate with such an accessory. See
External Accessory Programming Topics.

Versions
This book is geared to iOS 7 and Xcode 5. In general, only very minimal attention is
given to earlier versions of iOS and Xcode. It is not my intention to embrace in this book
any detailed knowledge about earlier versions of the software, which is, after all, readily
and compendiously available in my earlier books. There are, nevertheless, a few words
of advice about backward compatibility, and now and then I will call out a particularly
noteworthy change from earlier versions.
(For example, it has been hard to refrain from pointing out the confusion caused by the
changes in how the status bar works, or in the meaning of tintColor, or the nightmarish
way in which your perfectly viable iOS 6 project, when recompiled against iOS 7, will
try to resize and reposition its views incorrectly, underlapping the navigation bar.)
Xcode 5 no longer offers the user, creating a new app project from one of the project
templates, an option as to whether or not to use Automatic Reference Counting (ARC),
the compiler-based manual memory management technology that has made life so
much easier for iOS programmers in recent years. ARC is simply turned on by default.
Therefore, this book assumes from the outset that you are using ARC.
Xcode also no longer provides a template-based option as to whether or not to use a
storyboard. All projects (except the Empty Application template) come with a main
storyboard, and there is no option to use a main .xib file instead. Taking my cue from
Preface | xix
www.it-ebooks.info
this, I have adapted my teaching style to assume that storyboards are primary and that
you’ll usually be using one. (I do also assume that you know how to make and work
with a .xib file when you need one, as this is explained in iOS 7 Programming Funda‐
mentals.)
I have also embraced, often without much fanfare, the various other iOS 7 and Xcode
5 innovations. Apple has clearly set out, with this generation of their software, to make
iOS programming easier and more pleasant than ever; and by and large they have suc‐
ceeded. For example, modules and autolinking have made it much simpler than in the
past to work with additional frameworks, and I simply assume as a matter of course that

you will be using them; thus, when telling you what to do in order to employ a certain
framework, I give simply the relevant @import command. Similarly, in discussing draw‐
ing and images in Chapter 2, I naturally steer you toward the use of asset catalogs.
Acknowledgments
My thanks go first and foremost to the people at O’Reilly Media who have made writing
a book so delightfully easy: Rachel Roumeliotis, Sarah Schneider, Kristen Brown, and
Adam Witwer come particularly to mind. And let’s not forget my first and long-standing
editor, Brian Jepson, who had nothing whatever to do with this edition, but whose
influence is present throughout.
As in the past, I have been greatly aided by some fantastic software, whose excellences
I have appreciated at every moment of the process of writing this book. I should like to
mention, in particular:
•
git ()
• SourceTree ()
• TextMate ()
• AsciiDoc ( />• BBEdit ( />•
Snapz Pro X ()
• GraphicConverter ()
• OmniGraffle ()
The book was typed and edited entirely on my faithful Unicomp Model M keyboard
(), without which I could never have done so much writing over
so long a period so painlessly. For more about my physical work environment, see http://
matt.neuburg.usesthis.com.
xx | Preface
www.it-ebooks.info
From the Programming iOS 4 Preface
A programming framework has a kind of personality, an overall flavor that provides an
insight into the goals and mindset of those who created it. When I first encountered
Cocoa Touch, my assessment of its personality was: “Wow, the people who wrote this

are really clever!” On the one hand, the number of built-in interface widgets was severely
and deliberately limited; on the other hand, the power and flexibility of some of those
widgets, especially such things as UITableView, was greatly enhanced over their OS X
counterparts. Even more important, Apple created a particularly brilliant way (UIView‐
Controller) to help the programmer make entire blocks of interface come and go and
supplant one another in a controlled, hierarchical manner, thus allowing that tiny
iPhone display to unfold virtually into multiple interface worlds within a single app
without the user becoming lost or confused.
The popularity of the iPhone, with its largely free or very inexpensive apps, and the
subsequent popularity of the iPad, have brought and will continue to bring into the fold
many new programmers who see programming for these devices as worthwhile and
doable, even though they may not have felt the same way about OS X. Apple’s own annual
WWDC developer conventions have reflected this trend, with their emphasis shifted
from OS X to iOS instruction.
The widespread eagerness to program iOS, however, though delightful on the one hand,
has also fostered a certain tendency to try to run without first learning to walk. iOS gives
the programmer mighty powers that can seem as limitless as imagination itself, but it
also has fundamentals. I often see questions online from programmers who are evidently
deep into the creation of some interesting app, but who are stymied in a way that reveals
quite clearly that they are unfamiliar with the basics of the very world in which they are
so happily cavorting.
It is this state of affairs that has motivated me to write this book, which is intended to
ground the reader in the fundamentals of iOS. I love Cocoa and have long wished to
write about it, but it is iOS and its popularity that has given me a proximate excuse to
do so. Here I have attempted to marshal and expound, in what I hope is a pedagogically
helpful and instructive yet ruthlessly Euclidean and logical order, the principles and
elements on which sound iOS programming rests. My hope, as with my previous books,
is that you will both read this book cover to cover (learning something new often enough
to keep you turning the pages) and keep it by you as a handy reference.
This book is not intended to disparage Apple’s own documentation and example

projects. They are wonderful resources and have become more wonderful as time goes
on. I have depended heavily on them in the preparation of this book. But I also find that
they don’t fulfill the same function as a reasoned, ordered presentation of the facts. The
online documentation must make assumptions as to how much you already know; it
can’t guarantee that you’ll approach it in a given order. And online documentation is
Preface | xxi
www.it-ebooks.info
more suitable to reference than to instruction. A fully written example, no matter how
well commented, is difficult to follow; it demonstrates, but it does not teach.
A book, on the other hand, has numbered chapters and sequential pages; I can assume
you know views before you know view controllers for the simple reason that Part I
precedes Part II. And along with facts, I also bring to the table a degree of experience,
which I try to communicate to you. Throughout this book you’ll find me referring to
“common beginner mistakes”; in most cases, these are mistakes that I have made myself,
in addition to seeing others make them. I try to tell you what the pitfalls are because I
assume that, in the course of things, you will otherwise fall into them just as naturally
as I did as I was learning. You’ll also see me construct many examples piece by piece or
extract and explain just one tiny portion of a larger app. It is not a massive finished
program that teaches programming, but an exposition of the thought process that de‐
veloped that program. It is this thought process, more than anything else, that I hope
you will gain from reading this book.
Conventions Used in This Book
The following typographical conventions are used in this book:
Italic
Indicates new terms, URLs, email addresses, filenames, and file extensions.
Constant width
Used for program listings, as well as within paragraphs to refer to program elements
such as variable or function names, databases, data types, environment variables,
statements, and keywords.
Constant width bold

Shows commands or other text that should be typed literally by the user.
Constant width italic
Shows text that should be replaced with user-supplied values or by values deter‐
mined by context.
This icon signifies a tip, suggestion, or general note.
This icon indicates a warning or caution.
xxii | Preface
www.it-ebooks.info
Using Code Examples
Supplemental material (code examples, exercises, etc.) is available for download at
/>This book is here to help you get your job done. In general, if example code is offered
with this book, you may use it in your programs and documentation. You do not need
to contact us for permission unless you’re reproducing a significant portion of the code.
For example, writing a program that uses several chunks of code from this book does
not require permission. Selling or distributing a CD-ROM of examples from O’Reilly
books does require permission. Answering a question by citing this book and quoting
example code does not require permission. Incorporating a significant amount of ex‐
ample code from this book into your product’s documentation does require permission.
We appreciate, but do not require, attribution. An attribution usually includes the title,
author, publisher, and ISBN. For example: “Programming iOS 7 by Matt Neuburg
(O’Reilly). Copyright 2014 Matt Neuburg, 978-1-449-37234-7.”
If you feel your use of code examples falls outside fair use or the permission given above,
feel free to contact us at
Safari® Books Online
Safari Books Online is an on-demand digital library that delivers
expert content in both book and video form from the world’s lead‐
ing authors in technology and business.
Technology professionals, software developers, web designers, and business and crea‐
tive professionals use Safari Books Online as their primary resource for research, prob‐
lem solving, learning, and certification training.

Safari Books Online offers a range of product mixes and pricing programs for organi‐
zations, government agencies, and individuals. Subscribers have access to thousands of
books, training videos, and prepublication manuscripts in one fully searchable database
from publishers like O’Reilly Media, Prentice Hall Professional, Addison-Wesley Pro‐
fessional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco Press, John
Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT
Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, Course Technol‐
ogy, and dozens more. For more information about Safari Books Online, please visit us
online.
Preface | xxiii
www.it-ebooks.info