New version of the delegateless coordinators pattern presentation, updated with new implementation, also translated to English

2. Delegateless
Coordinators
Or yet… Event Based Coordinators

3. About me - Tales Pinheiro de Andrade
!@talesp, tales.andrade@concrete.com.br
!MSc Computer Science
!iOS Chapter Leader at Concrete
!CocoaHeads São Paulo Chapter Leader, CocoaHeads Brasil supporter
!C developer since 2003
!iOS since 2010
!Objective-C developer since 2007, Swift since 2015

4. Sumary
Content
!MVC Problems
!Introduction to Coordinators
!Delegation
!Base solution
!Chain of Responsibility
!Delegateless Coordinators

5. MVC Problems

6. MVC Problems
Responsibilities
Dependency Injection
Navigation Flow
• Layout
• Model-View binding
• Subview management
• User Input/Interaction
• Data
• Fetching
• Transformation
• Persistency
• Error Handling
• Navigation Flow

7. MVC Problems
Responsibilities
Dependency Injection
Navigation Flow
• Core Data/Realm
• Network
• Cache
• SomethingManager
• Frameworks de DI
• Typhon
• Kraken
• Perform
• SwiftDependencyInjection
• Swinject

8. MVC Problems
Responsibilities
Dependency Injection
Navigation Flow

9. Navigation Flow
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
if segue.identifier !== "showDetail" {
if let indexPath = tableView.indexPathForSelectedRow {
let object = fetchedResultsController.object(at: indexPath)
let controller = (segue.destination as! UINavigationController)
.topViewController as! DetailViewController
controller.detailItem = object
}
}
}

10. Introduction to
Coordinators

11. So what is a coordinator?
A coordinator is an object that bosses one or more view
controllers around. Taking all of the driving logic out of
your view controllers, and moving that stuff one layer
up is gonna make your life a lot more awesome.
Coordinators Redux
(Soroush Khanlou)

12. So what is a coordinator?
The Coordinator is a PONSO, like all great objects. For
something like Instagram’s photo creation flow, we could
have a PhotoCreationCoordinator. The app
coordinator could spawn a new one, and pass it the
root view controller so that it could present the first
view controller in the flow.
The Coordinator
(Soroush Khanlou)

14. Delegation

15. Delegation
Delegation is a way to make composition as powerful for reuse
as inheritance. In delegation, two objects are involved in
handling a request: a receiving object delegates operations to
its delegate. This is analogous to subclasses deferring requests
to parent classes. But with inheritance, an inherited operation
can always refer to the receiving object through the this
member variable in C++ and self in Smalltalk. To achieve the
same effect with delegation, the receiver passes itself to the
delegate to let the delegated operation refer to the receiver.

16. Delegation: Knight Rider & RoboCop
Let’s start with a story: Once upon a time, there was a man with no name.
Knight Industries decided that if this man were given guns and wheels and
booster rockets, he would be the perfect crime-fighting tool. First they
thought, “Let’s subclass him and override everything we need to add the
guns and wheels and booster rockets.” The problem was that to subclass
Michael Knight, they needed to wire his insides to the guns, wheels, and
booster rockets – a time-consuming task requiring lots of specialized
knowledge. So instead, Knight Industries created a helper object, the
Knight Industries 2000, or “KITT,” a well-equipped car designed to assist
Michael Knight in a variety of crime- fighting situations.

17. Delegation: Super Máquina e RoboCop
While approaching the perimeter of an arms dealer’s compound, Michael
Knight would say, “KITT, I need to get to the other side of that wall.” KITT
would then blast a big hole in the wall with a small rocket. After destroying
the wall, KITT would return control to Michael, who would charge through
the rubble and capture the arms dealer.
Note how creating a helper object is different from the RoboCop
approach. RoboCop was a man subclassed and extended. The RoboCop
project involved dozens of surgeons who extended the man into a fighting
machine. This is the approach taken by many object-oriented frameworks.

18. Delegation: Super Máquina e RoboCop
In the Cocoa framework, many objects are extended in the Knight
Industries way – by supplying them with helper objects. In this section, you
are going to provide the speech synthesizer with a type of helper object
called a delegate.
From Cocoa Programming for OS X: The Big Nerd Ranch Guide

20. MVC-C · Injecting
Coordinator pattern in
UIKit
Taking the first step towards clean and minimal
app architecture in iOS app means freeing your
view controllers from the burden of dealing with
other controllers.

