book

iPhone® Application Development All-In-One For Dummies®

Name: iPhone® Application Development All-In-One For Dummies®
ISBN: 9780470542934

by Neal Goldstein, Tony Bove

February 2010

Beginner to intermediate

882 pages

19h 26m

English

For Dummies

Read now

Unlock full access

Copyright
About the Authors
Authors' Acknowledgments
Publisher's Acknowledgments
Introduction
About This BookConventions Used in This BookFoolish AssumptionsHow This All-in-One Book Is OrganizedBook I: Creating the Killer AppBook II: Objective-C and iPhone TechnologiesBook III: Building a Utility App — DeepThoughtsBook IV: Debugging and Tuning Your ApplicationBook V: Building an Industrial Strength Application — RoadTrip!Book VI: Storing and Accessing DataBook VII: Extending the App to the Realm of UltracoolWhere to Go from Here
Book I. Creating the Killer App
1. What Makes a Killer iPhone App
1.1. Figuring Out What Makes a Great iPhone Application1.2. Exploiting the Platform1.2.1. Device-guided design1.2.2. Exploiting the features1.2.2.1. Accessing the Internet1.2.2.2. Knowing the location of the user1.2.2.3. Tracking orientation and motion1.2.2.4. Tracking the action of the user's fingers on the screen1.2.2.5. Playing audio and video1.2.2.6. Accessing the user's contacts1.2.2.7. Accessing the user's pictures and camera1.3. Embracing the iPhone's Limitations1.3.1. Living with the small screen1.3.2. Designing for fingers1.3.3. Balancing limited computer power, memory, and battery life1.4. Why Develop iPhone Applications?1.5. Developing with Apple's Expectations in Mind1.6. An Overview of the Development Cycle1.7. The Sample Applications1.8. What's Next
2. Creating a Compelling User Experience
2.1. Deep Thoughts on the User Experience2.2. Creating Compelling Content2.2.1. Focusing on the task at hand2.2.2. Maintaining consistency with the user's world2.2.3. Modeling actions on the real world2.3. Designing the User Interface — Form Follows Function2.3.1. Consistency across apps is a good thing2.3.2. Making it obvious2.3.3. Engaging the user2.4. Designing the User Experience2.4.1. Understanding the real-world context2.4.1.1. Become the champion of relevance2.4.1.2. Seconds count2.4.2. Doing it better on the iPhone2.4.2.1. The quality of information has to be better than the alternative2.4.2.2. The app has to be worth the real cost2.4.2.3. Keep things localized2.5. Playing to the iPhone Strengths2.5.1. Knowing the location of the device2.5.2. Accessing the Internet2.5.3. Recording and playing content2.5.4. Tracking orientation and motion2.6. Incorporating the Device Context2.7. Avoiding Practices that Get Apps Rejected
3. Enlisting in the Developer Corps
3.1. Becoming a Registered iPhone Developer3.2. Joining the iPhone Developer Program3.3. Exploring the iPhone Dev Center3.3.1. Looking forward to using the SDK3.3.2. Resources in the iPhone Dev Center3.4. Downloading the SDK3.5. Getting Yourself Ready for the SDK
4. Getting to Know the SDK
4.1. Developing Using the SDK4.2. Creating Your Xcode Project4.3. Exploring Your Project4.4. Building and Running Your Application4.5. The iPhone Simulator4.5.1. Hardware interaction4.5.2. Gestures4.5.3. Uninstalling apps and resetting your device4.5.4. Limitations4.6. Customizing Xcode to Your Liking4.7. Using Interface Builder4.8. It's Time to Explore

