Beginning IOS 6 development

www.it-ebooks.info
For your convenience Apress has placed some of the front
matter material after the index. Please use the Bookmarks
and Contents at a Glance links to access them.

www.it-ebooks.info

v
Contents at a Glance
About the Authors �������������������������������������������������������������������������������������������������������������� xxi
About the Technical Reviewers ��������������������������������������������������������������������������������������� xxiii
Chapter 1: Welcome to the Jungle ■ �������������������������������������������������������������������������������������1
Chapter 2: Appeasing the Tiki Gods ■ ���������������������������������������������������������������������������������11
Chapter 3: Handling Basic Interaction ■ �����������������������������������������������������������������������������43
Chapter 4: More User Interface Fun ■ ��������������������������������������������������������������������������������69
Chapter 5: Autorotation and Autosizing ■ ������������������������������������������������������������������������115
Chapter 6: Multiview Applications ■ ��������������������������������������������������������������������������������139
Chapter 7: Tab Bars and Pickers ■ �����������������������������������������������������������������������������������169
Chapter 8: Introduction to Table Views ■ �������������������������������������������������������������������������221
Chapter 9: Navigation Controllers and Table Views ■ �������������������������������������������������������269
Chapter 10: Storyboards ■ ������������������������������������������������������������������������������������������������341
Chapter 11: iPad Considerations ■ �����������������������������������������������������������������������������������367
Chapter 12: Application Settings and User Defaults ■ ������������������������������������������������������397
Chapter 13: Basic Data Persistence ■ ������������������������������������������������������������������������������435
Chapter 14: Hey! You! Get onto iCloud! ■ �������������������������������������������������������������������������481
www.it-ebooks.info

vi Contents at a Glance
Chapter 15: Grand Central Dispatch, Background Processing, and You ■ ������������������������511
Chapter 16: Drawing with Quartz and OpenGL ■ ��������������������������������������������������������������545
Chapter 17: Taps, Touches, and Gestures ■ ����������������������������������������������������������������������585

Chapter 18: Where Am I? Finding Your Way with Core Location and Map Kit ■ ���������������619
Chapter 19: Whee! Gyro and Accelerometer! ■ ����������������������������������������������������������������637
Chapter 20: The Camera and Photo Library ■ �������������������������������������������������������������������667
Chapter 21: Collection View ■ ������������������������������������������������������������������������������������������677
Chapter 22: Application Localization ■ �����������������������������������������������������������������������������691
Appendix A: Where to Next? ■ ������������������������������������������������������������������������������������������717
Index ���������������������������������������������������������������������������������������������������������������������������������725
www.it-ebooks.info
1

Chapter 1
Welcome to the Jungle
So, you want to write iPhone, iPod touch, and iPad applications? Well, we can’t say that we blame
you. iOS, the core software of all of these devices, is an exciting platform that has been seeing
explosive growth since it first came out in 2007. The rise of the mobile software platform means that
people are using software everywhere they go. With the release of iOS 6, and the latest incarnation
of the iOS software development kit (SDK), things have only gotten better and more interesting.
What This Book Is
This book is a guide to help you get started down the path to creating your own iOS applications.
Our goal is to get you past the initial difficulties, to help you understand the way iOS applications
work and how they are built.
As you work your way through this book, you will create a number of small applications, each
designed to highlight specific iOS features and to show you how to control or interact with those
features. If you combine the foundation you’ll gain through this book with your own creativity and
determination, and then add in the extensive and well-written documentation provided by Apple,
you’ll have everything you need to build your own professional iPhone and iPad applications.
Tip Dave, Jack, Jeff, and Fredrik have set up a forum for this book. It’s a great place to meet like-minded
folks, get your questions answered, and even answer other people’s questions. The forum is at
. Be sure to check it out!
What You Need

Before you can begin writing software for iOS, you’ll need a few items. For starters, you’ll need
an Intel-based Macintosh, running Lion (OS X 10.7) or later. Any recent Intel-based Macintosh
computer—laptop or desktop—should work just fine.
www.it-ebooks.info

2 CHAPTER 1: Welcome to the Jungle
You’ll also need to sign up to become a registered iOS developer. Apple requires this step before
you’re allowed to download the iOS SDK.
To sign up as a developer, just navigate to That will bring you to
a page similar to the one shown in Figure 1-1.
Figure 1-1. Apple’s iOS Dev Center website
First, click on Log in. You’ll be prompted for your Apple ID. If you don’t have an Apple ID, click
Join now, create one, and then log in. Once you are logged in, you’ll be taken to the main iOS
development page. Not only will you see a link to the SDK download, but you’ll also find links to a
wealth of documentation, videos, sample code, and the like—all dedicated to teaching you the finer
points of iOS application development.
The most important tool you’ll be using to develop iOS applications is called Xcode. Xcode is
Apple’s integrated development environment (IDE). Xcode includes tools for creating and debugging
source code, compiling applications, and performance tuning the applications you’ve written.
You can download Xcode from the Mac App Store, which you can access from your Mac’s Apple
menu.
www.it-ebooks.info

