This document provides an overview of key concepts in iOS development using the Model-View-Controller (MVC) pattern, including views, view controllers, navigation controllers, collection view controllers, delegation, data sources, storyboards, Objective-C basics like classes and protocols, and memory management with ARC. Views define rectangular regions to display content, view controllers control views, and navigation controllers manage hierarchical navigation between views. Delegation and data sources separate responsibilities between classes. Storyboards provide a visual layout of scenes and segues. Objective-C code uses classes, categories, and protocols with message passing between objects. Memory is managed using reference counting.

1. iOS (7)
Workshop

2. Model-View-Controller
View Model
Controller
UpdateUser Action
NotifyUpdate

3. ModelView Controller

5. V M
C
Views
•
Defines a rectangular region on the screen and handles the drawing
and touch events in that region.
•
Every application has at least one view (the window) for presenting it’s
content.
•
A view can also act as a parent for other views and coordinate the
placement and sizing of those views.
•
Examples: Buttons, Navigation Bars, Alerts, Table View Cells, etc...

6. View Controllers
•
Each view controller organizes and controls a view.
•
A view controller owns it’s view. It takes care of all user actions,
animations, updating the view, etc...
•
Just like Views, Controllers can act as parents of other Controllers.
V M
C

8. Navigation Controller
•
A Controller that manages the navigation of hierarchical content.
•
You can push/pop view controllers into/from the Navigation Controller.
•
Each time you add a view controller to the hierarchy the Navigation
Controller becomes it’s parent.
V M
C

9. Collection View Controller
•
Contains and manages it’s collection view (each controller has a root
view, remember?).
•
Usually you subclass it to add your custom behavior.
•
By default it is the delegate and datasource of it’s collection view.
V M
C

10. Delegation
•
Or acting on behalf/at the request of another object.
•
The delegating object sends a message to it’s delegate telling it some
event is about to happen and asks for some response.
•
Delegation is a means for injecting specific behavior in the workings of
a framework class — without having to subclass it.
V M
C

11. Delegate

12. User taps
Delegate

13. User taps shouldSelectItemAtIndexPath:
Delegate

14. User taps shouldSelectItemAtIndexPath:
Delegate
YES

15. Data Source
•
It’s like a delegate except that, instead of being delegated control of
the UI, it is delegated control of the data.
•
Responsible for managing the memory of the model objects they give
to the delegating view.
V M
C

16. Data
Source

17. View starts
loading
Data
Source

18. View starts
loading numberOfSectionsInCollectionView:
Data
Source

19. View starts
loading numberOfSectionsInCollectionView:
Data
Source1

20. View starts
loading
Data
Source
numberOfItemsInSection:0

21. View starts
loading
Data
Source
numberOfItemsInSection:0
7

22. View starts
loading
Data
Source
cellForItemAtIndexPath:

23. View starts
loading
Data
Source
cellForItemAtIndexPath:
Cell View

24. View starts
loading
Data
Source
cellForItemAtIndexPath:
Cell View

25. Application Delegate
•
A custom object created for you at app launch time.
•
It’s primary job is to handle state transitions within the app.
•
Example: application:didFinishLaunching:

26. Storyboards V M
C
•
Big canvas where you lay out your app screens and transitions
•
Trees of view controllers in a serialized form
•
Storyboards = Scenes (VCs) + Segues (transitions)
•
Good for a conceptual overview of the app
•
Bad for apps with lots of VCs or iPad apps (HUGE views...)
•
Limitations: Storyboards < XIBs < Code

27. Objective-C
•
1983
•
Stepstone -> NeXT -> Apple
•
ObjC = C + Smalltalk
•
Object-oriented, reflective
•
OSX (Cocoa), iOS (Cocoa Touch)

28. Basics
Objective-C Java
char b = 0; byte b = 0;
int i = 0; int i = 0;
float f = 0; float f = 0;
double d = 0; double d = 0;
BOOL b = YES; // NO boolean b = true; // false
char c = ‘c’; char c = ‘c’;
NSObject *o = [[NSObject alloc] init]; Object o = new Object();
NSString *s = @”string”; String s = “string”;

29. Basics
Objective-C Java
#import “MyType.h” import me.app.MyType;
- (void)method; public void method() { ... }
+ (void)method; static public void method() { ... }
const, (...readonly...) final
static static
package
nil null

30. Basics
•
(Almost) all C/C++-stuff (if, for, while,...)
•
Pointers (*) to objects.
•
Pointer = reference to another value in memory
[instance message:argument1 otherParameter:argument2];

31. Stuff0x3DE2FE
Basics

32. Stuff0x3DE2FE
Basics

33. Stuff0x3DE2FE
Basics

34. Object* Stuff0x3DE2FE
Basics

35. .h & .m
•
ObjC type = interface + implementation
•
.h: header file, type contract to the outside world
@implementation MyType
- (void)myMessage:(int)myParam
{
// Do stuff...
}
@end
@interface MyType
- (void)myMessage:(int)myParam;
@end
•
.m: messages (old stuff) file, implementation (actual code)

36. Messages
•
Message: just a fancy name for a method call
•
Interpreted in runtime: objects decide if they respond to messages
•
self = this object (can message self)
•
super = base (parent) object (can message super)

37. Properties
•
Syntactic sugar on instance variables
•
Clang generates setters and getters automatically (it was not always
like this)
•
Atomic by default! (use nonatomic to remove lock)
@property (nonatomic, copy) NSString *myProperty;

38. •
Protocol: just a fancy name for an interface (defines an expected
behaviour)
•
Messages and properties can be mandatory or optional
•
Used in the delegate pattern: “will ask somebody (the delegate)
something”
Protocols

39. @interface MyType : NSObject<MyProtocol>
@end
@protocol MyProtocol
- (void)myMandatoryMessage;
@optional
- (void)myOptionalMessage;
@end
Protocols

40. Categories
•
Category: allows to extend a class without inheritance
•
Add new messages without recompile!
•
Warning: existing messages can be “replaced”. Category messages
take precedence.
•
Similar to .NETs extension methods

41. Categories
@implementation UIColor (MyColors)
+ (UIColor*)myAwesomeColor
{
return ...;
}
+ (UIColor*)blackColor
{
// I told ya...
return [UIColor redColor];
}
@end
@interface UIColor (MyColors)
+ (UIColor*)myAwesomeColor;
+ (UIColor*)blackColor; // Oops!
@end

42. Collections
•
Store “things”
•
Jumble! (can mix Strings with Numbers with Astrocreeps...)
•
Arrays, Dictionary, Sets
•
Immutable: once set can’t change (NSArray, NSDictionary, NSSet)
•
Mutable: can change (NSMutableArray, NSMutableDictionary,
NSMutableSet)
•
Sort, filter, query, enumerate, map & other cool stuff

43. Memory
•
Instantiate new object: MyType *myType = [[MyType alloc] init];
•
Reference count: keep track of the number of instances. If 0
deallocate object
•
ARC does retain/release for you automatically.
•
References: strong (retain), weak, copy (new immutable object)

44. Blocks
•
Closures: fancy name for functions that can be passed around like
data
•
Key to lots of ObjC features: collection enumeration, Grand Central
Dispatch (threads), animations
•
Explicit or inline definition
•
Context variable must be marked with __block if changed within
block

45. self.square.backgroundColor = [UIColor redColor];
...
- (void)animate:(id)sender
{
[UIView animateWithDuration:3.0 animations:^{
self.square.backgroundColor = [UIColor greenColor];
}];
}
Blocks

46. Demo
github.com/fbernardo/fct_ios_workshop/releases

47. Thank you
@fbbernardo @PragmaPilot