Tutorial Overview and Design Patterns

This chapter provides an overview of the application you’re going to create and the design patterns you’ll use.

Tutorial Overview

In this tutorial, you’re going to create a very simple application. It has a text field, a label, and a button. You can type your name into the text field and tap the button to say hello. The application updates the label’s text to say “Hello, <Name>!”:

Even though this is a very simple application, it introduces the fundamental design patterns, tools, and techniques that underlie all iOS development using Cocoa Touch. Cocoa Touch comprises the UIKit and Foundation frameworks which provide the basic tools and infrastructure you need to implement graphical, event-driven applications in iOS. It also includes several other frameworks that provide key services for accessing device features, such as the user’s contacts. To learn more about Cocoa Touch and where it fits into iOS, read iOS Technology Overview. The main patterns you’re going to use are described in “Design Patterns.”

In this tutorial, little regard is given to the user interface. Presentation is, however, a critical component of a successful iOS application. You should read the iPhone Human Interface Guidelines to understand how the user interface might be improved for a full-fledged application.

You’ll also start to gain an understanding of how view controllers work and how they fit into the architecture of an iOS application.

Design Patterns

If you haven’t already, you should make sure you read the design patterns chapter in Cocoa Fundamentals Guide, however the main patterns you’re going to use are:

• Delegation

• Model View Controller

• Target-Action

Here’s a quick summary of these patterns and an indication of where they’ll be used in the application.

Delegation

Delegation is a pattern where one object sends messages to another object specified as its delegate to ask for input or to notify the delegate that an event is occurring. You typically use it as an alternative to class inheritance for extending the functionality of reusable objects.

In this application, the application object tells its delegate that the main start-up routines have finished and that the custom configuration can begin. For this application, you want the delegate to create an instance of a controller to set up and manage the view. In addition, the text field will tell its delegate (which in this case will be the same controller) when the user has tapped the Return key.

Delegate methods are typically grouped together into a protocol. A protocol is basically just a list of methods. If a class conforms to (or “adopts”) a protocol, it guarantees that it implements the required methods of a protocol. (Protocols may also include optional methods.) The delegate protocol specifies all the messages an object might send to its delegate. To learn more about protocols and the role they play in Objective-C, see the “Protocols” chapter in The Objective-C Programming Language.

Model-View-Controller

The Model-View-Controller (or “MVC”) design pattern sets out three roles for objects in an application.

Model objects represent data such as SpaceShips and Weapons in a game, ToDo items and Contacts in a productivity application, or Circles and Squares in a drawing application.

In this application, the model is very simple—just a string—and it’s not actually used outside of a single method, so from a practical perspective in this application it’s not even necessary. It’s the principle that’s important here, though. In other applications the model will be more complicated and accessed from a variety of locations.

View objects know how to display data (model objects) and may allow the user to edit the data.

In this application, you need a main view to contain several other views—a text field to capture information from the user, a second text field to display text based on the user’s input, and a button to let the user tell us that the secondary text should be updated.

Controller objects mediate between models and views.

In this application, the controller object takes the data from the input text field, stores it in a string, and updates a second text field appropriately. The update is initiated as a result of an action sent by the button.

Target-Action

The target-action mechanism enables a view object that presents a control—that is, an object such as a button or slider—in response to a user event (such as a click or a tap) to send a message (the action) to another object (the target) that can interpret the message and handle it as an application-specific instruction.

In this application, when it’s tapped, the button tells the controller to update its model and view based on the user’s input.

---