3CHAPTER 1: Welcome to the Jungle
As the versions of the SDK and Xcode evolve, the mechanism for downloading them will also change. Starting with the
release of Xcode 4.3, Apple has been publishing the current “stable” version of Xcode and the iOS SDK on the Mac App
Store, while simultaneously often providing developers the ability to download preview versions of upcoming releases
from their developer site. Bottom line: you want to download the latest released (non-beta) version of Xcode and the iOS
SDK, so use the Mac App Store.
This book has been written to work with the latest version of the SDK. In some places, we have chosen to use new

functions or methods introduced with iOS 6 that may prove incompatible with earlier versions of the SDK. We’ll be sure to
point those situations out as they arise in this book.
Be sure to download the latest and greatest source code archives from or from the
book’s forum at . We’ll update the code as new versions of the SDK are released, so
be sure to check the site periodically.
Developer Options
The free SDK download option includes a simulator that will allow you to build and run iPhone and
iPad apps on your Mac. This is perfect for learning how to program for iOS. However, the simulator
does not support many hardware-dependent features, such as the accelerometer and camera. Also,
the free option will not allow you to download your applications onto your actual iPhone or other
device, and it does not give you the ability to distribute your applications on Apple’s App Store. For
those capabilities, you’ll need to sign up for one of the other options, which aren’t free:
The Standard program costs $99/year. It provides a host of development tools 
and resources, technical support, distribution of your application via Apple’s App
Store, and, most important, the ability to test and debug your code on an iOS
device, rather than just in the simulator.
The Enterprise program costs $299/year. It is designed for companies 
developing proprietary, in-house iOS applications.
For more details on these programs, visit and
to compare the two.
Because iOS supports an always-connected mobile device that uses other companies’ wireless
infrastructure, Apple has needed to place far more restrictions on iOS developers than it ever has on Mac
developers (who are able—at the moment anyway—to write and distribute programs with absolutely no
oversight or approval from Apple). Even though the iPod touch and the Wi-Fi-only versions of the iPad
don’t use anyone else’s infrastructure, they’re still subject to these same restrictions.
Apple has not added restrictions to be mean, but rather as an attempt to minimize the chances of
malicious or poorly written programs being distributed that could degrade performance on the shared
network. Developing for iOS may appear to present a lot of hoops to jump through, but Apple has
expended quite an effort to make the process as painless as possible. And also consider that $99 is
still much less than buying, for example, Visual Studio, which is Microsoft’s software development IDE.

SDK VERSIONS AND SOURCE CODE FOR THE EXAMPLES
www.it-ebooks.info

4 CHAPTER 1: Welcome to the Jungle
This may seem obvious, but you’ll also need an iPhone, iPod touch, or iPad. While much of your
code can be tested using the iOS simulator, not all programs can be. And even those that can run
on the simulator really need to be thoroughly tested on an actual device before you ever consider
releasing your application to the public.
Note If you are going to sign up for the Standard or Enterprise program, you should do it right now.
The approval process can take a while, and you’ll need that approval to be able to run your applications
on an actual device. Don’t worry, though, because all the projects in the first several chapters and the
majority of the applications in this book will run just fine on the iOS simulator.
What You Need to Know
This book assumes that you already have some programming knowledge. It assumes that you
understand the fundamentals of object-oriented programming (you know what objects, loops, and
variables are, for example). It also assumes that you are familiar with the Objective-C programming
language. Cocoa Touch, the part of the SDK that you will be working with through most of this book,
uses the latest version of Objective-C, which contains several new features not present in earlier
versions. But don’t worry if you’re not familiar with the more recent additions to the Objective-C
language. We highlight any of the new language features we take advantage of, and explain how
they work and why we are using them.
You should also be familiar with iOS itself, as a user. Just as you would with any platform for which
you wanted to write an application, get to know the nuances and quirks of the iPhone, iPad, or iPod
touch. Take the time to get familiar with the iOS interface and with the way Apple’s iPhone and/or
iPad applications look and feel.
NEW TO OBJECTIVE-C?
If you have not programmed in Objective-C before, here are a few resources to help you get started:
Check out • Learn Objective-C on the Mac: For OS X and iOS (2nd edition, Apress, 2012):,
an excellent and approachable introduction to Objective-C by Mac-programming experts Scott Knaster,
Waqar Malik, and Mark Dalrymple: />See Apple’s introduction to the language, Learning Objective-C: A Primer.•