21. Implementation
Responder objects—that is, instances of UIResponder—
constitute the event-handling backbone of a UIKit app.
Many key objects are also responders, including the
UIApplication object, UIViewController objects, and all
UIView objects (which includes UIWindow). As events
occur, UIKit dispatches them to your app's responder
objects for handling.
UIResponder
Documentation
UIEvent
UIResponder children
View Controller

22. Implementação
In addition to handling events, UIKit responders also
manage the forwarding of unhandled events to other
parts of your app. If a given responder does not
handle an event, it forwards that event to the next
event in the responder chain. UIKit manages the
responder chain dynamically, using predefined rules to
determine which object should be next to receive an
event. For example, a view forwards events to its
superview, and the root view of a hierarchy forwards
events to its view controller.
UIResponder
Documentation
UIEvent
UIResponder children
View Controller

23. Implementação
UIResponder
Documentation
UIEvent
UIResponder children
View Controller

24. Implementação
UIResponder
Documentation
UIEvent
UIResponder children
View Controller

25. Implementação
UIResponder
Documentation
UIEvent
UIResponder children
View Controller

26. Implementação
UIResponder
Documentation
UIEvent
UIResponder children
View Controller

27. Implementação
UIResponder
Documentation
UIEvent
UIResponder children
View Controller

28. UIResponder children
open class UIView : UIResponder
open class UIViewController : UIResponder
open class UIWindow : UIView
class AppDelegate : UIResponder
open class UIApplication : UIResponder

29. Implementation - UIResponder
extension UIResponder {
public var coordinatingResponder: UIResponder? {
return next
}
}
extension UIResponder {
func messageTemplate(args: Whatever, sender: Any?) {
coordinatingResponder!?.messageTemplate(args: args, sender: sender)
}
}
extension UIResponder {
func cartBuyNow(_ product: Product, sender: Any?) { … }
func cartAdd(product: Product, color: ColorBox,
sender: Any?, completion: @escaping (Bool, Int) !-> Void) { … }
}

30. Chain of
Responsibility

31. Chain-of-Responsibility
In object-oriented design, the chain-of-responsibility pattern is a
design pattern consisting of a source of command objects and a
series of processing objects. Each processing object contains logic
that defines the types of command objects that it can handle; the rest
are passed to the next processing object in the chain. A mechanism
also exists for adding new processing objects to the end of this chain.
Thus, the chain of responsibility is an object oriented version of the
if ... else if ... else if ....... else ... endif idiom, with the benefit that the
condition–action blocks can be dynamically rearranged and
reconfigured at runtime.

32. Delegateless
Coordinators
Our solution

33. There are several kinds of events, including touch
events, motion events, remote-control events, and
press events. To handle a specific type of event, a
responder must override the corresponding
methods. For example, to handle touch events, a
responder implements the touchesBegan(_:with:),
touchesMoved(_:with:), touchesEnded(_:with:), and
touchesCancelled(_:with:) methods. In the case of
touches, the responder uses the event information
provided by UIKit to track changes to those touches
and to update the app's interface appropriately.
Remembering
Events
Defining Events
Protocol
Base implementation
Child management
Event handling

34. Defining Events
protocol AppEventType { }
protocol AppEventSubType { }
protocol AppEvent {
var type: AppEventType { get }
var subtype: AppEventSubType? { get }
}

35. Defining Events
protocol AppEvent { }

36. protocol AppEvent { }
public protocol CoordinatorProtocol: AnyObject, NSObjectProtocol {
var identifier: String { get }
var parent: CoordinatorProtocol? { get set }
var childCoordinators: [String: CoordinatorProtocol] { get }
var handlers: [String: (AppEvent) !-> Void] { get }
func start(with completion: @escaping () !-> Void)
func stop(with completion: @escaping () !-> Void)
func startChild(coordinator: CoordinatorProtocol, completion: @escaping () !-> Void)
func stopChild(coordinator: CoordinatorProtocol, completion: @escaping () !-> Void)
func target<T: AppEvent>(forEvent event: T) !-> CoordinatorProtocol?
func handle<T: AppEvent>(event: T) throws
func add<T: AppEvent>(eventType: T.Type, handler: @escaping (T) !-> Void)
func canHandle<T: AppEvent>(event: T) !-> Bool
}
CoordinatorProtocol Protocol

