Как хранить путь в приложении с несколькими вкладками?

Хранение состояния навигации в приложении с несколькими вкладками

Это классический вопрос архитектуры iOS1приложений, который затрагивает навигацию, состояние и поток данных. В современном iOS-разработке есть несколько основных подходов, выбор которых зависит от архитектуры приложения, используемых технологий и требований к UX.

Основные проблемы и требования

При хранении пути (navigation stack) в multi-tab приложении нужно учитывать:

• Изоляция стэков: Каждая вкладка должна иметь независимый стек навигации (UINavigationController), чтобы переключение между табами не сбрасывало историю переходов внутри каждой из них.
• Восстановление состояния: При повторном запуске приложения или при переходе в фоновый режим и обратно, пользователь должен видеть тот же самый экран на той же вкладке.
• Глубокие ссылки (Deep Linking): Возможность открыть конкретный экран на конкретной вкладке по URL-схеме или универсальной ссылке.
• Координация навигации: Управление переходами между табами и внутри них, часто с использованием паттерна Координатор (Coordinator).

Подход 1: Классический на основе UITabBarController (и хранение в UserDefaults)

Самый простой и нативный способ — положиться на встроенные механизмы UITabBarController и UINavigationController.

class MainTabBarController: UITabBarController {
    // 1. Создаем навигейшн контроллеры для каждой вкладки
    let feedNavVC = UINavigationController(rootViewController: FeedViewController())
    let profileNavVC = UINavigationController(rootViewController: ProfileViewController())
    let messagesNavVC = UINavigationController(rootViewController: MessagesViewController())

    override func viewDidLoad() {
        super.viewDidLoad()
        self.viewControllers = [feedNavVC, profileNavVC, messagesNavVC]
    }

    // 2. Восстановление пути при запуске (упрощенный пример)
    func restoreNavigationState() {
        if let lastViewedTabIndex = UserDefaults.standard.integer(forKey: "lastViewedTab") as? Int {
            self.selectedIndex = lastViewedTabIndex
        }
        // Восстановление стэка внутри конкретной вкладки потребует сериализации массива идентификаторов экранов
    }
}

Как хранить путь?

• Индекс выбранной вкладки: Легко сохранить в UserDefaults или в Keychain для безопасности.
• Стэк навигации внутри вкладки: Это сложнее. Можно сохранять массив String (идентификаторов экранов или типов) в том же UserDefaults, но это быстро становится громоздким. Более продвинутый способ — использовать Codable для сериализации легковесных моделей состояния каждого экрана.

Подход 2: Использование архитектурных паттернов (Router/Coordinator + State Container)

Современные приложения часто используют более декларативные и управляемые состояниями подходы.

Координатор (Coordinator)

Каждая вкладка управляется своим собственным Coordinator, который отвечает за всю навигацию внутри этой вкладки. Главный AppCoordinator управляет таббаром и переключением между координаторами вкладок.

protocol Coordinator {
    func start()
    var childCoordinators: [Coordinator] { get set }
}

class FeedTabCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    let navigationController: UINavigationController

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func start() {
        let feedVC = FeedViewController()
        feedVC.didSelectItem = { [weak self] item in
            self?.showDetails(for: item)
        }
        navigationController.pushViewController(feedVC, animated: false)
    }

    private func showDetails(for item: FeedItem) {
        let detailVC = DetailViewController(item: item)
        navigationController.pushViewController(detailVC, animated: true)
    }
}

Где хранить путь? Фактически, путь "хранится" в самой структуре координаторов и в стеке UINavigationController.viewControllers. Для сохранения состояния можно сделать все координаторы и их дочерние контроллеры сериализуемыми.

State Container (например, Redux-подобные решения)

Состояние всего приложения, включая навигацию, хранится в едином источнике истины (single source of truth).

struct AppState {
    var navigationState: NavigationState
}

struct NavigationState {
    var selectedTab: TabIdentifier = .feed
    var feedStack: [Route] = [.feedList]
    var profileStack: [Route] = [.profile]
    var messagesStack: [Route] = [.messageList]
}

enum Route: Codable {
    case feedList
    case feedDetail(id: String)
    case profile
    case profileSettings
    case messageList
    case chat(id: String)
}

Как работает?

• Пользовательское действие (тап по табу, нажатие кнопки "назад") диспатчит intent (намерение) в store (хранилище).
• Store вычисляет новое состояние, включая обновленный NavigationState.
• Подписанные компоненты (например, Router или модифицированный UINavigationController) реагируют на изменения состояния и обновляют UI, выполняя необходимые push и pop операции.

Преимущество: Полная сериализация состояния в JSON и простое восстановление. Идеально для глубоких ссылок.

Подход 3: Использование SwiftUI (нативный с iOS 14+)

В SwiftUI навигация декларативна и тесно связана с данными.

struct ContentView: View {
    @State private var selectedTab = 0
    @StateObject private var feedNavigationState = NavigationPathHolder()
    @StateObject private var profileNavigationState = NavigationPathHolder()

    var body: some View {
        TabView(selection: $selectedTab) {
            NavigationStack(path: $feedNavigationState.path) {
                FeedView()
                    .navigationDestination(for: Route.self) { route in
                        // Определяем view для каждого route
                    }
            }
            .tabItem { Label("Лента", systemImage: "house") }
            .tag(0)

            NavigationStack(path: $profileNavigationState.path) {
                ProfileView()
                    .navigationDestination(for: Route.self) { route in
                        // ...
                    }
            }
            .tabItem { Label("Профиль", systemImage: "person") }
            .tag(1)
        }
        .onChange(of: selectedTab) { oldValue, newValue in
            // Можем сохранить индекс выбранной вкладки
            UserDefaults.standard.set(newValue, forKey: "selectedTab")
        }
    }
}

class NavigationPathHolder: ObservableObject {
    @Published var path = NavigationPath()
}

enum Route: Hashable, Codable {
    case feedDetail(id: String)
    case profileEdit
}

Ключевые моменты для SwiftUI:

• NavigationStack с привязкой к NavigationPath или массиву Hashable данных (например, enum Route) — это и есть хранилище пути.
• Каждая вкладка должна иметь свой собственный источник данных для пути (@State или @StateObject), чтобы стэки были изолированы.
• Сохранить и восстановить NavigationPath можно, используя его Codable представление (через json или подобное).

Рекомендации по выбору подхода

• Для простых приложений: Достаточно подхода 1 с сохранением индекса таба. Восстановление сложных стэков часто излишне.
• Для сложных приложений с глубокими ссылками и требованием к полному восстановлению состояния: Используйте State Container (подход 2) или SwiftUI NavigationStack (подход 3). Это наиболее надежные и масштабируемые методы.
• Для приложений со сложной бизнес-логикой навигации: Паттерн Координатор остается отличным выбором, особенно в комбинации с UIKit.

Главное — помнить, что хранение пути — это хранение состояния. Поэтому лучшие практики управления состоянием приложения напрямую влияют на то, как эффективно и надежно вы реализуете навигацию между вкладками.