Take a look at • The Objective-C Programming Language, a very detailed and extensive description of the
language and a great reference guide.
The last two are available from That last one is also
available as a free download from iBooks on your iPhone, iPod touch, or iPad. It’s perfect for reading on the go! Apple
has released several developer titles in this format, and we hope that more are on the way. Search for “Apple developer
publications” in iBooks to find them.
www.it-ebooks.info

5CHAPTER 1: Welcome to the Jungle
What’s Different About Coding for iOS?
If you have never programmed in Cocoa or its predecessors NeXTSTEP or OpenStep, you may
find Cocoa Touch—the application framework you’ll be using to write iOS applications—a little alien.
It has some fundamental differences from other common application frameworks, such as those
used when building .NET or Java applications. Don’t worry too much if you feel a little lost at first.
Just keep plugging away at the exercises, and it will all start to fall into place after a while.
If you have written programs using Cocoa or NeXTSTEP, a lot in the iOS SDK will be familiar to
you. A great many classes are unchanged from the versions that are used to develop for OS X.
Even those that are different tend to follow the same basic principles and similar design patterns.
However, several differences exist between Cocoa and Cocoa Touch.
Regardless of your background, you need to keep in mind some key differences between iOS
development and desktop application development. These differences are discussed in the
following sections.
Only One Active Application
On iOS, only one application can be active and displayed on the screen at any given time. Since
iOS 4, applications have been able to run in the background after the user presses the “home”
button, but even that is limited to a narrow set of situations, and you must code for it specifically.
When your application isn’t active or running in the background, it doesn’t receive any attention
whatsoever from the CPU, which will wreak havoc with open network connections and the like. iOS
allows background processing, but making your apps play nicely in this situation will require some
effort on your part.

Only One Window
Desktop and laptop operating systems allow many running programs to coexist, each with the ability
to create and control multiple windows. However, iOS gives your application just one “window” to
work with. All of your application’s interaction with the user takes place inside this one window, and
its size is fixed at the size of the screen.
Limited Access
Programs on a computer pretty much have access to everything the user who launched them does.
However, iOS seriously restricts what your application can access.
You can read and write files only from the part of iOS’s file system that was created for your
application. This area is called your application’s sandbox. Your sandbox is where your application
will store documents, preferences, and every other kind of data it may need to retain.
Your application is also constrained in some other ways. You will not be able to access low-number
network ports on iOS, for example, or do anything else that would typically require root or
administrative access on a desktop computer.
www.it-ebooks.info

6 CHAPTER 1: Welcome to the Jungle
Limited Response Time
Because of the way it is used, iOS needs to be snappy, and it expects the same of your application.
When your program is launched, you need to get your application open, preferences and data
loaded, and the main view shown on the screen as fast as possible—in no more than a few seconds.
At any time when your program is running, it may have the rug pulled out from under it. If the user
presses the home button, iOS goes home, and you must quickly save everything and quit. If you
take longer than five seconds to save and give up control, your application process will be killed,
regardless of whether you are finished saving.
Note that since iOS 5, this situation has been ameliorated somewhat by the existence of new API
that allows your app to ask for additional time to work when it’s about to go dark.
Limited Screen Size
The iPhone’s screen is really nice. When introduced, it was the highest resolution screen available on
a consumer device, by far.

But the iPhone display just isn’t all that big, and as a result, you have a lot less room to work with
than on modern computers. The screen is just 320 × 480 on the first few iPhone generations, and
was later doubled in both directions to 640 × 960 with the introduction of the iPhone 4’s retina
display. This was recently increased further to 640 × 1136 on the iPhone 5. That sounds like a decent
number of pixels, but keep in minde that these retina displays are crammed into pretty small form
factors, so you can’t count on fitting more controls or anything like that. This has a big impact on the
kinds of applications and interactivity you can offer on an iPhone.
The iPad increases the available space a bit by offering a 1024 × 768 display, but even today, that’s
not so terribly large. To give an interesting contrast, at the time of writing, Apple’s least expensive
iMac supports 1920 × 1080 pixels, and its least expensive notebook computer, the 11-inch MacBook
Air, supports 1366 × 768 pixels. On the other end of the spectrum, Apple’s largest current monitor,
the 27-inch LED Cinema Display, offers a whopping 2560 × 1440 pixels. Note that the 3
rd
generation
iPad released in the spring of 2012 (which Apple confusingly calls the “new iPad” instead of
incrementing the number from the previous iPad 2) actually doubles the screen resolution in both
directions. But as with the retina iPhones, that 2048 × 1536 screen is in the same physical space as
the old screen was, so you can’t really count on using those pixels the same way you would on a
traditional screen.
Limited System Resources
Any old-time programmers who are reading this are likely laughing at the idea of a machine with
at least 512MB of RAM and 16GB of storage being in any way resource-constrained, but it is
true. Developing for iOS is not, perhaps, in exactly the same league as trying to write a complex
spreadsheet application on a machine with 48KB of memory. But given the graphical nature of iOS
and all it is capable of doing, running out of memory is very easy.
The iOS devices available right now have either 512MB (iPhone 4, iPhone 4S, iPad 2), or 1024MB of
physical RAM (iPhone 5, new iPad), though that will likely increase over time. Some of that memory
is used for the screen buffer and by other system processes. Usually, no more than half of that
www.it-ebooks.info
7CHAPTER 1: Welcome to the Jungle

