@nebula-rn/host 0.0.1

package/ios/Nebula/NebulaContainerController.swift

@@ -0,0 +1,580 @@
+//
+//  NebulaContainerController.swift
+//  SuperApp - Nebula Mini-App Container
+//
+//  Container view controller for displaying mini-app instances
+//
+
+import UIKit
+import React
+import React_RCTAppDelegate
+
+private let nebulaLoadingExitAnimationDuration: TimeInterval = 0.24
+var miniappLoadingDelay: TimeInterval = 0
+
+@objc public final class NebulaContainerController: UIViewController, UIGestureRecognizerDelegate {
+    
+    // MARK: - Properties
+    
+    let appId: String
+    public let instanceId: String
+    private var initialProps: [AnyHashable: Any]?
+    private let shouldDelayContentEntrance: Bool
+    private let installedAppSignature: String?
+    private var miniAppFactory: RCTReactNativeFactory?
+    private var pageStyle: [String: Any] = [:]
+    private var backgroundEffectView: UIView?
+    private weak var rootContentView: UIView?
+    private weak var miniappLoadingView: UIView?
+    private var rootContentConstraints: [NSLayoutConstraint] = []
+    private var willResignActiveObserver: NSObjectProtocol?
+    private var didBecomeActiveObserver: NSObjectProtocol?
+    private var contentDidAppearObserver: NSObjectProtocol?
+    private var hasDismissedLoadingOverlay = false
+    private var minimumLoadingDismissDate: Date?
+    
+    private let loadingIndicator: UIActivityIndicatorView = {
+        let indicator = UIActivityIndicatorView(style: .large)
+        indicator.translatesAutoresizingMaskIntoConstraints = false
+        indicator.hidesWhenStopped = true
+        return indicator
+    }()
+
+    // MARK: - Initialization
+    
+    @objc public init(appId: String, initialProps: [AnyHashable: Any]? = nil) {
+        self.appId = appId
+        self.instanceId = UUID().uuidString
+        self.initialProps = initialProps
+        self.shouldDelayContentEntrance = false
+        self.installedAppSignature = NebulaHost.shared.installedAppRuntimeSignature(appId)
+        super.init(nibName: nil, bundle: nil)
+        self.title = appId
+        if let pageStyle = initialProps?["__pageConfig"] as? [String: Any] {
+            self.pageStyle = pageStyle
+        }
+        
+        // Store reference to allow JS-side navigation using unique instanceId
+        NebulaRouter.shared.registerContainer(self, instanceId: instanceId, appId: appId)
+    }
+
+    @objc public init(appId: String,
+                      initialProps: [AnyHashable: Any]? = nil,
+                      delayContentEntrance: Bool) {
+        self.appId = appId
+        self.instanceId = UUID().uuidString
+        self.initialProps = initialProps
+        self.shouldDelayContentEntrance = delayContentEntrance
+        self.installedAppSignature = NebulaHost.shared.installedAppRuntimeSignature(appId)
+        super.init(nibName: nil, bundle: nil)
+        self.title = appId
+        if let pageStyle = initialProps?["__pageConfig"] as? [String: Any] {
+            self.pageStyle = pageStyle
+        }
+        
+        // Store reference to allow JS-side navigation using unique instanceId
+        NebulaRouter.shared.registerContainer(self, instanceId: instanceId, appId: appId)
+    }
+    
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    deinit {
+        dismissLoading()
+        NotificationCenter.default.post(
+            name: NSNotification.Name("NebulaContainerDidUnload"),
+            object: nil,
+            userInfo: [
+                "appId": appId,
+                "instanceId": instanceId,
+                "routePath": initialProps?["__routePath"] as? String ?? "/"
+            ]
+        )
+        if let observer = willResignActiveObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
+        if let observer = didBecomeActiveObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
+        if let observer = contentDidAppearObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
+        NebulaRouter.shared.unregisterContainer(for: instanceId)
+        NebulaAppManager.shared.releaseConsumedResources(appId: appId)
+        print("[Nebula] Container deallocated for \(appId) (instance: \(instanceId))")
+    }
+    
+    // MARK: - Lifecycle
+    
+    public override func viewDidLoad() {
+        super.viewDidLoad()
+        
+        applyBaseBackgroundColor()
+        applyPageStyle()
+        registerAppStateObservers()
+        
+        // Setup loading indicator
+        view.addSubview(loadingIndicator)
+        NSLayoutConstraint.activate([
+            loadingIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            loadingIndicator.centerYAnchor.constraint(equalTo: view.centerYAnchor)
+        ])
+        loadingIndicator.startAnimating()
+        setupRootView()
+    }
+    
+    public override func viewWillAppear(_ animated: Bool) {
+        super.viewWillAppear(animated)
+        applyPageStyle()
+        if let navigationController {
+            navigationController.interactivePopGestureRecognizer?.delegate = self
+            navigationController.interactivePopGestureRecognizer?.isEnabled =
+                navigationController.viewControllers.count > 1
+        }
+        
+        // Notify JS about lifecycle
+        NotificationCenter.default.post(
+            name: NSNotification.Name("NebulaContainerWillAppear"),
+            object: nil,
+            userInfo: [
+                "appId": appId,
+                "instanceId": instanceId,
+                "routePath": initialProps?["__routePath"] as? String ?? "/"
+            ]
+        )
+    }
+    
+    public override func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        
+        // Notify JS about lifecycle
+        NotificationCenter.default.post(
+            name: NSNotification.Name("NebulaContainerDidDisappear"),
+            object: nil,
+            userInfo: [
+                "appId": appId,
+                "instanceId": instanceId,
+                "routePath": initialProps?["__routePath"] as? String ?? "/"
+            ]
+        )
+    }
+    
+    // MARK: - Public Methods
+    
+    /// Update initial props for container reuse
+    @objc public func updateInitialProps(_ props: [AnyHashable: Any]) {
+        self.initialProps = props
+        if let pageStyle = props["__pageConfig"] as? [String: Any] {
+            self.pageStyle = pageStyle
+        } else if let routePath = props["__routePath"] as? String,
+                  let manifestPageStyle = NebulaManifestManager.shared.getPageConfig(forAppId: appId, path: routePath) as? [String: Any] {
+            self.pageStyle = manifestPageStyle
+        }
+        applyPageStyle()
+        print("[Nebula] Updated initialProps for container \(appId) (instance: \(instanceId))")
+        // Note: Existing RootView will not be recreated. 
+        // For full props update, consider implementing JS-side prop refresh mechanism.
+    }
+
+    @objc public func updatePageStyle(_ nextStyle: [String: Any]) {
+        self.pageStyle.merge(nextStyle) { _, new in new }
+        if let title = nextStyle["navigationBarTitleText"] as? String {
+            self.title = title
+        }
+        applyPageStyle()
+    }
+
+    @objc public func matchesInstalledRuntimeSignature(_ signature: String?) -> Bool {
+        return installedAppSignature == signature
+    }
+
+    func prepareForPresentation() -> Bool {
+        loadViewIfNeeded()
+        return shouldDelayContentEntrance && miniappLoadingView != nil
+    }
+
+    func shouldAttachMiniappLoadingView() -> Bool {
+        return shouldDelayContentEntrance && !isViewLoaded
+    }
+
+    func attachMiniappLoadingView(_ loadingView: UIView, minimumDismissDelay: TimeInterval) {
+        miniappLoadingView?.removeFromSuperview()
+        hasDismissedLoadingOverlay = false
+        minimumLoadingDismissDate = Date().addingTimeInterval(minimumDismissDelay)
+        miniappLoadingView = loadingView
+    }
+
+    @objc public func dismissLoading() {
+        hasDismissedLoadingOverlay = true
+        minimumLoadingDismissDate = nil
+        miniappLoadingView?.removeFromSuperview()
+        miniappLoadingView = nil
+        loadingIndicator.stopAnimating()
+        loadingIndicator.removeFromSuperview()
+        if let observer = contentDidAppearObserver {
+            NotificationCenter.default.removeObserver(observer)
+            contentDidAppearObserver = nil
+        }
+    }
+
+    // MARK: - Private Methods
+    
+    private func setupRootView() {
+
+        // Clean old root content before attaching a new mini-app view.
+        for subview in view.subviews where subview != loadingIndicator && subview != miniappLoadingView {
+            subview.removeFromSuperview()
+        }
+        
+        if let preloadedRootView = NebulaAppManager.shared.consumePreloadedRootView(for: appId) {
+            view.addSubview(preloadedRootView)
+            attachRootContentView(preloadedRootView)
+            view.bringSubviewToFront(preloadedRootView)
+            bringMiniappLoadingViewToFrontIfNeeded()
+            handleMiniappContentReady()
+            loadingIndicator.stopAnimating()
+            loadingIndicator.removeFromSuperview()
+            print("[Nebula] Debug z-order(preloaded): subviews=\(view.subviews.count), top=\(String(describing: view.subviews.last))")
+            print("[Nebula] Consumed preloaded root view for \(appId)")
+            return
+        }
+
+        let bundleURL: URL
+        if let devURL = NebulaConfig.shared.devURL(for: appId) {
+            bundleURL = devURL
+            print("[Nebula] Using development URL for hot reload: \(devURL)")
+        } else if let bundlePath = NebulaConfig.shared.bundlePath(for: appId) {
+            bundleURL = URL(fileURLWithPath: bundlePath)
+            print("[Nebula] Using local bundle: \(bundlePath)")
+        } else {
+            showError(NSError(
+                domain: "com.nebula.container",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Bundle not found for appId: \(appId)"]
+            ))
+            return
+        }
+
+        let miniFactory = NebulaAppManager.shared.acquireFactory(
+            for: appId,
+            bundleURL: bundleURL
+        )
+        self.miniAppFactory = miniFactory
+
+        let routePath = (initialProps?["__routePath"] as? String)
+            ?? (NebulaManifestManager.shared.getEntryPagePath(forAppId: appId) ?? "/")
+        guard let moduleName = NebulaManifestManager.shared.getComponentName(forAppId: appId, path: routePath) else {
+            return
+        }
+
+        let rootView = miniFactory.rootViewFactory.view(
+            withModuleName: moduleName,
+            initialProperties: buildInitialProps()
+        )
+        registerContentDidAppearObserver(for: rootView)
+
+        rootView.backgroundColor = resolvedPageBackgroundColor()
+        
+        // Debug: force mini-app content on top to rule out z-order issues.
+        view.addSubview(rootView)
+        attachRootContentView(rootView)
+        view.bringSubviewToFront(rootView)
+        bringMiniappLoadingViewToFrontIfNeeded()
+        
+        // Hide loading indicator
+        loadingIndicator.stopAnimating()
+        loadingIndicator.removeFromSuperview()
+
+        print("[Nebula] Debug z-order(new): subviews=\(view.subviews.count), top=\(String(describing: view.subviews.last))")
+
+        // Some RN loading overlays can persist in mixed lifecycle paths; clean once after mount.
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.35) { [weak self, weak rootView] in
+            guard let self = self, let rootView = rootView else { return }
+            self.removeInternalLoadingViews(from: rootView)
+        }
+        
+        print("[Nebula] Container loaded for \(appId), module=\(moduleName)")
+    }
+
+    private func registerContentDidAppearObserver(for rootView: UIView) {
+        if let observer = contentDidAppearObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
+
+        contentDidAppearObserver = NotificationCenter.default.addObserver(
+            forName: NSNotification.Name(rawValue: "RCTContentDidAppearNotification"),
+            object: nil,
+            queue: .main
+        ) { [weak self, weak rootView] notification in
+            guard let self,
+                  let rootView,
+                  let contentView = notification.object as? UIView else {
+                return
+            }
+
+            if contentView === rootView || contentView.isDescendant(of: rootView) {
+                self.handleMiniappContentReady()
+            }
+        }
+    }
+
+    private func handleMiniappContentReady() {
+        guard !hasDismissedLoadingOverlay else {
+            return
+        }
+        hasDismissedLoadingOverlay = true
+        NotificationCenter.default.post(
+            name: NSNotification.Name("NebulaContainerDidBecomeReady"),
+            object: nil,
+            userInfo: [
+                "appId": appId,
+                "instanceId": instanceId,
+                "routePath": initialProps?["__routePath"] as? String ?? "/"
+            ]
+        )
+        dismissLoadingOverlayIfNeeded()
+    }
+
+    private func dismissLoadingOverlayIfNeeded() {
+        let remainingEntranceDelay = max(0, minimumLoadingDismissDate?.timeIntervalSinceNow ?? 0)
+        let totalDelay = remainingEntranceDelay + miniappLoadingDelay + nebulaLoadingExitAnimationDuration
+        DispatchQueue.main.asyncAfter(deadline: .now() + totalDelay) {
+            self.dismissLoading()
+        }
+    }
+
+    private func bringMiniappLoadingViewToFrontIfNeeded() {
+        guard let loadingView = miniappLoadingView else { return }
+        loadingView.superview?.bringSubviewToFront(loadingView)
+    }
+
+    private func removeInternalLoadingViews(from view: UIView) {
+        for subview in view.subviews {
+            let className = String(describing: type(of: subview))
+            if subview is UIActivityIndicatorView || className.contains("Loading") || className.contains("RCT") && className.contains("Progress") {
+                subview.removeFromSuperview()
+                continue
+            }
+            removeInternalLoadingViews(from: subview)
+        }
+    }
+    
+    private func buildInitialProps() -> [AnyHashable: Any] {
+        var props: [AnyHashable: Any] = [
+            "appId": appId,
+            "instanceId": instanceId,
+            "sandboxPath": getSandboxPath()
+        ]
+
+        // Merge caller-provided props first so route/page config resolution uses the actual target page.
+        if let initialProps = initialProps {
+            props.merge(initialProps) { _, new in new }
+        }
+
+        if props["__routePath"] == nil {
+            let entryPath = NebulaManifestManager.shared.getEntryPagePath(forAppId: appId) ?? "/"
+            props["__routePath"] = entryPath
+        }
+        if let providedPageStyle = props["__pageConfig"] as? [String: Any] {
+            pageStyle = providedPageStyle
+        } else if let routePath = props["__routePath"] as? String,
+                  let manifestPageStyle = NebulaManifestManager.shared.getPageConfig(forAppId: appId, path: routePath) as? [String: Any] {
+            pageStyle = manifestPageStyle
+        }
+        if !pageStyle.isEmpty {
+            props["__pageConfig"] = pageStyle
+        }
+
+        return props
+    }
+    
+    private func getSandboxPath() -> String {
+        return NebulaConfig.shared.sandboxPath(for: appId)
+    }
+
+    private func applyPageStyle() {
+        applyBaseBackgroundColor()
+        rootContentView?.backgroundColor = resolvedPageBackgroundColor()
+
+        navigationItem.hidesBackButton = shouldHideBackButton()
+
+        if let title = pageStyle["navigationBarTitleText"] as? String, !title.isEmpty {
+            self.title = title
+        }
+
+        let navigationStyle = (pageStyle["navigationStyle"] as? String)?.lowercased() ?? "default"
+        updateLayoutForNavigationStyle(navigationStyle)
+
+        guard let navigationController else { return }
+        navigationController.setNavigationBarHidden(navigationStyle == "custom", animated: false)
+
+        let appearance = UINavigationBarAppearance()
+        appearance.configureWithOpaqueBackground()
+
+        if let backgroundColorHex = pageStyle["navigationBarBackgroundColor"] as? String,
+           let color = UIColor(nebulaHex: backgroundColorHex) {
+            appearance.backgroundColor = color
+        } else {
+            appearance.backgroundColor = .systemBackground
+        }
+
+        let textColor = UIColor(nebulaHex: pageStyle["navigationBarTextColor"] as? String ?? "") ?? .label
+        appearance.titleTextAttributes = [.foregroundColor: textColor]
+        appearance.largeTitleTextAttributes = [.foregroundColor: textColor]
+
+        navigationController.navigationBar.tintColor = textColor
+        navigationController.navigationBar.standardAppearance = appearance
+        navigationController.navigationBar.scrollEdgeAppearance = appearance
+        navigationController.navigationBar.compactAppearance = appearance
+    }
+
+    private func shouldHideBackButton() -> Bool {
+        let currentRoute = normalizeRoute(
+            (initialProps?["__routePath"] as? String)
+                ?? (pageStyle["route"] as? String)
+        )
+        let entryRoute = normalizeRoute(
+            NebulaManifestManager.shared.getEntryPagePath(forAppId: appId)
+        )
+        return currentRoute == "/" || currentRoute == entryRoute
+    }
+
+    private func normalizeRoute(_ routePath: String?) -> String {
+        let raw = routePath?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        if raw.isEmpty {
+            return "/"
+        }
+        return raw.hasPrefix("/") ? raw : "/\(raw)"
+    }
+
+    public func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
+        guard gestureRecognizer === navigationController?.interactivePopGestureRecognizer else {
+            return true
+        }
+        return (navigationController?.viewControllers.count ?? 0) > 1
+    }
+
+    private func registerAppStateObservers() {
+        willResignActiveObserver = NotificationCenter.default.addObserver(
+            forName: UIApplication.willResignActiveNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.applyBackgroundVisualEffectIfNeeded()
+        }
+
+        didBecomeActiveObserver = NotificationCenter.default.addObserver(
+            forName: UIApplication.didBecomeActiveNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.removeBackgroundVisualEffect()
+        }
+    }
+
+    private func applyBackgroundVisualEffectIfNeeded() {
+        let visualEffect = (pageStyle["visualEffectInBackground"] as? String)?.lowercased() ?? "none"
+        guard visualEffect == "blur", backgroundEffectView == nil else { return }
+
+        let blurView = UIVisualEffectView(effect: UIBlurEffect(style: .systemChromeMaterial))
+        blurView.frame = view.bounds
+        blurView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        blurView.isUserInteractionEnabled = false
+        blurView.backgroundColor = resolvedPageBackgroundColor().withAlphaComponent(0.15)
+        view.addSubview(blurView)
+        view.bringSubviewToFront(blurView)
+        backgroundEffectView = blurView
+    }
+
+    private func removeBackgroundVisualEffect() {
+        backgroundEffectView?.removeFromSuperview()
+        backgroundEffectView = nil
+    }
+
+    private func applyBaseBackgroundColor() {
+        view.backgroundColor = resolvedPageBackgroundColor()
+    }
+
+    private func attachRootContentView(_ rootView: UIView) {
+        rootView.translatesAutoresizingMaskIntoConstraints = false
+        rootContentView = rootView
+        updateLayoutForNavigationStyle(
+            (pageStyle["navigationStyle"] as? String)?.lowercased() ?? "default"
+        )
+    }
+
+    private func updateLayoutForNavigationStyle(_ navigationStyle: String) {
+        let usesDefaultNavigationBar = navigationStyle != "custom"
+
+        if usesDefaultNavigationBar {
+            edgesForExtendedLayout = []
+            extendedLayoutIncludesOpaqueBars = false
+        } else {
+            edgesForExtendedLayout = [.top, .left, .bottom, .right]
+            extendedLayoutIncludesOpaqueBars = true
+        }
+
+        guard let rootContentView, rootContentView.superview === view else { return }
+
+        NSLayoutConstraint.deactivate(rootContentConstraints)
+        let topAnchor = usesDefaultNavigationBar ? view.safeAreaLayoutGuide.topAnchor : view.topAnchor
+        rootContentConstraints = [
+            rootContentView.topAnchor.constraint(equalTo: topAnchor),
+            rootContentView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            rootContentView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            rootContentView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
+        ]
+        NSLayoutConstraint.activate(rootContentConstraints)
+        view.layoutIfNeeded()
+    }
+
+    private func resolvedPageBackgroundColor() -> UIColor {
+        if let backgroundColorHex = pageStyle["backgroundColor"] as? String,
+           let color = UIColor(nebulaHex: backgroundColorHex) {
+            return color
+        }
+        return .systemBackground
+    }
+    
+    private func showError(_ error: Error) {
+        loadingIndicator.stopAnimating()
+        
+        let label = UILabel()
+        label.text = "Load failed\n\(error.localizedDescription)"
+        label.textAlignment = .center
+        label.numberOfLines = 0
+        label.textColor = .systemRed
+        label.translatesAutoresizingMaskIntoConstraints = false
+        
+        view.addSubview(label)
+        NSLayoutConstraint.activate([
+            label.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            label.centerYAnchor.constraint(equalTo: view.centerYAnchor),
+            label.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),
+            label.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -20)
+        ])
+        
+        print("[Nebula] Error: \(error.localizedDescription)")
+    }
+}
+
+private extension UIColor {
+    convenience init?(nebulaHex: String) {
+        let sanitized = nebulaHex
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .replacingOccurrences(of: "#", with: "")
+
+        guard sanitized.count == 6,
+              let value = Int(sanitized, radix: 16) else {
+            return nil
+        }
+
+        self.init(
+            red: CGFloat((value >> 16) & 0xFF) / 255.0,
+            green: CGFloat((value >> 8) & 0xFF) / 255.0,
+            blue: CGFloat(value & 0xFF) / 255.0,
+            alpha: 1.0
+        )
+    }
+}