Session 7 - Overview of the iOS7 app development architecture

Overview of the iOS 7 Application
Development Architecture
These are conﬁdential sessions - please refrain from streaming, blogging, or taking pictures
Session 7
Vu Tran Lam
IAD-2013

Start Developing iOS Apps Today

Creating iOS apps is fun and rewarding. If you're a new developer,
you might be wondering where to begin. This road map provides the
perfect starting point for iOS app development.

When you develop apps, you use the iOS software development kit
(SDK) and Xcode, Apple’s integrated development environment (IDE).

To make a great iOS app, you need to learn and do many things, but
the tools and iOS SDK make it easy to get a simple app running.
Let’s do the tutorial Your First iOS App.

Xcode provides tools to manage your entire development workﬂow-
from creating your app and designing your user interface, to testing,
optimizing, and shipping your app to the App Store.

Objective-C is an elegant object-oriented language that is used in all
iOS apps. You need to understand this language in order to use most
iOS application frameworks.

If you’ve learned enough about Objective-C to read and write basic
code, you can begin to think in terms of objects - OOP. To create an
iOS app, you need to know how to create, compare, query objects
and access objects in collections such as arrays.

iOS app consists of code that you write and frameworks provided by
Apple. A framework contains a library of methods that your app can use.
More than one app can access a framework library at the same time.

A design pattern solves a common software engineering problem.
Patterns are abstract designs, not code. When you adopt a design,
you adapt the general pattern to your speciﬁc needs.

Users expect iOS apps to be intuitive, interactive, and engaging. Think
about user experience as you design every aspect of your app, from
the features you choose to the way your app responds to a gesture.

Before you begin writing a line of code, you should make some
critical design decisions. Be as speciﬁc as possible about your app’s
purpose and features. Choose the kind of data model your app will
use. Decide on a user interface style for your app.

After completing your iOS App, if you want more and more iOS users
know and download your app, you must publish your app on the App
Store. To make a great app, you need to test it on actual devices, not
just in Simulator. To run an app on iOS-based devices, you need to
register your devices, create certiﬁcates that authorize developers to
sign an app, and create an app ID to identify the app.

While developing your apps, you’ll need easy access to detailed
technical information. Xcode makes that material available at your
ﬁngertips while you're coding.

• Model-View-Controller
• Delegation
• Target-Action
• Block objects
• Sandboxing
Fundamental iOS Design Patterns & Techniques

Model-View-Controller
• By default, iOS apps are organized around the Model-View-
Controller design pattern.
• The Model-View-Controller (MVC) design pattern assigns objects in
an application one of three roles: model, view, or controller. The
pattern defines not only the roles objects play in the application, it
defines the way objects communicate with each other.
• MVC is central to a good design for a Cocoa Touch application.
Many objects in these applications tend to be more reusable, and
their interfaces tend to be better defined.
• Applications having an MVC design are also more easily extensible
than other applications.

ViewModel
Controller

Assign objects in an application to one of three roles.
ViewModel
Controller

Model objects encapsulate the data speciﬁc to an application and deﬁne
the logic and computation that manipulate and process that data, e.g: a
model object represent a character in game or a contact in address book.
Model View
Controller

A view object is an object in an application that users can see. A view
object knows how to draw itself and can respond to user actions.
Model View
Controller

A controller object acts as an intermediary between view and model
objects. In MVC, a controller object interprets user actions made in view
objects and communicates new or changed data to the model objects.
Model View
Controller

ViewModel
Controller
It’s all about managing communication between 3 roles types

ViewModel
Controller
Controllers can always talk directly to their Model.
update

ViewModel
Controller
Controllers can also talk directly to their View.
outlet
update
update

ViewModel
The Model and View should never speak to each other.
Controller
?
outlet
update
update

ViewModel
Can the View speak to its Controller?
Controller
?
outlet
update
update

ViewModel
action
target
The Controller can drop a target on itself.
Controller
outlet
update
update

ViewModel
action
target
Then hand out an action to the View.
Controller
outlet
update
update

ViewModel
action
target
The View sends the action when things happen in the UI.
Controller
outlet
update
update

ViewModel
action
target
Sometimes the View needs to synchronize with the Controller.
should did
will
Controller
update
outlet
update

ViewModel
action
target
The Controller sets itself as the View’s delegate.
delegate
should did
will
Controller
update
outlet
update

ViewModel
action
target
The delegate is set via a protocol (i.e. it’s “blind” to class).
delegate
should did
will
Controller
outlet
update
update

ViewModel
action
target
Views do not own the data they display.
delegate
should did
will
Controller
outlet
update
update

ViewModel
action
target
So, if needed, they have a protocol to acquire it.
delegate
should did
will
data
at
count
Controller
outlet
update
update

ViewModel
action
target
Controllers are almost always that data source (not Model!).
data
source
data
at
count
delegate
should did
will
Controller
outlet
update
update

ViewModel
action
target
Controllers interpret/format Model information for the View.
data
source
data
at
count
delegate
should did
will
Controller
outlet
update
update

ViewModel
action
target
Can the Model talk directly to the Controller?
data
source
data
at
count
delegate
should did
will
Controller
outlet
update
update
?

ViewModel
So what if the Model has information to update or something?
action
target
data
source
data
at
count
delegate
should did
will
Controller
outlet
update
update
?

ViewModel
It uses a “radio station”-like broadcast mechanism
action
target
notification
data
source
data
at
count
delegate
should did
will
Controller
outlet
update
update
notify