memory is left for your application to use, and the amount can be considerably less, especially now
that apps can run in the background.
Although that may sound like it leaves a pretty decent amount of memory for such a small computer,
there is another factor to consider when it comes to memory on iOS. Modern computer operating
systems like OS X will take chunks of memory that aren’t being used and write them out to disk
in something called a swap file. The swap file allows applications to keep running, even when
they have requested more memory than is actually available on the computer. iOS, however, will not
write volatile memory, such as application data, out to a swap file. As a result, the amount of memory
available to your application is constrained by the amount of unused physical memory in the iOS device.
Cocoa Touch has built-in mechanisms for letting your application know that memory is getting low.
When that happens, your application must free up unneeded memory or risk being forced to quit.
No Garbage Collection, but…
We mentioned earlier that Cocoa Touch uses Objective-C, but one of the key new features of that
language is not available with iOS: Cocoa Touch does not support garbage collection. The need to
do manual memory management when programming for iOS has been a bit of a stumbling block
for many programmers new to the platform, especially those coming from languages that offer
garbage collection.
With the version of Objective-C supported by the latest versions of iOS, however, this particular
stumbling block is basically gone. This is thanks to a feature called Automatic Reference Counting
(ARC), which gets rid of the need to manually manage memory for Objective-C objects. ARC not
only serves as a worthy replacement to garbage collection, it’s actually better in most respects,
so that starting in OS X 10.8 it’s now become the default memory management technology, and
garbage collection has been deprecated there in favor of ARC. We’ll talk about ARC in Chapter 3.
Some New Stuff
Since we’ve mentioned that Cocoa Touch is missing some features that Cocoa has, it seems only
fair to mention that the iOS SDK contains some functionality that is not currently present in Cocoa or,
at least, is not available on every Mac:
The iOS SDK provides a way for your application to determine the iOS device’s
current geographic coordinates using Core Location.
Most iOS devices have built-in cameras and photo libraries, and the SDK

provides mechanisms that allow your application to access both.
iOS devices have a built-in accelerometer (and, in the latest iPhone and iPod
touch, a gyroscope) that lets you detect how your device is being held and
moved.
www.it-ebooks.info
8 CHAPTER 1: Welcome to the Jungle
A Different Approach
Two things iOS devices don’t have are a physical keyboard and a mouse, which means you have
a fundamentally different way of interacting with the user than you do when programming for a
general-purpose computer. Fortunately, most of that interaction is handled for you. For example, if
you add a text field to your application, iOS knows to bring up a keyboard when the user touches
that field, without you needing to write any extra code.
Note Current devices do allow you to connect an external keyboard via Bluetooth, which gives you
a nice keyboard experience and saves some screen real estate, but this is still a fairly rare usage.
Connecting a mouse is still not an option.
What’s in This Book
Here is a brief overview of the remaining chapters in this book:
In Chapter 2, you’ll learn how to use Xcode’s partner in crime, Interface Builder,
to create a simple interface, placing some text on the screen.
In Chapter 3, you’ll start interacting with the user, building a simple application
that dynamically updates displayed text at runtime based on buttons the user
presses.
Chapter 4 will build on Chapter 3 by introducing you to several more of iOS’s
standard user-interface controls. We’ll also demonstrate how to use alerts
and action sheets to prompt users to make a decision or to inform them that
something out of the ordinary has occurred.
In Chapter 5, we’ll look at handling autorotation and autosize attributes,
the mechanisms that allow iOS applications to be used in both portrait and
landscape modes.
In Chapter 6, we’ll move into more advanced user interfaces and explore