37. Base implementation
open class Coordinator: NSObject, CoordinatorProtocol {
public var parent: CoordinatorProtocol?
public var childCoordinators: [String : CoordinatorProtocol] = [:]
public weak var rootViewController: UIViewController?
public init(rootViewController: UIViewController?) {
self.rootViewController = rootViewController
}
open func start(with completion: @escaping () !-> Void = {}) {
self.rootViewController!?.parentCoordinator = self
completion()
}
open func stop(with completion: @escaping () !-> Void = {}) {
self.rootViewController!?.parentCoordinator = nil
completion()
}

38. Child management
open class Coordinator: NSObject, CoordinatorProtocol {
open func startChild(coordinator: CoordinatorProtocol,
completion: @escaping () !-> Void = {}) {
childCoordinators[coordinator.identifier] = coordinator
coordinator.parent = self
coordinator.start(with: completion)
}
public func stopChild(coordinator: CoordinatorProtocol,
completion: @escaping () !-> Void = {}) {
coordinator.parent = nil
coordinator.stop { [unowned self] in
self.childCoordinators.removeValue(forKey: coordinator.identifier)
completion()
}
}

39. Event handling
open class Coordinator: NSObject, CoordinatorProtocol {
public final func add<T>(eventType: T.Type,
handler: @escaping (T) !-> Void) where T : AppEvent {
handlers[String(reflecting: eventType)] = { event in
guard let realEV = event as? T else { return }
handler(realEV)
}
}
public final func handle<T: AppEvent>(event: T) throws {
let target = self.target(forEvent: event)
guard let handler = target!?.handlers[String(reflecting: type(of: event))] else {
throw AppEventError.eventNotHandled(event)
}
handler(event)
}

40. Event handling - helper functions
open class Coordinator: NSObject, CoordinatorProtocol {
public final func canHandle<T: AppEvent>(event: T) !-> Bool {
return handlers[String(reflecting: type(of: event))] !!= nil
}
public func target<T: AppEvent>(forEvent event: T) !-> CoordinatorProtocol? {
guard self.canHandle(event: event) !!= true else { return self }
var next = self.parent
while next!?.canHandle(event: event) !== false {
next = next!?.parent
}
return next
}

41. Event handling - helper functions
enum SignEvent: AppEvent {
case signIn
case signUp
}
enum SignInEvent: AppEvent {
typealias Username = String
typealias Password = String
case signIn(Username, Password)
case emptyUsernameOrPassword
}

42. Event handling - helper functions
override func start(with completion: @escaping () !-> Void = {}) {
self.add(eventType: SignEvent.self) { [weak self] event in
switch event {
case .signIn:
guard let navigationCoordinator = self!?.navigationCoordinator else {
fatalError("something went wrong")
}
let childCoordinator = SignInCoordinator(rootViewController: navigationCoordinator.rootViewController)
navigationCoordinator.startChild(coordinator: childCoordinator)
case .signUp: !// Start a child coordinator, go to some view controller or do something else…
}
}
self.add(eventType: SignInEvent.self) { [weak self] event in
switch event {
case .emptyUsernameOrPassword:!// treat error? show alert?
case let .signIn(username, password):
print("Auth with Username: (username) - password: (password)")
guard let navigationCoordinator = self!?.navigationCoordinator else {
fatalError("super.handle(event: event, withSender: self)")
}
self!?.stopChild(coordinator: navigationCoordinator)
guard let tabBarCoordinator = self!?.setupTabCoordinator() else { return }
self!?.startChild(coordinator: tabBarCoordinator)
}
}
super.start(with: completion)
}

43. AppCoordinator
SignCoordinator
SignInCoordinator
SignInViewController
SignUpCoordinator
SignUpViewController
TabBarCoordinator
ProductListCoordinator
UINavigationController
ProductListViewController ProductDetailViewController
ShoppingCartCoordinator
ShoppingCartViewController
ProfileCoordinator
ProfileViewController

44. DEMO TIME
See here:
https://github.com/talesp/DelegatelessCoordinators

45. Thank you
GitHub.com/talesp/DelegatelessCoordinators
@talesp
tales.andrade@concrete.com.br

46. N Ó S M O V E M O S O M U N D O .
RIO SÃO PAULO BH RECIFE
Centro
Av. Presidente Wilson, 231
29º andar
(21) 2240-2030
Cidade Monções
Av. Nações Unidas, 11.541
3º andar
(11) 4119-0449
Savassi
Av. Getúlio Vargas, 671
Sala 800 - 8º andar
(31) 3360-8900
Ilha do Leite
Rua Sen. José Henrique, 199
2º andar
(81) 3018-6299
W W W. C O N C R E T E . C O M . B R