Controllers (or other Model) “tune in” to interesting stuff.
action
ViewModel
target
notification
data
source
data
at
count
delegate
should did
will
Controllernotify outlet
update
update

Delegation
• Delegation is the design pattern which facilitates the transfer
information and data from one object to another. In delegation, an
object called the delegate acts on behalf of, and at the request of,
another object.
• A prime example of delegation can be seen in the case of the
UIApplication class. The UIApplication class, of which every iOS
iPhone application must have one instance, is responsible for the
control and operation of the application within the iOS environment.
• The Application Delegate is a custom object created at app launch
time, usually by the UIApplicationMain function.
• The primary job of Application Delegate is to handle state
transitions within the app. For example, this object is responsible for
launch-time initialization and handling transitions to and from the

Managing App State Changes
• The app launch cycle
• Responding to interruptions
• Moving to the background
• Returning to the foreground
• The main run loop

The Main Run Loop
The main run loop of your app is responsible for processing all user-
related events. The UIApplication object sets up the main run loop at
launch time and uses it to process events and handle updates to view-
based interfaces.

Target-Action
• Target-action is a design pattern in which an object holds the
information necessary to send a message to another object when an
event occurs.
• The stored information consists of two items of data: an action
selector, which identiﬁes the method to be invoked, and a target,
which is the object to receive the message.
• The message sent when the event occurs is called an action
message.

• For example, when a user interacts with a slider (action), it
generates a UIControlEventValueChanged control event. You
could use this event to update a label’s text to the current value
of the slider. In this case, the sender is the slider, the control
event is Value Changed, the action is updating the label’s text,
and the target is the controller ﬁle containing the label as an
IBOutlet.
• Action methods must have a conventional signature as
- (IBAction)doSomething:(id)sender;!
• UIKit framework allows three different forms of action selector:
- (void)action;
- (void)action:(id)sender;
- (void)action:(id)sender forEvent:(UIEvent *)event;
Target-Action

• Target-action is primarily a feature of
controls in both the Cocoa Touch and
Cocoa frameworks.
• A control is a user-interface object such
as a button, slider, or switch that users
manipulate (by tapping, dragging, and so
on) to signal their intention to an app.
• A Cocoa Touch control stores both
action and target; most Cocoa controls
are paired with one or more cell objects
that store target and action.
Target-Action

Block Objects
• Block objects are a C-level syntactic and runtime feature that allow
you to compose function expressions that can be passed as
arguments, optionally stored, and used by multiple threads.
• Declaring a block
float (^aBlock)(const int*, int, float);
• Creating a block
int (^oneFrom)(int);
oneFrom = ^(int anInt) {
return anInt - 1;
};
• Using block
printf("%dn", oneFrom(10));

Sandboxing
• All iOS apps are placed in sandboxes to protect the system and
other apps.
• The structure of the sandbox affects the placement of your app’s
ﬁles and has implications for data backups and some app-related
features.

• Concept of View Controller
• Visual Interfaces
• View Controllers manage Views
• Taxonomy of View Controllers
• Using Storyboards to design User Interface
Overview of View Controllers

• View controllers are a vital link between an app’s data and its visual
appearance. Whenever an iOS app displays a user interface, the
displayed content is managed by a view controller or a group of
view controllers coordinating with each other.
• View controllers are traditional controller objects in the Model-View-
Controller (MVC) design pattern, but they also do much more. View
controllers provide many behaviors common to all iOS apps.
About View Controllers

Visual Interfaces
Screens, Windows, and Views create Visual Interfaces.

• Each view controller organizes and controls a view
• View controllers are controller objects in the MVC pattern, but a
view controller also has speciﬁc tasks iOS expects it to perform.
• These tasks are deﬁned by the UIViewController class that all view
controllers inherit from.
View Controllers Manage Views

• Each view controller organizes and controls a view
• View controllers are controller objects in the MVC pattern, but a
view controller also has speciﬁc tasks iOS expects it to perform.
• These tasks are deﬁned by the UIViewController class that all view
controllers inherit from.
Taxonomy of View Controllers

Using Storyboards to Design User Interface

Documentation
iOS App Programming Guide
https://developer.apple.com/library/ios/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/
Introduction/Introduction.html
Streamline Your App with Design Patterns
https://developer.apple.com/library/ios/referencelibrary/GettingStarted/RoadMapiOS/chapters/
StreamlineYourAppswithDesignPatterns/StreamlineYourApps/StreamlineYourApps.html
Concepts in Objective-C Programming
https://developer.apple.com/library/ios/documentation/general/conceptual/CocoaEncyclopedia/Introduction/
Introduction.html
View Programming Guide
https://developer.apple.com/library/ios/DOCUMENTATION/WindowsViews/Conceptual/ViewPG_iPhoneOS/
Introduction/Introduction.html

many thanks
to
lamvt@fpt.com.vn
please
say
Stanford University
https://developer.apple.com
Developer Center
http://www.stanford.edu/class/cs193p
xin
chào

Next: Xcode 5 & Interface Builder for iOS 7 App

Session 7 - Overview of the iOS7 app development architecture

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Session 7 - Overview of the iOS7 app development architecture

Similar a Session 7 - Overview of the iOS7 app development architecture (20)

Más de Vu Tran Lam

Más de Vu Tran Lam (20)

Último

Último (20)

Session 7 - Overview of the iOS7 app development architecture