creating applications that support multiple views. We’ll show you how to change
which view is being shown to the user at runtime, which will greatly enhance the
potential of your apps.
Tab bars and pickers are part of the standard iOS user interface. In Chapter 7,
we’ll look at how to implement these interface elements.
In Chapter 8, we’ll cover table views, the primary way of providing lists of data to
the user and the foundation of hierarchical navigation-based applications. You’ll
also see how to let the user search in your application data.
One of the most common iOS application interfaces is the hierarchical list that
lets you drill down to see more data or more details. In Chapter 9, you’ll learn
what’s involved in implementing this standard type of interface.
www.it-ebooks.info

9CHAPTER 1: Welcome to the Jungle
iOS developers have traditionally built user interfaces for their apps using nib 
files. This is still a fully supported development style, but nowadays you can do
even more with your designs using storyboards. Chapter 10 covers this great
new feature.
The iPad, with its different form factor from the other iOS devices, requires a 
different approach to displaying a GUI and provides some components to help
make that happen. In Chapter 11, we’ll show you how to use the iPad-specific
parts of the SDK.
In Chapter 12, we’ll look at implementing application settings, which is iOS’s 
mechanism for letting users set their application-level preferences.
Chapter 13 covers data management on iOS. We’ll talk about creating objects 
to hold application data and see how that data can be persisted to iOS’s file
system. We’ll also discuss the basics of using Core Data, which allows you to
save and retrieve data easily.
In iOS 5 Apple introduced iCloud, which allows your document to store data 
online and sync it between different instances of the application. Chapter 14

shows you how to get started with iCloud.
Since iOS 4, developers have access to a new approach to multithreaded 
development using Grand Central Dispatch, and also have the ability to make
their apps run in the background in certain circumstances. In Chapter 15, we’ll
show you how that’s done.
Everyone loves to draw, so we’ll look at doing some custom drawing in Chapter 16. 
We’ll use basic drawing functions in Quartz 2D and OpenGL ES.
The multitouch screen common to all iOS devices can accept a wide variety of 
gestural inputs from the user. In Chapter 17, you’ll learn all about detecting basic
gestures, such as the pinch and swipe. We’ll also look at the process of defining
new gestures and talk about when new gestures are appropriate.
iOS is capable of determining its latitude and longitude thanks to Core Location. 
In Chapter 18, we’ll build some code that makes use of Core Location to figure
out where in the world your device is and use that information in our quest for
world dominance.
In Chapter 19, we’ll look at interfacing with iOS’s accelerometer and gyroscope, 
which is how your device knows which way it’s being held, the speed and
direction in which it is moving, and where in the world it’s located. We’ll explore
some of the fun things your application can do with that information.
Nearly every iOS device has a camera and a library of pictures, both of which 
are available to your application, if you ask nicely! In Chapter 20, we’ll show you
how to ask nicely.
From the beginning, all sorts of iOS applications have made use of table views 
to display dynamic, vertically scrolling lists of components. In iOS 6, Apple
has introduced a new class called UICollectionView which takes this concept
a few steps further, giving developers lots of new flexibility in laying out visual
components. Chapter 21 will get you up and running with collection views.
www.it-ebooks.info

10 CHAPTER 1: Welcome to the Jungle

iOS devices are currently available in more than 90 countries. In Chapter 22, 
we’ll show you how to write your applications in such a way that all parts can be
easily translated into other languages. This helps expand the potential audience
for your applications.
By the end of this book, you’ll have mastered the fundamental building blocks 
for creating iPhone and iPad applications. But where do you go from here? In
the appendix, we’ll explore the logical next steps for you to take on your journey
to master the iOS SDK.
What’s New in This Update?
Since the first edition of this book hit the bookstores, the growth of the iOS development community
has been phenomenal. The SDK has continually evolved, with Apple releasing a steady stream of
SDK updates.
Well, we’ve been busy, too! The second we found out about iOS SDK 6, we immediately went to
work, updating every single project to ensure not only that the code compiles using the latest version
of Xcode and the SDK, but also that each one takes advantage of the latest and greatest features
offered by Cocoa Touch. We made a ton of subtle changes throughout the book, and added a good
amount of substantive changes as well, including a brand-new chapter on the new collection view
that Apple added to iOS 6. And, of course, we reshot every screen shown in the book.
Are You Ready?
iOS is an incredible computing platform and an exciting new frontier for your development pleasure.
Programming for iOS is going to be a new experience—different from working on any other platform.
For everything that looks familiar, there will be something alien, but as you work through the book’s
code, the concepts should all come together and start to make sense.
Keep in mind that the exercises in this book are not simply a checklist that, when completed,
magically grants you iOS developer guru status. Make sure you understand what you did and why
before moving on to the next project. Don’t be afraid to make changes to the code. Observing
the results of your experimentation is one of the best ways you can wrap your head around the
complexities of coding in an environment like Cocoa Touch.
That said, if you have your iOS SDK installed, turn the page. If not, get to it! Got it? Good. Then let’s go!
www.it-ebooks.info

