# Tworzenie tab bara i navigation controllera programistycznie w UIKit

By Tarik Pinarci (https://tarikpinarci.com). Published 2023-05-11. Canonical: https://tarikpinarci.com/pl/blog/creating-tabbar-and-navigation-controller-programmatically-in-uikit

Przy tworzeniu aplikacji na iOS w UIKit zawsze skłaniałem się ku podejściu programistycznemu. Storyboardy na początku mogą wydawać się wygodne, ale przy nich czuję się bardziej jak projektant niż programista. Poza tym, jeśli chodzi o skalowalność i łatwość utrzymania, podejście programistyczne zawsze wypada u mnie lepiej.

W tym artykule pokażę, jak w UIKit stworzyć tab bar controller połączony z navigation controllerem.

### Konfiguracja SceneDelegate

Pierwszym krokiem w podejściu programistycznym jest zmiana kodu „root” naszej aplikacji. Nazywam go tak, bo przypomina mi App.js albo index.js w React/React Native. To punkt wejścia do naszej aplikacji lub sceny. W iOS w klasie SceneDelegate znajdziemy funkcję scene, której użyjemy wyłącznie do skonfigurowania aplikacji pod programistyczne podejście.

Poniżej domyślna struktura klasy SceneDelegate:

```swift
    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.
      }
    }
```

Zmienimy tylko tę funkcję:

```swift
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 }
  }
```

### Aktualizacja funkcji scene w SceneDelegate

W poniższym fragmencie kodu bezpiecznie pobieramy windowScene za pomocą instrukcji guard. Następnie przypisujemy tę windowScene do właściwości window, zdefiniowanej w klasie SceneDelegate. Na koniec wywołujemy metodę makeKeyAndVisible, żeby okno stało się key window.

```swift
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()
}
```

Teraz zajmijmy się stworzeniem tab bar controllera. Ten controller będzie zarządzał view controllerami dla każdej zakładki w aplikacji. **_Na przykład, jeśli mamy dwie zakładki, potrzebujemy dwóch osobnych navigation controllerów._** Ale dlaczego wybieramy navigation controllery? Dlatego, że chcemy mieć osobny navigation controller w każdej zakładce. Weźmy jako przykład zakładkę „Profile”. Ekran profilu będzie głównym widokiem tej zakładki, ale w jej obrębie możemy mieć dodatkowe widoki, między którymi chcemy nawigować. Właśnie dlatego dla każdej zakładki używamy navigation controllera. Daje on funkcjonalność potrzebną do płynnej nawigacji między różnymi view controllerami w ramach jednej zakładki.

Czas na kod!

```swift
 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

  }
```

Po zainicjalizowaniu tab bar controllera tworzymy dwa navigation controllery, które odpowiadają dwóm zakładkom w naszej aplikacji. Pierwszy view controller to ten domyślny, a drugi, czyli SecondViewController, omówię w następnej sekcji. SecondViewController to zwykły view controller, podobny do domyślnego.

Żeby skonfigurować zakładki, ustawiamy właściwość tabItem każdego navigation controllera za pomocą UITabBarItem.

Na koniec przypisujemy utworzone view controllery do właściwości viewControllers tab bar controllera.

A najważniejszy krok to ustawienie tab bar controllera jako rootViewController okna. Dzięki temu tab bar razem z navigation controllerami w każdej zakładce znajduje się na samej górze hierarchii naszej aplikacji.

### View controllery w akcji

Spójrzmy na naszą klasę ViewController poniżej:

```swift
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
    }

}
```

I SecondViewController (_wiem, wiem, kiepskie nazewnictwo…_)

![„SecondViewController”](https://cdn-images-1.medium.com/max/2000/1*38H_rYXGqsbZNlvJXlyWpg.gif)

```swift
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
    }

}
```

> Oczywiście ten kod jest dość powtarzalny. Ale na potrzeby tego artykułu można to pominąć.

Te dwa view controllery są w zasadzie identyczne, poza tytułami i akcjami przycisków. Oba renderują przede wszystkim label na środku ekranu z nazwą bieżącego ekranu. Do tego mają przycisk na dole ekranu, który pozwala przełączać się między zakładkami. Tak w skrócie wygląda podstawowa funkcjonalność tych view controllerów.

### Aktualny obraz

Mamy teraz w pełni programistyczną aplikację, która korzysta z tab bara i navigation controllera, bez ani jednego storyboardu!

![Faktycznie brzydkie, ale działa](https://cdn-images-1.medium.com/max/2000/1*Mh9-aPrme1BRh4QRjRhkVw.gif)

### Podsumowanie

Podsumowując, podejście programistyczne daje większą kontrolę nad projektem i skalowalnością aplikacji i pozwala developerom skupić się na programowaniu zamiast polegać wyłącznie na storyboardach. Dotyczy to zwłaszcza problemów z IBAction/IBOutlet. Jeden konkretny problem przy refaktoryzacji kodu ze zmiennymi IBOutlet i IBAction to konieczność ponownego podpinania połączeń po wprowadzeniu zmian. Z mojego doświadczenia: po kilku dniach pracy z codebase'em trafiałem na niespodziewane crashe aplikacji bez żadnego jasnego wyjaśnienia. Po dokładniejszym sprawdzeniu okazało się, że przyczyną tych crashy były zmienione nazwy zmiennych IBOutlet i IBAction. Za każdym razem musiałem ręcznie ponownie podpinać te zmienne, żeby przywrócić ich działanie. To potrafi zabrać sporo czasu, frustruje i rozbija rytm pracy.

Dzięki za przeczytanie!

```

```

