factory

AppDependency.swift

import Foundation

import HaihwanFoundation

struct AppDependency {

  let networking: NetworkingLogic
  let authWorker: AuthWorkerLogic
  let propertyWorker: PropertyWorkerLogic

  static func resolve() -> AppDependency {

    let networking = Networking()
    let userDefault = UserDefaults.standard

    return AppDependency(
      networking: networking,
      authWorker: AuthWorker(
        dependency: AuthWorker.Dependency(
          networking: networking,
          userDefault: userDefault
        )
      ),
      propertyWorker: PropertyWorker(
        dependency: PropertyWorker.Dependency(
          networking: networking,
          userDefault: userDefault
        )
      )
    )
  }
}

IntroRouter.swift

final class IntroRouter: IntroDataPassing {

  struct Dependency {
    let dataStore: IntroDataStore
  }

  var dataStore: IntroDataStore
  
  weak var viewController: IntroViewController?
  var sceneFactory: SceneFactoryLogic.Type = SceneFactory.self

  init(dependency: Dependency) {
    self.dataStore = dependency.dataStore
  }
  
}

SceneFactory.swift

import Foundation

protocol SceneFactoryLogic: class {

  static var start: (() -> StartViewController)! { get }
  static var main: ((MainFactory.Payload) -> MainViewController)! { get }
  static var intro: ((IntroFactory.Payload) -> IntroViewController)! { get }
  static var signUp: ((SignUpFactory.Payload) -> SignUpViewController)! { get }
  static var signIn: ((SignInFactory.Payload) -> SignInViewController)! { get }
  static func regist(_ appDependency: AppDependency)
}

final class SceneFactory: SceneFactoryLogic {

  static var start: (() -> StartViewController)!
  static var main: ((MainFactory.Payload) -> MainViewController)!
  static var intro: ((IntroFactory.Payload) -> IntroViewController)!
  static var signUp: ((SignUpFactory.Payload) -> SignUpViewController)!
  static var signIn: ((SignInFactory.Payload) -> SignInViewController)!
  
  static func regist(_ appDependency: AppDependency) {

    SceneFactory.start = {
      return StartViewController(
        dependency: StartViewController.Dependency(
          networking: appDependency.networking,
          authWorker: appDependency.authWorker,
          propertyWorker: appDependency.propertyWorker
        )
      )
    }

    SceneFactory.main = {
      return MainFactory(
        dependency: MainFactory.Dependency(
          networking: appDependency.networking,
          authWorker: appDependency.authWorker,
          propertyWorker: appDependency.propertyWorker
        )
      ).create(payload: $0)
    }

    SceneFactory.intro = {
      return IntroFactory(
        dependency: IntroFactory.Dependency(
          networking: appDependency.networking,
          propertyWorker: appDependency.propertyWorker
        )
      ).create(payload: $0)
    }

    SceneFactory.signIn = {
      return SignInFactory(
        dependency: SignInFactory.Dependency(
          networking: appDependency.networking,
          authWorker: appDependency.authWorker
        )
      ).create(payload: $0)
    }

    SceneFactory.signUp = {
      return SignUpFactory(
        dependency: SignUpFactory.Dependency(
          networking: appDependency.networking,
          authWorker: appDependency.authWorker
        )
      ).create(payload: $0)
    }
  }

}

SignInFactory.swift

import UIKit

import HaihwanFoundation

struct SignInFactory {

  struct Dependency {
    let networking: NetworkingLogic
    let authWorker: AuthWorkerLogic
  }

  struct Payload {

    let window: UIWindow
  }

  let dependency: Dependency

  init(dependency: Dependency) {
    self.dependency = dependency
  }

  func create(payload: Payload) -> SignInViewController {
    let viewController = SignInViewController()

    let presenter = SignInPresenter()

    presenter.viewController = viewController

    let interactor = SignInInteractor(
      dependency: SignInInteractor.Dependency(
        worker: SignInWorker(
          dependency: SignInWorker.Dependency()
        ),
        presenter: presenter
      )
    )

    let router = SignInRouter(
      dependency: SignInRouter.Dependency(
        dataStore: interactor
      )
    )

    router.window = payload.window
    router.viewController = viewController
    
    viewController.router = router
    viewController.interactor = interactor

    return viewController
  }
  
}