11

Chapter 2
Appeasing the Tiki Gods
As you’re probably well aware, it has become something of a tradition to call the first project in any
book on programming “Hello, World.” We considered breaking with this tradition, but were scared
that the tiki gods would inflict some painful retribution on us for such a gross breach of etiquette.
So, let’s do it by the book, shall we?
In this chapter, we’re going to use Xcode to create a small iOS application that will display the text
“Hello, World!” We’ll look at what’s involved in creating an iOS application project in Xcode, work
through the specifics of using Xcode’s Interface Builder to design our application’s user interface,
and then run our application on the iOS simulator. After that, we’ll give our application an icon to
make it feel more like a real iOS application.
We have a lot to do here, so let’s get going.
Setting Up Your Project in Xcode
By now, you should have Xcode and the iOS SDK installed on your machine. You should also download
the book project archive from the iPhone Dev Book web site (
While you’re at it, take a look at the book forums at The book forums
are a great place to discuss iOS development, get your questions answered, and meet up with
like-minded people.
Note Even though you have the complete set of project files at your disposal in this book’s project
archive, you’ll get more out of the book if you create each project by hand, rather than simply running
the version you downloaded. By doing that, you’ll gain familiarity and expertise working with the various
application development tools.
There’s no substitute for actually creating applications; software development is not a spectator sport.
www.it-ebooks.info

12 CHAPTER 2: Appeasing the Tiki Gods
Figure 2-1. The Xcode welcome window
The project we’re going to build in this chapter is contained in the 02 Hello World folder of the

project archive.
Before we can start, we need to launch Xcode. Xcode is the tool that we’ll use to do most of what
we do in this book, and after downloading it from the Mac App Store you’ll find it installed in the
/Applications folder as with most Mac applications. You’ll be using Xcode a lot, so you might want to
consider dragging it to your dock so you’ll have ready access to it.
If this is your first time using Xcode, don’t worry; we’ll walk you through every step involved in
creating a new project. If you’re already an old hand but haven’t worked with Xcode 4, you will find
that quite a bit has changed (mostly for the better, we think).
When you first launch Xcode, you’ll be presented with a welcome window like the one shown in
Figure 2-1. From here, you can choose to create a new project, connect to a version-control system
to check out an existing project, or select from a list of recently opened projects. The welcome
window also contains links to iOS and Mac OS X technical documentation, tutorial videos, news,
sample code, and other useful items. All of this functionality can be accessed from the Xcode menu
as well, but this window gives you a nice starting point, covering some of the most common tasks
you’re likely to want to do after launching Xcode. If you feel like poking through the information here
for a few minutes, by all means go right ahead. When you’re finished, close the window, and we’ll
proceed. If you would rather not see this window in the future, just uncheck the Show this window
when Xcode launches checkbox before closing it.
www.it-ebooks.info

13CHAPTER 2: Appeasing the Tiki Gods
Note If you have an iPhone, iPad, or iPod touch connected to your machine, you might see a message
when you first launch Xcode asking whether you want to use that device for development. For now,
click the Ignore button. Alternatively, the Organizer window, which shows (among other things) the
devices that have been synchronized with your computer, might appear. In that case, just close the
Organizer window. If you choose to join the paid iOS Developer Program, you will gain access to a
program portal that will tell you how to use your iOS device for development and testing.
Figure 2-2. The project template selection sheet lets you select from various templates when creating a new project
Create a new project by selecting New ➤ Project… from the File menu (or by pressing ÒN). A new
project window will open, and will show you the project template selection sheet (see Figure 2-2).

From this sheet, you’ll choose a project template to use as a starting point for building your application.
The pane on the left side of the sheet is divided into two main sections: iOS and Mac OS X.
Since we’re building an iOS application, select Application in the iOS section to reveal the iOS
application templates.
Each of the icons shown in the upper-right pane in Figure 2-2 represents a separate project template
that can be used as a starting point for your iOS applications. The icon labeled Single View Application
is the simplest template and the one we’ll be using for the first several chapters. The other templates
provide additional code and/or resources needed to create common iPhone and iPad application
interfaces, as you’ll see in later chapters.
www.it-ebooks.info

14 CHAPTER 2: Appeasing the Tiki Gods
Click the Single View Application icon (as in Figure 2-2), and then click the Next button. You’ll see
the project options sheet, which should look like Figure 2-3. On this sheet, you need to specify
the Product Name and Company Identifier for your project. Xcode will combine the two of those
to generate a unique Bundle Identifier for your app. You’ll also see a field that lets you enter an
Organization Name, which Xcode will use to automatically insert a copyright notice into every source
code file you create. Name your product Hello World, call your organization Apress, and then enter
com.apress in the Company Identifier field, as shown in Figure 2-3. Later, after you’ve signed up
for the developer program and learned about provisioning profiles, you’ll want to use your own
company identifier. We’ll talk more about the bundle identifier later in the chapter.
Figure 2-3. Selecting a product name and company identifier for your project. Use these settings for now
The next text box is labeled Class Prefix, and we should populate this with a sequence of at least
three capital letters. These characters will be added to the beginning of the name of all classes that
Xcode creates for us. This is done to avoid naming conflicts with Apple (who reserves the use of all
two-letter prefixes) and other developers whose code we might use. In Objective-C, having more
than one class with the same name will prevent your application from being built.
For the projects in the book, we’re going to use the prefix BID, which stands for Beginning iPhone
Development. While there are likely to be many classes named, for example, ViewController, far
fewer classes are likely to be named BIDMyViewController, which means a lot less chance

of conflicts.
www.it-ebooks.info

15CHAPTER 2: Appeasing the Tiki Gods
We also need to specify the Device Family. In other words, Xcode wants to know if we’re building
an app for the iPhone and iPod touch, if we’re building an app for the iPad, or if we’re building a
universal application that will run on all iOS devices. Select iPhone for the Device Family if it’s not
already selected. This tells Xcode that we’ll be targeting this particular app at the iPhone and iPod
touch, which have the same screen size. For the first part of the book, we’ll be using the iPhone
device family, but don’t worry—we’ll cover the iPad also.
There are three checkboxes on this sheet. You should check the middle option, Use Automatic
Reference Counting, but uncheck the other two. Automatic Reference Counting (ARC) is a recent
addition to the Objective-C language, introduced with iOS 5, that makes your life much easier. We’ll
talk briefly about ARC in the next chapter.
The Use Storyboard option will be covered starting in Chapter 10. The other option—Include Unit
Tests—will set up your project in such a way that you can add special pieces of code to your
project, called unit tests, which are not part of your application but run every time you create your
application to test certain functionality. Unit tests allow you to identify when a change made to your
code breaks something that was previously working. Although it can be a valuable tool, we won’t be
using automated unit testing in this book, so you can leave its box unchecked.
Click Next again, and you’ll be asked where to save your new project using a standard save sheet,
as shown in Figure 2-4. If you haven’t already done so, jump over to the Finder and create a new
master directory for these book projects, and then return to Xcode and navigate into that directory.
Before you click the Create button, make note of the the Create local git repository for this project
checkbox. We won’t be talking about git in this book, but Xcode includes some support for using git
and other kinds of source control repositories. If you are already familiar with git and want to use it,
leave this checkbox enabled, but otherwise feel free to turn it off.
Figure 2-4. Saving your project in a project folder on your hard drive
www.it-ebooks.info

16 CHAPTER 2: Appeasing the Tiki Gods
Note A source control repository is a tool used to keep track of changes made to an application’s
source code and resources while it’s being built. It also facilitates multiple developers working on the
same application at the same time by providing tools to resolve conflicts when they arise. We won’t be
using source control in this book, so it’s up to you to enable it or disable it, whichever works for you.
Figure 2-5. The Hello World project in Xcode
You’ll also see a pop-up at the bottom of the window, offering you a chance to add this project to
an existing project or workspace. Leave this set to the default value, Don’t add to any project or
workspace. Then create the new project by clicking the Create button.
The Xcode Workspace Window
After you dismiss the save sheet, Xcode will create and then open your project. You will see a new
workspace window, as shown in Figure 2-5. There’s a lot of information crammed into this window,
and it’s where you will be spending a lot of your iOS development time.
Even if you are an old hand with earlier versions of Xcode, you’ll still benefit from reading through
this section, as a lot has changed since the last release of Xcode 3.x. Let’s take a quick tour.
www.it-ebooks.info

17CHAPTER 2: Appeasing the Tiki Gods
The Toolbar
The top of the Xcode workspace window is called the toolbar (see Figure 2-6). On the left side of
the toolbar are controls to start and stop running your project, a pop-up menu to select the scheme
you want to run, and a button to toggle breakpoints on and off. A scheme brings together target and
build settings, and the toolbar pop-up menu lets you select a specific setup with just one click.
Figure 2-6. The Xcode toolbar
The big box in the middle of the toolbar is the activity view. As its name implies, the activity view
displays any actions or processes that are currently happening. For example, when you run your
project, the activity view gives you a running commentary on the various steps it’s taking to build
your application. If you encounter any errors or warnings, that information is displayed here as
well. If you click the warning or error, you’ll go directly to the issues navigator, which provides more
information about the warning or error, as described in the next section.

On the right side of the toolbar are three sets of buttons. The left set, labeled Editor, lets you switch
between three different editor configurations:
The  standard view gives you a single pane dedicated to editing a file or
project-specific configuration values.
The incredibly powerful  assistant view splits the editor pane into two panes,
left and right. The pane on the right is generally used to display a file that relates
to the file on the left, or that you might need to refer to while editing the file on
the left. You can manually specify what goes into each pane, or you can let
Xcode decide what’s most appropriate for the task at hand. For example, if
you’re editing the implementation of an Objective-C class (the .m file), Xcode
will automatically show you that class’s header file (the .h file) in the right pane.
If you’re designing your user interface on the left, Xcode will show you the code
that user interface is able to interact with on the right. You’ll see the assistant
view at work throughout the book.
The versions button converts the editor pane into a time-machine-like comparison 
view that works with source code management systems such as Subversion
and Git. You can compare the current version of a source file with a previously
committed version or compare any two earlier versions with each other.
To the right of the editor button set is another set of buttons that show and hide the navigator pane
and the utility pane, on the left and right sides of the editor pane. Click those buttons to see these
panes in action.
4
www.it-ebooks.info
18 CHAPTER 2: Appeasing the Tiki Gods
Finally, the rightmost button brings up the Organizer window, which is where you’ll find the
bulk of non-project-specific functionality. It’s used as the documentation viewer for Apple’s API
documentation, shows you all the source code repositories that Xcode knows about, keeps a list of
all projects you’ve opened, and maintains a list of all devices that you’ve synchronized with
this computer.
The Navigator View

Just below the toolbar, on the left side of the workspace window, is the navigator view. The navigator
view offers seven configurations that give you different views into your project. Click one of the icons
at the top of the navigator view to switch among the following navigators, going from left to right:
 Project navigator: This view contains a list of files that are used by your project
(see Figure 2-7). You can store references to everything you expect—from
source code files to artwork, data models, property list (or plist) files (discussed
in the “A Closer Look at Our Project” section later in this chapter), and even
other project files. By storing multiple projects in a single workspace, multiple
projects can easily share resources. If you click any file in the navigator view,
that file will display in the editor pane. In addition to viewing the file, you can
also edit the file (if it’s a file that Xcode knows how to edit).
Figure 2-7. The Xcode navigator view showing the project navigator. Click one of the seven icons at
the top of the view to switch navigators
 Symbol navigator: As its name implies, this navigator focuses on the symbols
defined in the workspace (see Figure 2-8). Symbols are basically the items that
the compiler recognizes, such as Objective-C classes, enumerations, structs,
and global variables.

www.it-ebooks.info

19CHAPTER 2: Appeasing the Tiki Gods
Search navigator: You’ll use this navigator to perform searches on all the files in
your workspace (see Figure 2-9). You can select Replace from the Find pop-up
menu, and do a search and replace on all or just selected portions of the search
results. For richer searches, select Show Find Options from the pop-up menu
tied to the magnifying glass in the search field.
Figure 2-8. The Xcode navigator view showing the symbol navigator. Open the disclosure triangle to
explore the files and symbols defined within each group
www.it-ebooks.info

20 CHAPTER 2: Appeasing the Tiki Gods
Issues navigator: When you build your project, any errors or warnings will
appear in this navigator, and a message detailing the number of errors will
appear in the activity view at the top of the window (see Figure 2-10). When you
click an error in the issues navigator, you’ll jump to the appropriate line of code
in the editor pane.
Figure 2-9. The Xcode navigator view showing the search navigator. Be sure to check out the pop-up
menus hidden under the word Find and under the magnifying glass in the search field
www.it-ebooks.info

21CHAPTER 2: Appeasing the Tiki Gods
Debug navigator: This navigator is your main view into the debugging process
(see Figure 2-11). If you are new to debugging, you might check out this part of
the Xcode 4 User Guide:

ToolsLanguages/Conceptual/Xcode4UserGuide/060-Debug_Your_App/
debug_app.html
The debug navigator lists the stack frame for each active thread. A stack frame is
a list of the functions or methods that have been called previously, in the order they
were called. Click a method, and the associated code appears in the editor pane.
In the editor, there will be a second frame, where you can control the debugging
process, display and modify data values, and access the low-level debugger.
A slider at the bottom of the debug navigator allows you to control the level of detail
it tracks. Slide to the extreme right to see everything, including all the system calls.
Slide to the extreme left to see only your calls. The default setting of right in the
middle is a good place to start.
Figure 2-10. The Xcode navigator view showing the issues navigator. This is where you’ll find your
compiler errors and warnings
www.it-ebooks.info