ruby_everywhere 0.1.15 → 0.3.0

data/support/mobile/ios/App/SceneDelegate.swift

@@ -0,0 +1,484 @@
+import HotwireNative
+import UIKit
+import WebKit
+
+final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+    var window: UIWindow?
+
+    private let config = EverywhereConfig.shared
+
+    /// Fingerprint (title|path|icon per tab) of the tabs currently on screen,
+    /// so a path-config refresh only rebuilds when the tabs actually change.
+    /// Empty string = single-navigator mode.
+    private var loadedTabsFingerprint: String?
+
+    /// The current root — exactly one is non-nil, matching the fingerprint.
+    private var navigator: Navigator?
+    private var tabBarController: HotwireTabBarController?
+
+    /// Cold-launch splash, removed when the first request finishes. A whole
+    /// window (not a subview of the main one): launch swaps the main
+    /// window's rootViewController (single nav → tab bar), and window
+    /// subviews don't survive that swap — an overlay subview is gone before
+    /// the first frame ever reaches the screen.
+    private var splashWindow: UIWindow?
+    private var splashIsCustom = false
+
+    /// Custom splashes stay up at least config.splashMinimumDisplay. Against
+    /// a fast (local) server the first request finishes before the first
+    /// frame is even presented, and a branded splash that flashes for 50ms
+    /// reads as a glitch — while the default spinner vanishes instantly.
+    private var splashShownAt: Date = .distantPast
+    private var splashDismissScheduled = false
+
+    /// Last badge per tab path. Pages usually set badges from the first page
+    /// load — often before the auth-gated tab bar exists — so badges are
+    /// stored here and (re)applied whenever the tab bar is (re)built.
+    private var tabBadges: [String: String] = [:]
+
+    /// The path the shell treats as the "reset the app" signal.
+    private static let resetPath = "/everywhere/reset"
+
+    /// A universal link that arrived before the root existed (cold launch), held
+    /// until the first navigator/tab bar is built, then routed.
+    private var pendingUniversalLinkURL: URL?
+
+    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
+        guard let windowScene = scene as? UIWindowScene else { return }
+
+        let window = UIWindow(windowScene: windowScene)
+        if let tint = config.tint {
+            window.tintColor = tint
+        }
+        self.window = window
+
+        Hotwire.config.pathConfiguration.delegate = self
+
+        window.makeKeyAndVisible()
+        showSplash(in: windowScene)
+
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(reloadPathConfiguration),
+            name: .everywhereReloadConfig, object: nil)
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(handleReset(_:)),
+            name: .everywhereResetApp, object: nil)
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(handleTabBadge(_:)),
+            name: .everywhereSetTabBadge, object: nil)
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(handleSetInstance(_:)),
+            name: .everywhereSetInstance, object: nil)
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(handleClearInstance(_:)),
+            name: .everywhereClearInstance, object: nil)
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(handleNativeVisit(_:)),
+            name: .everywhereNativeVisit, object: nil)
+
+        // Cookie hydration BEFORE the first visit: after a force-kill relaunch
+        // (iOS kills the app when a Settings permission changes) the first
+        // request can beat the web view's cookie store loading from disk and
+        // render a signed-in user the login page. getAllCookies forces
+        // hydration — the splash covers the wait — and the same pass mirrors
+        // cookies for the auth-aware config fetch, which adds the tab bar for
+        // a signed-in user.
+        // A universal link that launched the app (cold start): capture it now,
+        // route it once the root exists (below).
+        captureUniversalLink(from: connectionOptions.userActivities)
+
+        syncWebViewCookiesToSharedStore { [weak self] in
+            guard let self else { return }
+            self.applyPathConfiguration()
+            self.routePendingUniversalLink()
+            Hotwire.loadPathConfiguration(from: EverywhereConfig.pathConfigurationSources(serverOnly: true))
+        }
+    }
+
+    // MARK: Universal links (deep linking)
+
+    /// A universal link tapped while the app is running: route it straight to
+    /// its in-app path. Links to other sites fall through to the system.
+    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
+        guard let url = webpageURL(from: userActivity) else { return }
+        activeNavigator.route(config.url(forPath: config.pathAndQuery(of: url)))
+    }
+
+    private func captureUniversalLink(from activities: Set<NSUserActivity>) {
+        guard let activity = activities.first(where: { $0.activityType == NSUserActivityTypeBrowsingWeb }),
+              let url = webpageURL(from: activity)
+        else { return }
+        pendingUniversalLinkURL = config.url(forPath: config.pathAndQuery(of: url))
+    }
+
+    /// The webpage URL of a browsing-web activity, but only if this app claims
+    /// its host (the associated domains) — never route someone else's link.
+    private func webpageURL(from userActivity: NSUserActivity) -> URL? {
+        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
+              let url = userActivity.webpageURL,
+              config.handlesUniversalLink(url)
+        else { return nil }
+        return url
+    }
+
+    private func routePendingUniversalLink() {
+        guard let url = pendingUniversalLinkURL else { return }
+        pendingUniversalLinkURL = nil
+        activeNavigator.route(url)
+    }
+
+    /// Refetch the server path configuration on every foreground — so a config
+    /// change lands without a relaunch (the dev endpoint is uncached). Uses the
+    /// server-only sources: the auth-aware source of truth, no baked flash.
+    func sceneWillEnterForeground(_ scene: UIScene) {
+        reloadPathConfiguration()
+    }
+
+    @objc private func reloadPathConfiguration() {
+        loadPathConfiguration(serverOnly: true)
+    }
+
+    /// Load the path configuration, first mirroring the web view's cookies into
+    /// the shared store. The config's tabs are auth-gated server-side, and the
+    /// framework fetches them with `URLSession.shared` (backed by
+    /// `HTTPCookieStorage.shared`) — a DIFFERENT cookie jar from the one the
+    /// web view uses for the session cookie. Without this mirror the config
+    /// request is unauthenticated, so a just-signed-in user gets no tabs.
+    private func loadPathConfiguration(serverOnly: Bool) {
+        syncWebViewCookiesToSharedStore {
+            Hotwire.loadPathConfiguration(from: EverywhereConfig.pathConfigurationSources(serverOnly: serverOnly))
+        }
+    }
+
+    private func syncWebViewCookiesToSharedStore(_ then: @escaping () -> Void) {
+        WKWebsiteDataStore.default().httpCookieStore.getAllCookies { cookies in
+            // True sync, not additive: a session cookie the web view no longer
+            // has (e.g. lost when iOS killed the app for a Settings permission
+            // change before the web view persisted it) must not linger here and
+            // keep authenticating the config fetch — that's how the app ends up
+            // signed out with a signed-in tab bar.
+            HTTPCookieStorage.shared.removeCookies(since: .distantPast)
+            for cookie in cookies {
+                HTTPCookieStorage.shared.setCookie(cookie)
+            }
+            then() // getAllCookies delivers its completion on the main queue
+        }
+    }
+
+    // MARK: Reset (auth changes)
+
+    /// Reset triggered by `Everywhere.resetApp()` from the page (the reset
+    /// page's fallback, or app code) — same effect as intercepting the URL.
+    @objc private func handleReset(_ note: Notification) {
+        let target = (note.userInfo?["to"] as? String).map { config.url(forPath: $0) } ?? config.startURL
+        resetApp(to: target)
+    }
+
+    /// Full app reset for an auth change. Deterministic and self-contained —
+    /// it does NOT depend on the reset page's JavaScript running:
+    ///   1. clear cached web content (no stale authed pages),
+    ///   2. drop to a single navigator on `target` immediately (a correct
+    ///      baseline for any auth state — no tab bar),
+    ///   3. refresh the auth-aware server config, which rebuilds the tab bar
+    ///      back in if (and only if) the user is now signed in.
+    private func resetApp(to target: URL) {
+        clearWebContentCache()
+        rebuildRoot(entries: [], routeTo: target)
+        loadedTabsFingerprint = "" // matches the empty tab set we just built
+        loadPathConfiguration(serverOnly: true)
+    }
+
+    // MARK: Native-code navigation
+
+    /// `everywhereVisit(path)` from extension code: route through the active
+    /// navigator, so the visit gets the full path-configuration treatment
+    /// (modals, native screens, reset interception) like any web-driven visit.
+    @objc private func handleNativeVisit(_ note: Notification) {
+        guard let path = note.userInfo?["path"] as? String else { return }
+        let url = path.hasPrefix("/") ? config.url(forPath: path) : URL(string: path)
+        guard let url else { return }
+        #if DEBUG
+        NSLog("everywhereVisit: %@", url.absoluteString)
+        #endif
+        activeNavigator.route(url)
+    }
+
+    // MARK: Instance switching (multi-instance apps)
+
+    /// `Everywhere.instance.set(url)`: persist the picked instance as the
+    /// app's root, then full-reset onto it. Ignored unless everywhere.yml
+    /// opts in (`remote.instances: true`) — for every other app, a page that
+    /// posts setInstance must not be able to re-root the shell. Persisting
+    /// happens BEFORE the reset target resolves: `config.url(forPath:)` must
+    /// build against the new root.
+    @objc private func handleSetInstance(_ note: Notification) {
+        guard config.remoteInstances == true,
+              let raw = note.userInfo?["url"] as? String,
+              let url = URL(string: raw),
+              EverywhereConfig.setInstanceURL(url)
+        else { return }
+
+        resetApp(to: resetTarget(fromPath: note.userInfo?["to"] as? String))
+    }
+
+    /// `Everywhere.instance.clear()`: drop the override and reset back into
+    /// the stamped root — the instance picker.
+    @objc private func handleClearInstance(_ note: Notification) {
+        guard config.remoteInstances == true else { return }
+        EverywhereConfig.setInstanceURL(nil)
+        resetApp(to: resetTarget(fromPath: note.userInfo?["to"] as? String))
+    }
+
+    private func resetTarget(fromPath path: String?) -> URL {
+        path.map { config.url(forPath: $0) } ?? config.startURL
+    }
+
+    /// The `to` path carried on a /everywhere/reset URL, resolved against the
+    /// app's root (falls back to the configured start URL).
+    private func resetTarget(from url: URL) -> URL {
+        let to = URLComponents(url: url, resolvingAgainstBaseURL: false)?
+            .queryItems?.first { $0.name == "to" }?.value
+        return to.map { config.url(forPath: $0) } ?? config.startURL
+    }
+
+    /// Drop cached responses and WKWebView content caches so a page isn't
+    /// served from its pre-auth state. Cookies are left intact — the server
+    /// has already invalidated the session on sign-out, and we must keep the
+    /// fresh cookie on sign-in.
+    private func clearWebContentCache() {
+        URLCache.shared.removeAllCachedResponses()
+        let types: Set<String> = [
+            WKWebsiteDataTypeDiskCache,
+            WKWebsiteDataTypeMemoryCache,
+            WKWebsiteDataTypeOfflineWebApplicationCache
+        ]
+        WKWebsiteDataStore.default().removeData(ofTypes: types, modifiedSince: .distantPast) {}
+    }
+
+    // MARK: Tabs / root
+
+    private func applyPathConfiguration() {
+        let entries = tabEntries
+        let fingerprint = entries
+            .map { "\($0.title)|\($0.path)|\($0.icon)" }
+            .joined(separator: "\n")
+
+        guard loadedTabsFingerprint != fingerprint else { return }
+        loadedTabsFingerprint = fingerprint
+        rebuildRoot(entries: entries, routeTo: nil)
+    }
+
+    private func rebuildRoot(entries: [TabEntry], routeTo: URL?) {
+        if entries.isEmpty {
+            let nav = makeNavigator()
+            navigator = nav
+            tabBarController = nil
+            window?.rootViewController = nav.rootViewController
+            if let routeTo {
+                nav.route(routeTo)
+            } else {
+                nav.start()
+            }
+        } else {
+            let controller = HotwireTabBarController(navigatorDelegate: self, lazyLoadTabs: config.lazyLoadsTabs)
+            tabBarController = controller
+            navigator = nil
+            window?.rootViewController = controller
+            controller.load(entries.map(hotwireTab(for:)))
+            if let routeTo {
+                controller.route(routeTo)
+            }
+            tabBadges.forEach { applyTabBadge(path: $0.key, value: $0.value) }
+        }
+    }
+
+    // MARK: Splash
+
+    /// Continues the static launch screen (same background) until the first
+    /// request finishes — no white flash while the first page loads over the
+    /// network. An app-provided splash (everywhere.yml native.ios.splash)
+    /// replaces the default spinner wholesale.
+    private func showSplash(in scene: UIWindowScene) {
+        let custom = EverywhereExtensions.splashViewController()
+        splashIsCustom = custom != nil
+
+        let overlay = UIWindow(windowScene: scene)
+        overlay.windowLevel = .normal + 1
+        overlay.rootViewController = custom ?? defaultSplashController()
+        overlay.isHidden = false
+        splashWindow = overlay
+        splashShownAt = Date()
+
+        // Safety net: never trap the user behind the splash.
+        DispatchQueue.main.asyncAfter(deadline: .now() + 8) { [weak self] in
+            self?.dismissSplash()
+        }
+    }
+
+    private func defaultSplashController() -> UIViewController {
+        let controller = UIViewController()
+        controller.view.backgroundColor = config.background ?? .systemBackground
+
+        let spinner = UIActivityIndicatorView(style: .medium)
+        spinner.translatesAutoresizingMaskIntoConstraints = false
+        spinner.startAnimating()
+        controller.view.addSubview(spinner)
+        NSLayoutConstraint.activate([
+            spinner.centerXAnchor.constraint(equalTo: controller.view.centerXAnchor),
+            spinner.centerYAnchor.constraint(equalTo: controller.view.centerYAnchor)
+        ])
+        return controller
+    }
+
+    private func dismissSplash() {
+        guard let overlay = splashWindow else { return }
+
+        if splashIsCustom {
+            let remaining = config.splashMinimumDisplay - Date().timeIntervalSince(splashShownAt)
+            if remaining > 0 {
+                guard !splashDismissScheduled else { return }
+                splashDismissScheduled = true
+                DispatchQueue.main.asyncAfter(deadline: .now() + remaining) { [weak self] in
+                    self?.splashDismissScheduled = false
+                    self?.dismissSplash()
+                }
+                return
+            }
+        }
+
+        splashWindow = nil
+        UIView.animate(withDuration: 0.25, animations: { overlay.alpha = 0 }) { _ in
+            overlay.isHidden = true
+        }
+    }
+
+    // MARK: Badges
+
+    @objc private func handleTabBadge(_ note: Notification) {
+        guard let path = note.userInfo?["path"] as? String,
+              let count = note.userInfo?["count"] as? Int
+        else { return }
+
+        if count > 0 {
+            tabBadges[path] = String(count)
+        } else {
+            tabBadges.removeValue(forKey: path)
+        }
+        applyTabBadge(path: path, value: count > 0 ? String(count) : nil)
+    }
+
+    private func applyTabBadge(path: String, value: String?) {
+        if #available(iOS 18.0, *), let tabBarController {
+            tabBarController.tabs.first { $0.identifier == path }?.badgeValue = value
+        } else if let viewControllers = tabBarController?.viewControllers,
+                  let index = tabEntries.firstIndex(where: { $0.path == path }),
+                  viewControllers.indices.contains(index) {
+            viewControllers[index].tabBarItem.badgeValue = value
+        }
+    }
+
+    private func makeNavigator() -> Navigator {
+        Navigator(
+            configuration: Navigator.Configuration(name: "main", startLocation: config.startURL),
+            delegate: self
+        )
+    }
+
+    private struct TabEntry {
+        let title: String
+        let path: String
+        let icon: String
+    }
+
+    /// `settings.tabs` from the merged path configuration. Icon names are SF
+    /// Symbols (everywhere.yml `tabs[].icons.ios`).
+    private var tabEntries: [TabEntry] {
+        guard let entries = Hotwire.config.pathConfiguration.settings["tabs"] as? [[String: AnyHashable]] else {
+            return []
+        }
+
+        return entries.compactMap { entry -> TabEntry? in
+            guard let title = entry["title"] as? String,
+                  let path = entry["path"] as? String
+            else { return nil }
+
+            return TabEntry(title: title, path: path, icon: entry["icon"] as? String ?? "circle")
+        }
+    }
+
+    private func hotwireTab(for entry: TabEntry) -> HotwireTab {
+        HotwireTab(
+            id: entry.path,
+            title: entry.title,
+            image: UIImage(systemName: entry.icon) ?? UIImage(systemName: "circle"),
+            url: config.url(forPath: entry.path)
+        )
+    }
+
+    /// The navigator currently on screen.
+    private var activeNavigator: Navigator {
+        if let tabBarController { return tabBarController.activeNavigator }
+        return navigator ?? makeNavigator()
+    }
+}
+
+// MARK: - PathConfigurationDelegate
+
+extension SceneDelegate: PathConfigurationDelegate {
+    func pathConfigurationDidUpdate() {
+        if Thread.isMainThread {
+            applyPathConfiguration()
+        } else {
+            DispatchQueue.main.async { self.applyPathConfiguration() }
+        }
+    }
+}
+
+// MARK: - NavigatorDelegate
+
+extension SceneDelegate: NavigatorDelegate {
+    func handle(proposal: VisitProposal, from navigator: Navigator) -> ProposalResult {
+        // Intercept the reset URL natively — the redirect after sign-in/out —
+        // so resetting never depends on the reset page's JavaScript running.
+        if proposal.url.path == Self.resetPath {
+            resetApp(to: resetTarget(from: proposal.url))
+            return .reject
+        }
+        // App-provided native screens: a path rule's `view_controller`
+        // identifier resolves through the extension registry (everywhere.yml
+        // native.ios.screens). Unknown identifiers fall through to the web.
+        if let identifier = proposal.properties["view_controller"] as? String,
+           let screen = EverywhereExtensions.screen(for: identifier, url: proposal.url) {
+            // A native screen IS first content: without this, an app whose
+            // entry path is native never finishes a request and the splash
+            // sits until its safety timeout.
+            dismissSplash()
+            return .acceptCustom(screen)
+        }
+        return .accept
+    }
+
+    func requestDidFinish(at url: URL) {
+        dismissSplash()
+    }
+
+    func visitableDidFailRequest(_ visitable: any Visitable, error: HotwireNativeError, retryHandler: RetryBlock?) {
+        dismissSplash()
+        switch error {
+        case .http(.client(.unauthorized)):
+            promptForAuthentication()
+        default:
+            presentError(error, retryHandler: retryHandler)
+        }
+    }
+
+    private func promptForAuthentication() {
+        activeNavigator.route(config.rootURL.appendingPathComponent("/session/new"))
+    }
+
+    private func presentError(_ error: HotwireNativeError, retryHandler: RetryBlock?) {
+        let errorViewController = ErrorViewController(error: error, retryHandler: retryHandler)
+        errorViewController.modalPresentationStyle = .fullScreen
+        activeNavigator.activeNavigationController.present(errorViewController, animated: true)
+    }
+}