5. Looking Behind the Screen
5.1. Using Frameworks5.2. Using Design Patterns5.2.1. The Model-View-Controller (MVC) pattern5.2.2. The MVC in action5.3. Working with Windows and Views5.3.1. Looking out the window5.3.2. Admiring the view5.3.2.1. What views do5.3.2.2. The view hierarchy5.3.3. The kinds of views you use5.3.3.1. Container views5.3.3.2. Controls5.3.3.3. Display views5.3.3.4. Text and Web views5.3.3.5. Alert views and action sheets5.3.3.6. Navigation views5.3.3.7. The window5.4. Controlling View Controllers5.5. What About the Model?5.6. Adding Your Own Application's Behavior5.6.1. The Delegation pattern5.6.2. The Target-Action pattern5.7. Doing What When?5.8. Whew!
6. Death, Taxes, and iPhone Provisioning
6.1. How the Process Works6.1.1. The Distribution process6.1.2. The Development process6.2. Provisioning Your Device for Development6.3. Creating Your Development Provisioning Profile and Development Certificate6.4. Provisioning Your Application for the App Store6.5. Using iTunes Connect to Manage Apps in the App Store6.6. Supplying the Information Required for the App Store6.6.1. Adding the metadata and artwork6.6.2. You're not done yet6.6.3. Uploading your information6.6.4. Uploading your app and its data6.7. Avoiding the App Store Rejection Slip6.8. Now What?
7. The App Store Is Not Enough
7.1. Why People Buy Apps from the App Store7.1.1. Finding out how to reach your potential customers7.1.2. Marketing 101: Pricing your app7.2. Knowing Your Customers7.2.1. Tracking downloads7.2.2. Adding analytical code to your app7.2.3. Putting ads in your app7.3. Deploying the In App Purchase Feature7.4. Links Are Not Enough7.4.1. Using iTunes affiliate links7.4.2. Making use of user reviews7.4.3. Going social7.4.4. Updating your app for attention7.4.5. Buying advertising and publicity
Book II. Objective-C and iPhone Technologies
1. Using Objective-C's Extensions to C for iPhone Development
1.1. What You Need to Know About Objective-C1.2. Introducing Objects and Classes1.2.1. Grasping objects and their classes1.2.2. Scoping instance variables1.2.3. Spreading the wealth across files1.2.4. Knowing the naming conventions1.2.5. Using id and nil1.3. Declaring the Class Interface1.3.1. The @interface compiler directive and first line1.3.2. The instance variables1.3.3. The methods1.3.4. The @end compiler directive1.4. The Implementation — Coding the Methods1.4.1. The @implementation compiler directive1.4.2. Defining the methods1.4.3. The @end compiler directive1.5. Allocating Objects1.5.1. All objects are dynamic1.5.2. Initialization1.6. Sending Messages to Your Objects1.7. Working with Declared Properties1.7.1. Adding properties1.7.2. Accessing the properties from within the class1.7.3. Releasing the object assigned to a property1.7.4. Using accessor methods to get data from objects1.7.5. Properly using properties1.8. Extending the Program1.8.1. Inheritance1.8.2. Delegation
2. The Real Truth about Object-Oriented Programming
2.1. Not All Modules Are Created Equal2.2. Understanding How Objects Behave2.3. Seeing the Concepts in Action2.3.1. Encapsulation2.3.2. Polymorphism2.4. How Inheritance Works2.4.1. Knowing what inheritance enables you to do2.4.2. Using inheritance effectively2.5. Implementing Inheritance in a Program2.5.1. Deriving classes2.5.2. Replacing a control structure with polymorphism2.5.3. The final word on polymorphism and inheritance2.6. Encapsulating Objects2.6.1. Getting to know the Model-View-Controller (MVC) pattern2.6.2. Implementing the MVC pattern2.7. Looking Ahead
3. Digging Deeper Into Objective-C
3.1. Initializing Objects3.1.1. Invoking the superclass's init method3.1.2. Initializing instance variables3.1.3. Returning self3.2. Raising and Terminating Responsible Objects3.2.1. Understanding the object lifecycle3.2.2. Using reference counting3.3. Running the Static Analyzer3.4. Plugging the Leaks3.5. Attending to Memory Management Subtleties — Arrays and Autorelease3.5.1. Considering objects in arrays3.5.2. Understanding autorelease3.5.3. Using the autorelease pool3.6. Some Basic Memory Management Rules You Shouldn't Forget
4. Leveraging the Foundation Framework in Your App
4.1. Useful Utility Classes4.2. Container Classes4.3. Taking Advantage of Array Objects4.3.1. Tiptoeing through an array4.3.2. Working with fixed arrays4.3.3. Using C arrays4.3.4. Expanding to multidimensional arrays4.4. Using Dictionaries4.4.1. Understanding a dictionary's keys and values4.4.2. Creating a dictionary4.5. Using Property Lists4.5.1. Working with property lists4.5.2. Adding a property list to your project4.5.3. Using plists4.5.4. Creating a mutable dictionary4.5.5. Creating, initializing, and using the symbol string4.6. Dictionaries of Dictionaries4.6.1. Managing a dictionary of dictionaries4.7. Modifying the Property List4.7.1. Adding a new entry to the property list4.7.1.1. Checking to see if the dictionary is there4.7.1.2. Creating the new entry if it's not there4.7.1.3. Getting the data stored in the dictionary if it's there4.7.2. Updating the dictionary
5. Getting Other Objects to Do Your Work for You
5.1. Understanding Delegation5.2. Using Protocols5.2.1. Declaring a protocol5.2.2. Adopting a protocol5.3. Adding delegation to Transaction5.4. Categories5.4.1. Using categories5.4.2. Defining informal protocols
Book III. Building a Utility App — DeepThoughts
1. Understanding How an App Runs
1.1. App Anatomy 101 — The Lifecycle1.1.1. It all starts with the main nib file1.1.2. Initialization1.2. Termination1.3. Other Runtime Considerations1.3.1. Responding to interruptions1.3.2. Seeing how memory management works on the iPhone1.3.2.1. Observing low-memory warnings1.3.2.2. Avoiding the warnings1.3.2.3. Some basic memory-management rules you shouldn't forget1.3.2.4. Reread this section!1.4. Whew!
2. Understanding the User Interface Controls
2.1. Running the Utility Application Template2.2. Inspecting the Main View2.2.1. Initializing the Main view2.2.2. Controller a subset of UIViewController2.2.3. Main view a subset of UIView2.3. Inspecting the Flipside View2.3.1. MainViewController initializes the Flipside view2.3.2. Flipside view a subset of UIView2.4. Unraveling the Info and Done Buttons2.4.1. Info connects to showinfo2.4.2. Done sends an action to FlipsideViewController2.5. Understanding Event Processing
3. Developing the Main View
3.1. Using the Xcode Text Editor3.2. Accessing Documentation3.2.1. Quick Help3.2.2. The header file for a symbol3.2.3. Documentation window3.2.4. Help menu3.2.5. Find3.3. Where Does Your Code Go?3.3.1. The delegate object3.3.2. The controller object3.4. Creating an Animated View3.4.1. The viewDidLoad method3.4.2. Drawing the view3.4.3. The animation block3.5. Testing the Main View
4. Developing the Flipside Controls
4.1. Respecting User Preferences4.2. Setting Up User Preferences4.2.1. Identifying preferences for NSUserDefaults4.2.2. Adding a Constants.h file4.3. Reading Preferences into the App4.4. Setting Up Preferences for the Settings App4.4.1. Adding a Settings bundle to your project4.4.2. Setting up the property list4.4.3. Testing your app with the Settings app4.5. Setting Up Preferences in the Flipside View4.5.1. Objective-C properties4.5.2. Adding methods for the interface objects4.6. Connecting the Interface Objects in Interface Builder
5. Extending Your App with a Photo View
5.1. Adding a Second View5.1.1. Initializing view controllers in the app delegate5.1.2. Discovering how horizontal scrolling works5.1.3. Playing the memory management game5.2. Implementing the Photo View5.2.1. Creating subclasses of UIView and UIViewController5.2.2. Creating a nib file for the Photo view5.2.3. Modifying the window nib file for scrolling5.3. Animating the Photo View5.3.1. Reusing MainViewController code for PhotoViewController5.3.2. Adding a default image5.4. Accessing Media on the iPhone5.5. Adding an Application Icon5.6. A Lot Accomplished Very Quickly
Book IV. Debugging and Tuning Your Application
1. Using the Xcode Debugger
1.1. Understanding Bugs1.2. Using the Debugger1.2.1. Debugging in the Text editor1.2.2. Using the Debugger window1.2.3. Using the Mini Debugger1.2.4. Using the Console1.3. Using Breakpoints1.4. Using the Static Analyzer
2. Tuning Your Code Using Xcode's Instruments Application
2.1. Getting Started with the Instruments Application2.1.1. A Leaks instrument preview2.1.2. Actually using the Leaks instrument2.2. Yes Virginia, There Are Zombies Amongst Us
Book V. Building an Industrial Strength Application — RoadTrip!
1. Designing Your Application
1.1. Defining the Problems1.2. Creating the Program Architecture1.2.1. Models1.2.2. Views1.2.3. Models yet again1.2.4. View controllers1.2.5. Stored data mode, saving state, and localization1.3. Understanding the Iterative Nature of the Process
2. Setting the Table
2.1. Understanding Table Views2.2. Creating the Table View2.3. Creating and Formatting a Grouped Table View2.4. Making UITableViewController Work for You2.4.1. Adding sections2.4.2. Adding titles for the sections2.4.3. Localization2.5. Creating the Row Model2.6. Seeing How Cells Work2.6.1. Using vanilla cell objects2.6.2. Adding subviews to a cell's Content view2.6.3. Creating a custom subclass UITableViewCell2.7. Creating the Cell2.8. And Now . . .
3. Navigating
3.1. Working with User Selections3.1.1. Navigating the navigation controller3.1.2. Implementing the selection3.2. Saving and Restoring State3.2.1. Saving state information3.2.2. Restoring the state3.3. Respecting User Preferences3.3.1. Adding a Settings bundle to your project3.3.2. Setting up the property list3.4. Reading Settings in the Application3.5. Using Preferences in Your Application
4. Creating Controllers and Model Classes
4.1. Specifying the Content4.2. Creating the View Controller, Nib, and Model Files4.2.1. Adding the controller and nib file4.2.2. Setting up the nib file4.3. Getting Trippy with the Trip Model4.3.1. Working with controllers4.3.2. Managing links in Web view Web sites4.3.3. Keeping users from going astray4.4. Implementing CarInformation4.4.1. Setting up the view4.5. Implementing CarServicingInformation4.5.1. Setting up the view4.6. What's with the Trip Model and All That Indirection?4.7. What's Next?
5. Finding Your Way
5.1. Building Your Map Functionality5.1.1. Setting up the nib file5.2. Putting MapKit through Its Paces5.2.1. MKMapView5.2.2. Enhancing the map5.2.2.1. Adding landscape mode and the current location5.2.2.2. It's about the region5.2.2.3. Dealing with failure5.2.3. Adding annotations5.2.3.1. The annotation5.2.3.2. Displaying the annotations5.2.4. Going to the current location5.3. And There's Even More
6. Geocoding and Reverse Geocoding
6.1. Reverse Geocoding6.2. (Forward) Geocoding6.2.1. Adding the FindLocationController and nib file6.3. What's Next?
Book VI. Storing and Accessing Data
1. Show Me the Data
1.1. Seeing the Sights1.2. Starting with the Table View1.2.1. Adding the controller1.2.2. Setting up the controller1.2.3. Creating the SightListController in the RootViewController1.3. Seeing the Sights1.4. Sight.plist Is a Plist1.4.1. Working with property lists1.5. Adding a plist to Your Project1.5.1. Adding images1.6. Initializing the Sight Objects with plist Data1.6.1. Categories and extensions1.6.2. Loading the Sights1.6.3. Tiptoeing through an array1.6.4. Using dictionaries1.6.4.1. Understanding a dictionary's keys and values1.6.5. The Sight object initializes itself with the plist dictionary1.7. Displaying the Sights in the SightListController Table View1.8. Drawing the Thumbs1.9. Compile and Run RoadTrip1.10. Houston, We Have a Problem . . .1.10.1. The problem being . . .
2. A More Flexible Generic Controller
2.1. Seeing How the Old School Generic Controller Worked2.1.1. Stepping through the process2.1.2. The problem being . . .2.2. Understanding Delegation2.2.1. Naming conventions2.3. Using Protocols2.3.1. Declaring a protocol2.3.2. Adding delegation to WebViewController2.3.3. Changing the way WebViewController is instantiated and initialized2.3.4. Adopting a protocol2.4. Asynchronous File Loading
3. Working the URL Loading System
3.1. URL Loading System Overview3.1.1. Authentication and credentials3.1.2. Cookie storage3.1.3. Protocol support3.1.4. Using NSURLConnection — Downloading data asynchronously3.1.4.1. connection:didReceiveResponse:3.1.4.2. connection:didReceiveData:3.1.4.3. connection:didFailWithError:3.1.4.4. connectionDidFinishLoading:3.1.5. One more thing3.2. Implementing Sight with Asynchronous Downloads3.2.1. Sending the right message3.2.2. Getting Trip in on the action3.3. Adding Delegation and the URL Loading System to the Rest of the Model Objects3.4. What About the Map?3.5. Where Are You?
4. Setting Up Core Data
4.1. Core Data Basics4.2. Starting with the Objects4.2.1. Add the Attributes4.2.2. Add relationships4.2.3. Generate your classes4.2.4. Managed objects4.3. The Managed Object Context4.4. The Persistent Store Coordinator and Persistent Store4.5. The Core Data Stack4.5.1. "Coding" the stack4.5.2. Adding the Core Data Framework4.5.3. Connecting the pieces4.6. What's in the Core Data Stack4.6.1. The Managed Object Context4.6.2. The Persistent Store Coordinator4.6.3. The Managed Object Model4.7. Putting Core Data to Work
5. Putting Core Data to Work
5.1. Understanding the Fetch Request5.2. Getting the Ball Rolling5.3. Adding HotelController5.3.1. Setting up the controller5.3.2. Repurposing the code from the template5.3.3. Modifying viewDidLoad5.3.4. Creating a fetched results controller5.3.5. Adding a new hotel5.3.6. Table view methods5.3.7. The fetched results controller's delegate5.3.8. Managing memory5.3.9. You now have someplace to stay5.4. Supporting Undo5.4.1. Supporting undo in HotelController5.4.2. Keeping tabs on your Undo manager5.5. Adding Delete5.6. What's Left
Book VII. Extending the App to the Realm of Ultracool
1. A User Interface for Adding Hotels and Using the Address Book
1.1. Add AddHotelController1.1.1. Adding controls to the view1.1.2. Setting up the controller1.2. Making the Connections in Interface Builder1.3. Adding Some Code to Actually Add Some Functionality1.3.1. Dismissing the controller1.4. Entering and Saving the Hotel Information1.4.1. Dismissing the keyboard1.4.2. Adding Cancel and Save buttons1.4.3. Setting up the AddHotelController delegate1.4.4. Adding the delegation plumbing1.4.5. Using default data1.5. Interfacing with the Address Book Application1.5.1. Adding a hotel to your Address Book
2. Incorporating E-Mail: Postcards from the Road
2.1. Mail on the iPhone2.1.1. The usual start to your adventure2.1.2. Adding the MessageUI framework2.2. Creating the Interface2.2.1. Selecting the new entry2.2.2. Reusing what you've already done in RoadTripController2.3. Creating the Mail Message2.3.1. Displaying the view2.3.2. The delegate2.4. More
3. Are We There Yet?
3.1. Adding Core Location3.2. Taking the Accelerometer for a Spin3.2.1. Doing something with the shake3.3. Yes, You're Finally There

