Modèle de coordinateur iOS

Jan 18 2023

Dans l'article d'aujourd'hui, explorons en détail le modèle de coordinateur. Nous verrons comment configurer un coordinateur à partir de zéro et verrons les avantages de l'implémenter dans les projets iOS Contexte…….

Arrière-plan…….

Comme nous le savons tous, les modèles de conception iOS les plus utilisés sont MVVM et MVC (il peut parfois s'agir d'un contrôleur de vue massif ). L'un des plus gros inconvénients de ces modèles est que les contrôleurs détiennent la logique de routage. Ici, le routage peut consister à initialiser et à gérer les contrôleurs suivants dans le flux métier.

Modèle de coordinateur…….

Le modèle de coordinateur surmonte ce problème en faisant abstraction de la logique de routage. Ici tous les contrôleurs de vue qui peuvent être regroupés logiquement sous un flux métier coordonné avec le coordinateur. Le coordinateur est seul responsable du prochain contrôleur dans le flux d'affaires. Cela rend la logique de routage plus lisible, maintenable et extensible.

Coordinateur HLD….

Coordinateur en action…..

Voyons maintenant comment créer un modèle de coordinateur à partir de rien.

Protocole du coordinateur : créons une interface pour nos coordinateurs qui oblige tous les coordinateurs à s'aligner sur nos attentes.

navController : ce serait le contrôleur de navigation pour gérer la pile du viewcontroller.
eventOccurred(T): Ceci serait utilisé par notre viewcontroller pour mettre à jour tout événement de navigation vers le coordinateur
start() : cette méthode unique est appelée pour démarrer le flux d'activité

protocol Coordinator {
    var navController : UINavigationController? { get set }

    func eventOccurred<T: RawRepresentable>(type: T) where T.RawValue == Int
    func start()
}

coordinateur : ce serait la référence du coordinateur par lequel le contrôleur de vue peut publier des événements
CoordinatingVC : nous allons également créer un typealias pratique pour nos viewcontrollers

protocol Coordinating {
    var coordinator: Coordinator? { get set}
}

typealias CoordinatingVC = UIViewController & Coordinating

ajoutez un titre pour identifier le contrôleur, dites écran 1
ajouter un CTA pour passer au contrôleur suivant
appelez eventOccurred(type: MainCoordinatorEvent.screen2) pour publier l'événement à notre coordinateur.
implémenter de la même manière ViewController2

class ViewController: CoordinatingVC {
    var coordinator: Coordinator?

    override func viewDidLoad() {
        super.viewDidLoad()
        setUp()
        setUpCTA()
    }

    private func setUp() {
        self.view.backgroundColor = .white
        self.title = "Screen1"
    }

    private func setUpCTA() {
        let screen2CTA = UIButton()
        screen2CTA.setTitle("Go to Screen2", for: .normal)
        screen2CTA.backgroundColor = .gray
        view.addSubview(screen2CTA)

        screen2CTA.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            screen2CTA.leadingAnchor.constraint(equalTo: view.leadingAnchor,
                                                constant: AppUIConfig.padding),
            screen2CTA.trailingAnchor.constraint(equalTo: view.trailingAnchor,
                                                constant: -AppUIConfig.padding),
            screen2CTA.centerYAnchor.constraint(equalTo: view.centerYAnchor),
            screen2CTA.heightAnchor.constraint(equalToConstant: AppUIConfig.buttonheight)
        ])

        screen2CTA.addTarget(self,
                             action: #selector(screen2CTATapped),
                             for: .touchUpInside)
    }

    @objc func screen2CTATapped() {
        coordinator?.eventOccurred(type: MainCoordinatorEvent.screen2)
    }

}

implémentez start(), qui définit le contrôleur de navigation sur screen1 viewcontroller.
implémenter eventOccurred(type : T), ici le T générique serait MainCoordinatorEvent pour le contexte du coordinateur principal. nous apportons des modifications à la pile du contrôleur de navigation en fonction du type pour afficher le type de contrôleur de vue approprié (écran 1 ou écran 2)

enum MainCoordinatorEvent: Int {
    case screen2
    case screen1
}

class MainCoordinator : Coordinator {
    func eventOccurred<T>(type: T) where T : RawRepresentable, T.RawValue == Int {
        guard let type = type as? MainCoordinatorEvent else {
            return
        }

        switch type {
        case .screen2:
            setupScreen2()
        case .screen1:
            setupScreen1()
        }
    }

    var navController: UINavigationController?

    func start() {
        setupScreen1()
    }

    private func setupScreen1() {
        guard var navController = navController else {
            return
        }

        if let firstVC = navController.viewControllers.first {
            navController.popToViewController(firstVC, animated: true)
            return
        }

        var viewController: CoordinatingVC = ViewController()
        viewController.coordinator = self
        navController.setViewControllers([viewController], animated: false)
    }

    private func setupScreen2() {
        var viewController: CoordinatingVC = ViewController2()
        viewController.coordinator = self
        navController?.pushViewController(viewController, animated: true)
    }

}

fenêtre d'initialisation
init coordinateur principal

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        setUpWindow()
        return true
    }

    private func setUpWindow() {
        let window = createKeyWindow()
        let mainCoordinator = createMainCoordinator()
        window.rootViewController = mainCoordinator.navController
        window.makeKeyAndVisible()
        self.window = window
        mainCoordinator.start()
    }

    private func createMainCoordinator() -> Coordinator {
        let navViewController = UINavigationController()
        let mainCoordinator =  MainCoordinator()

        mainCoordinator.navController = navViewController
        return mainCoordinator
    }

    private func createKeyWindow() -> UIWindow {
        let window = UIWindow(frame: UIScreen.main.bounds)
        return window
    }

Maintenant que nous savons comment gérer un flux d'affaires en utilisant le modèle de coordinateur. Nous pouvons étendre le modèle de manière récursive pour gérer un groupe de coordinateurs simplifiant ainsi chaque flux d'utilisateurs regroupés logiquement à gérer par lui-même.

Suivre le modèle de coordinateur dans les applications iOS rend le routage entre les flux d'utilisateurs plus propre et plus robuste. Cela rend chaque contrôleur de vue vraiment isolé et facile à entretenir.