# Tab Bar und Navigation Controller in UIKit programmatisch erstellen

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

Wenn ich iOS-Apps mit UIKit entwickle, habe ich schon immer einen programmatischen Ansatz bevorzugt. Storyboards wirken anfangs vielleicht bequem, aber durch sie fühle ich mich eher wie ein Designer als wie ein Programmierer. Außerdem finde ich den programmatischen Ansatz in Sachen Skalierbarkeit und Wartbarkeit jedes Mal überlegen.

In diesem Artikel erkläre ich, wie man mit UIKit einen Tab Bar Controller in Kombination mit einem Navigation Controller erstellt.

### SceneDelegate einrichten

Der erste Schritt zu einem programmatischen Ansatz ist, den Root-Code unserer Anwendung anzupassen. Ich nenne ihn "Root", und er erinnert mich an App.js oder index.js in React/React Native. Er dient als Einstiegspunkt für unsere Anwendung oder Scene. In iOS finden wir in der Klasse SceneDelegate eine scene-Funktion, die wir ausschließlich dafür nutzen, unsere Anwendung für die programmatische Entwicklung zu konfigurieren.

Hier ist die Standardstruktur der Klasse 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.
      }
    }
```

Wir aktualisieren nur die folgende Funktion:

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

### Die scene-Funktion in SceneDelegate aktualisieren

Im folgenden Snippet holen wir die windowScene sicher mit dem guard-Statement. Danach weisen wir diese windowScene der Eigenschaft window zu, die in der Klasse SceneDelegate definiert ist. Schließlich rufen wir die Methode makeKeyAndVisible auf, um das Fenster zum Key Window zu machen.

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

Als Nächstes konzentrieren wir uns darauf, den Tab Bar Controller zu erstellen. Dieser Controller verwaltet die View Controller für jeden Tab in unserer App. **_Wenn wir zum Beispiel zwei Tabs haben, brauchen wir zwei separate Navigation Controller._** Aber warum entscheiden wir uns für Navigation Controller? Weil wir in jedem Tab einen eigenen Navigation Controller haben wollen. Nehmen wir den Tab "Profile" als Beispiel. Der Profil-Screen ist die Hauptansicht dieses Tabs, aber vielleicht gibt es innerhalb des Tabs weitere Views, zwischen denen wir navigieren wollen. Deshalb nutzen wir für jedes Tab-Item einen Navigation Controller. Sie liefern die nötige Funktionalität, um innerhalb eines Tabs flüssig zwischen verschiedenen View Controllern zu navigieren.

Lass uns das programmieren!

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

  }
```

Nachdem wir unseren Tab Bar Controller initialisiert haben, erstellen wir zwei Navigation Controller, die den zwei Tab-Items in unserer App entsprechen. Der erste View Controller ist der Standard-Controller, während der zweite, SecondViewController, im nächsten Abschnitt behandelt wird. SecondViewController ist ein normaler View Controller, ähnlich wie der Standard-Controller.

Um die Tab-Items zu konfigurieren, setzen wir die Eigenschaft tabItem jedes Navigation Controllers mit UITabBarItem.

Schließlich weisen wir die erstellten View Controller der Eigenschaft viewControllers des Tab Bar Controllers zu.

Und der wichtigste Schritt ist, den rootViewController des Fensters auf unseren Tab Bar Controller zu setzen. So steht die Tab Bar samt der Navigation Controller in jedem Tab-Item ganz oben in der Hierarchie unserer App.

### View Controller in Aktion

Werfen wir einen Blick auf unsere Klasse ViewController:

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

}
```

Und SecondViewController (_ich weiß, eine schlechte Namenskonvention hier…_)

![“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
    }

}
```

> Natürlich ist der Code ziemlich repetitiv. Für den Zweck dieses Artikels kann man das aber vernachlässigen.

Diese beiden View Controller sind im Wesentlichen identisch, abgesehen von ihren Titeln und den Aktionen der Buttons. Beide Controller rendern vor allem ein Label in der Mitte des Screens, das den Namen des aktuellen Screens beschreibt. Außerdem haben sie unten auf dem Screen einen Button, mit dem man zwischen den Tab-Items navigieren kann. Das ist im Kern die Funktionalität dieser View Controller.

### Das aktuelle Bild

Wir haben jetzt eine vollständig programmatische App, die Tab Bar und Navigation Controller nutzt, mit genau 0 Storyboards!

![Zugegeben hässlich, aber funktional](https://cdn-images-1.medium.com/max/2000/1*Mh9-aPrme1BRh4QRjRhkVw.gif)

### Fazit

Zusammengefasst gibt ein programmatischer Ansatz mehr Kontrolle über das Design und die Skalierbarkeit der App, sodass sich Entwickler auf das Programmieren konzentrieren können, statt sich nur auf Storyboards zu verlassen. Das gilt besonders für Probleme mit IBAction/IBOutlet**. **Ein konkretes Problem beim Refactoring von Code mit IBOutlet- und IBAction-Variablen ist, dass man die Verbindungen nach Änderungen neu herstellen muss. Nach ein paar Tagen Arbeit an der Codebase hatte ich unerwartete Abstürze in der App, ohne klare Erklärung. Bei genauerem Hinsehen habe ich herausgefunden, dass die Ursache umbenannte IBOutlet- und IBAction-Variablen waren. Jedes Mal, wenn das passierte, musste ich die betroffenen Variablen manuell neu verbinden, damit sie wieder funktionieren. Das kann ein zeitraubender und frustrierender Prozess sein, der den Entwicklungsablauf stört.

Danke fürs Lesen!

```

```