Content preview from iPhone® Application Development All-In-One For Dummies®

Chapter 1. Designing Your Application

In This Chapter

Asking "Where's the beef?" in your application
Making sure your users don't hate you
Designing for perpetuity
Providing lots of functionality

While DeepThoughts is a fun little app, and debugging is well, debugging, it's time to move on to the more interesting stuff. In this chapter, I'll start you down the path to developing a more complex application. While I won't be dotting all the i's and crossing all the t's (I'll leave the memory management details for you to explore on your own, for example) I will be showing you how to use many of the technologies you need to know as you develop your own applications.

Defining the Problems

Necessity is the mother of invention, and the RoadTrip project was no exception. My daughter was about to leave on a 7,000 mile road trip around the U.S,, and, in anticipation of the Great Adventure, every square inch of surface area in her apartment was covered with maps, campground information, places to see, a schedule of who to visit where, and on and on.

"Please, Dad," she said, "you're so smart. Can't you figure out a way so that I can do all this on my iPhone." Being a sucker for the "Please, Dad" and the "you're so smart" combination, I started to give it some thought, and eventually the RoadTrip application idea was brought kicking and screaming into the world.

The purpose of the application would be to present information that's relevant to a) where you are, or b) where you plan to be. By concentrating ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

iPhone App Development: The Missing Manual

Publisher Resources

ISBN: 9780470542934Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

iPhone® Application Development All-In-One For Dummies®

by Neal Goldstein, Tony Bove

Chapter 1. Designing Your Application

Defining the Problems

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.