J’ai toujours préféré une approche entièrement par le code quand je développe des applications iOS avec UIKit. Les storyboards peuvent sembler pratiques au début, mais ils me donnent l’impression d’être davantage designer que développeur. Et surtout, en matière de scalabilité et de maintenabilité, je trouve systématiquement l’approche par le code supérieure.
Dans cet article, je vais détailler comment créer un tab bar controller combiné à un navigation controller avec UIKit.
Configurer le SceneDelegate
La première étape pour adopter une approche par le code consiste à modifier le code racine de notre application. Je l’appelle « racine » parce qu’il me rappelle App.js ou index.js en React/React Native. C’est le point d’entrée de notre application, ou de notre scène. Sous iOS, on trouve une fonction scene dans la classe SceneDelegate, et c’est uniquement elle que nous allons utiliser pour configurer notre application en mode programmatique.
Voici la structure par défaut de la classe SceneDelegate :
import UIKit
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
var window: UIWindow?
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
// Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
// If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
// This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
guard let _ = (scene as? UIWindowScene) else { return }
}
func sceneDidDisconnect(_ scene: UIScene) {
// Called as the scene is being released by the system.
// This occurs shortly after the scene enters the background, or when its session is discarded.
// Release any resources associated with this scene that can be re-created the next time the scene connects.
// The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions` instead).
}
func sceneDidBecomeActive(_ scene: UIScene) {
// Called when the scene has moved from an inactive state to an active state.
// Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
}
func sceneWillResignActive(_ scene: UIScene) {
// Called when the scene will move from an active state to an inactive state.
// This may occur due to temporary interruptions (ex. an incoming phone call).
}
func sceneWillEnterForeground(_ scene: UIScene) {
// Called as the scene transitions from the background to the foreground.
// Use this method to undo the changes made on entering the background.
}
func sceneDidEnterBackground(_ scene: UIScene) {
// Called as the scene transitions from the foreground to the background.
// Use this method to save data, release shared resources, and store enough scene-specific state information
// to restore the scene back to its current state.
}
}
Nous allons seulement modifier la fonction ci-dessous :
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
// Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
// If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
// This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
guard let _ = (scene as? UIWindowScene) else { return }
}
Mettre à jour la fonction scene dans le SceneDelegate
Dans l’extrait de code suivant, on récupère le windowScene de façon sûre grâce à l’instruction guard. On assigne ensuite ce windowScene à la propriété window, définie dans la classe SceneDelegate. Enfin, on appelle la méthode makeKeyAndVisible pour faire de cette fenêtre la key window.
var window: UIWindow?
func scene(\_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
guard let windowScene = (scene as? UIWindowScene) else { return }
window?.windowScene = windowScene
window?.makeKeyAndVisible()
}
Passons maintenant à la création du tab bar controller. Ce controller va gérer les view controllers de chaque onglet de notre application. Par exemple, si nous avons deux onglets, il nous faudra deux navigation controllers distincts. Mais pourquoi des navigation controllers ? Parce que nous voulons que chaque onglet ait son propre navigation controller. Prenons l’onglet « Profile » comme exemple. L’écran de profil sera la vue principale de cet onglet, mais nous pouvons avoir d’autres vues dans cet onglet entre lesquelles nous voulons naviguer. C’est pour cela que nous utilisons un navigation controller pour chaque onglet. Il fournit tout ce qu’il faut pour naviguer en douceur entre les différents view controllers d’un même onglet.
Codons tout ça !
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
guard let windowScene = (scene as? UIWindowScene) else { return }
window?.windowScene = windowScene
window?.makeKeyAndVisible()
let tabbar = UITabBarController()
let firstVC = UINavigationController(rootViewController: ViewController())
let secondVC = UINavigationController(rootViewController: SecondViewController())
firstVC.tabBarItem = UITabBarItem(title: "Home", image: UIImage(systemName: "house"),selectedImage: UIImage(systemName: "house.fill"))
secondVC.tabBarItem = UITabBarItem(title: "Profile", image: UIImage(systemName: "person"),selectedImage: UIImage(systemName: "person.fill"))
tabbar.viewControllers = [firstVC, secondVC]
window?.rootViewController = tabbar
}
Après avoir initialisé notre tab bar controller, nous créons deux navigation controllers, qui correspondent aux deux onglets de notre application. Le premier view controller est celui par défaut, tandis que le second, appelé SecondViewController, sera présenté dans la section suivante. SecondViewController est un view controller classique, semblable à celui par défaut.
Pour configurer les onglets, on définit la propriété tabItem de chaque navigation controller avec un UITabBarItem.
Enfin, on assigne les view controllers créés à la propriété viewControllers du tab bar controller.
Et l’étape la plus importante consiste à définir notre tab bar controller comme rootViewController de la fenêtre. Ainsi, la tab bar, avec les navigation controllers de chaque onglet, se trouve tout en haut de la hiérarchie de notre application.
Les view controllers en action
Jetons un œil à notre classe ViewController ci-dessous :
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
}
func setupUI(){
view.backgroundColor = .white
let homeLabel: UILabel = {
let label = UILabel()
label.text = "This is home screen"
label.translatesAutoresizingMaskIntoConstraints = false
return label
}()
let homeButton: UIButton = {
let button = UIButton()
button.setTitle("Go to profile", for: .normal)
button.setTitleColor(.white, for: .normal)
button.backgroundColor = .systemOrange
button.translatesAutoresizingMaskIntoConstraints = false
button.addTarget(self, action: #selector(goToProfile), for: .touchUpInside)
return button
}()
view.addSubview(homeButton)
view.addSubview(homeLabel)
NSLayoutConstraint.activate([
homeButton.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
homeButton.widthAnchor.constraint(equalTo: view.widthAnchor),
homeButton.heightAnchor.constraint(equalToConstant: 72),
homeLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
homeLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])
}
@objc func goToProfile(){
tabBarController?.selectedIndex = 1
}
}
Et voici SecondViewController (oui, je sais, le nommage n’est pas terrible…)

class SecondViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
}
func setupUI(){
view.backgroundColor = .white
let profileLabel: UILabel = {
let label = UILabel()
label.translatesAutoresizingMaskIntoConstraints = false
label.text = "This is profile screen"
return label
}()
let profileButton: UIButton = {
let button = UIButton()
button.setTitle("Go to home", for: .normal)
button.setTitleColor(.white, for: .normal)
button.backgroundColor = .systemOrange
button.translatesAutoresizingMaskIntoConstraints = false
button.addTarget(self, action: #selector(goToHome), for: .touchUpInside)
return button
}()
view.addSubview(profileButton)
view.addSubview(profileLabel)
NSLayoutConstraint.activate([
homeButton.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
homeButton.widthAnchor.constraint(equalTo: view.widthAnchor),
homeButton.heightAnchor.constraint(equalToConstant: 72),
homeLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
homeLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor)
])
}
@objc func goToHome(){
tabBarController?.selectedIndex = 0
}
}
Évidemment, le code est assez répétitif. Mais on peut l’ignorer pour les besoins de cet article.
Ces deux view controllers sont pratiquement identiques, à part leurs titres et les actions de leurs boutons. Tous deux affichent principalement un label au centre de l’écran, qui indique le nom de l’écran courant. Ils comportent aussi un bouton en bas de l’écran qui permet de naviguer entre les onglets. Voilà pour l’essentiel de leur fonctionnement.
Le résultat final
Nous avons maintenant une application entièrement programmatique qui utilise une tab bar et un navigation controller, sans aucun storyboard !

Conclusion
Pour conclure, l’approche par le code offre un meilleur contrôle sur le design et la scalabilité de l’application, et permet aux développeurs de se concentrer sur la programmation plutôt que de dépendre uniquement des storyboards. C’est particulièrement vrai pour les problèmes liés aux IBAction/IBOutlet**. **Un problème typique survient lors du refactoring de code contenant des variables IBOutlet et IBAction : il faut rétablir les connexions après chaque modification. Dans mon cas, après quelques jours de travail sur la codebase, l’application s’est mise à crasher sans explication claire. En creusant, j’ai découvert que ces crashs venaient des variables IBOutlet et IBAction que j’avais renommées. À chaque fois, je devais reconnecter manuellement les variables concernées pour qu’elles fonctionnent à nouveau. C’est un processus long et frustrant, qui casse le rythme de développement.
Merci de m’avoir lu !