@webspatial/platform-visionos 0.0.1

package/web-spatial/libs/Utils/Logger.swift

@@ -0,0 +1,36 @@
+//
+//  Logger.swift
+//  web-spatial
+//
+//  Created by ByteDance on 7/18/24.
+//
+
+import Foundation
+
+class Logger {
+    static func getLogger() -> Logger {
+        return Logger()
+    }
+
+    static func initLogger() {}
+
+    func error(_ str: String) {
+        print("error: " + str)
+    }
+
+    func verbose(_ str: String) {
+        print("verbose: " + str)
+    }
+
+    func debug(_ str: String) {
+        print("debug: " + str)
+    }
+
+    func info(_ str: String) {
+        print("info: " + str)
+    }
+
+    func warning(_ str: String) {
+        print("warning: " + str)
+    }
+}

package/web-spatial/libs/Utils/SceneManager.swift

@@ -0,0 +1,108 @@
+//
+//  SceneManager.swift
+//  web-spatial
+//
+//  Created by ByteDance on 2025/2/6.
+//
+
+import Foundation
+
+class SceneManager {
+    static let Instance = SceneManager()
+
+    private init() {}
+
+    // create scene
+    // if config is provided, it show immediately
+    // else it won't show until showRoot is called
+    func createRoot(target: SpatialWindowComponent, windowID: String, config: WindowContainerOptions? = nil) {
+        let windowContainerID = UUID().uuidString
+        // open window
+        let wgd = WindowContainerData(
+            windowStyle: "Plain",
+            windowContainerID: windowContainerID
+        )
+        let ent = SpatialEntity()
+        ent.coordinateSpace = CoordinateSpaceMode.ROOT
+        let windowComponent = SpatialWindowComponent(
+            parentWindowContainerID: windowContainerID
+        )
+
+        if let spawnedWebView = target.spawnedNativeWebviews.removeValue(forKey: windowID) {
+            windowComponent.getView()!.destroy()
+            windowComponent.setView(wv: spawnedWebView)
+            windowComponent.getView()!.webViewHolder.webViewCoordinator!.webViewRef = windowComponent
+            // focusRoot need the windowContainerID
+            windowComponent.evaluateJS(js: "window._webSpatialGroupID='\(windowContainerID)';")
+            // tell new webview parentWindowContainerID to open loadingview
+            windowComponent.evaluateJS(js: "window._webSpatialParentGroupID='\(target.parentWindowContainerID)';")
+
+            if config != nil {
+                // signal off hook
+                windowComponent.evaluateJS(js: "window._SceneHookOff=true;")
+            }
+        } else {
+            logger.warning("Unable to find spawned webview")
+        }
+
+        ent.addComponent(windowComponent)
+
+        let wg = SpatialWindowContainer.getOrCreateSpatialWindowContainer(windowContainerID, wgd)
+        ent.setParentWindowContainer(wg: wg)
+
+        if let config = config {
+            showRoot(
+                target: windowComponent,
+                config: config,
+                parentWindowContainerID: target.parentWindowContainerID
+            )
+        }
+    }
+
+    // set defaultvalues for the scene and show it
+    func showRoot(target: SpatialWindowComponent, config: WindowContainerOptions, parentWindowContainerID: String) {
+        let plainDV = WindowContainerPlainDefaultValues(
+            config
+        )
+
+        if let pwg = SpatialWindowContainer.getSpatialWindowContainer(parentWindowContainerID),
+           let wg = SpatialWindowContainer.getSpatialWindowContainer(
+               target.parentWindowContainerID
+           )
+        {
+            WindowContainerMgr.Instance
+                .updateWindowContainerPlainDefaultValues(
+                    plainDV
+                ) // set default values
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                pwg.openWindowData.send(wg.wgd) // openwindow
+            }
+        }
+    }
+
+    // bring the scene to focus
+    func focusRoot(target: SpatialWindowComponent, windowContainerID: String) {
+        if let wg = SpatialWindowContainer.getSpatialWindowContainer(windowContainerID) {
+            wg.openWindowData.send(wg.wgd)
+        }
+    }
+
+    // show LodingView when window.xrCurrentSceneDefaults is executing
+    func setLoading(_ method: LoadingMethod, windowContainerID: String) {
+        // trigger open loading view by parent windowContainer due to current windowContainer isn't visible yet
+        if let wg = SpatialWindowContainer.getSpatialWindowContainer(windowContainerID) {
+            let lwgdata = LoadingWindowContainerData(
+                method: method,
+                windowStyle: nil
+            )
+            wg.setLoadingWindowData.send(lwgdata)
+        }
+    }
+
+    // dismiss the scene content when webview closed
+    func closeRoot(_ target: SpatialWindowComponent) {
+        if let wg = SpatialWindowContainer.getSpatialWindowContainer(target.parentWindowContainerID) {
+            wg.closeWindowData.send(wg.wgd)
+        }
+    }
+}

package/web-spatial/libs/Utils/WindowContainerMgr.swift

@@ -0,0 +1,117 @@
+//
+//  WindowContainerMgr.swift
+//  web-spatial
+//
+//  Created by ByteDance on 2024/12/13.
+//
+
+//
+//  WindowContainerModel.swift
+//  web-spatial
+//
+//  Created by ByteDance on 2024/11/25.
+//
+
+import Combine
+import SwiftUI
+import UIKit
+
+// TODO: maybe get input from pwa manifest
+let defaultWindowContainerConfig = WindowContainerOptions(
+    defaultSize: WindowContainerOptions.Size(
+        width: DefaultPlainWindowContainerSize.width,
+        height: DefaultPlainWindowContainerSize.height
+    ),
+    resizability: nil
+)
+
+struct WindowContainerData: Decodable, Hashable, Encodable {
+    let windowStyle: String
+    let windowContainerID: String
+}
+
+enum LoadingMethod: String, Decodable, Encodable, Hashable {
+    case show
+    case hide
+}
+
+struct LoadingWindowContainerData: Decodable, Hashable, Encodable {
+    let method: LoadingMethod
+    let windowStyle: String?
+}
+
+struct WindowContainerPlainDefaultValues {
+    var defaultSize: CGSize?
+    var windowResizability: WindowResizability?
+}
+
+// support WindowContainerOptions => WindowContainerPlainDefaultValues
+extension WindowContainerPlainDefaultValues {
+    init(_ options: WindowContainerOptions) {
+        defaultSize = CGSize(
+            width: options.defaultSize?.width ?? DefaultPlainWindowContainerSize.width,
+            height: options.defaultSize?.height ?? DefaultPlainWindowContainerSize.height
+        )
+        windowResizability = getWindowResizability(options.resizability)
+    }
+}
+
+// incomming JSB data
+struct WindowContainerOptions: Codable {
+    // windowContainer
+    let defaultSize: Size?
+    let resizability: String?
+    struct Size: Codable {
+        var width: Double
+        var height: Double
+    }
+}
+
+func getWindowResizability(_ windowResizability: String?) -> WindowResizability {
+    switch windowResizability {
+    case "automatic":
+        return .automatic
+    case "contentSize":
+        return .contentSize
+    case "contentMinSize":
+        return .contentMinSize
+    default:
+        return .automatic
+    }
+}
+
+@Observable
+class WindowContainerMgr: ObservableObject {
+    static let Instance = WindowContainerMgr()
+
+    // cache for dynamic loading scene reopen
+    var memorizedMainSceneConfig: WindowContainerPlainDefaultValues? = nil
+
+    private init() {
+        setToMainSceneCfg()
+    }
+
+    private var wgSetting: WindowContainerPlainDefaultValues = .init(
+        defaultSize: CGSize(width: 1080, height: 720),
+        windowResizability: .automatic
+    )
+
+    func getValue() -> WindowContainerPlainDefaultValues {
+        return wgSetting
+    }
+
+    func setToMainSceneCfg() {
+        if let cfg = memorizedMainSceneConfig != nil ? memorizedMainSceneConfig : WindowContainerPlainDefaultValues(pwaManager.mainScene) {
+            updateWindowContainerPlainDefaultValues(cfg)
+        }
+    }
+
+    func updateWindowContainerPlainDefaultValues(_ data: WindowContainerPlainDefaultValues) {
+        if let newSize = data.defaultSize {
+            wgSetting.defaultSize = newSize
+        }
+        if let newResizability = data.windowResizability {
+            wgSetting.windowResizability = newResizability
+        }
+    }
+}

package/web-spatial/libs/json/JsonParser.swift

@@ -0,0 +1,52 @@
+//
+//  JsonParser.swift
+//  web-spatial
+//
+//  Created by ByteDance on 5/9/24.
+//
+
+import Foundation
+
+class JsonParser {
+    var json: [String: AnyObject]?
+    init(str: String?) {
+        if let toParse = str {
+            if let data = toParse.data(using: .utf8) {
+                do {
+                    json = try JSONSerialization.jsonObject(with: data, options: .mutableContainers) as? [String: AnyObject]
+                } catch {}
+            }
+        }
+    }
+
+    func getValue<T>(lookup: [String]) -> T? {
+        if var anyObj = json as? AnyObject {
+            for (index, str) in lookup.enumerated() {
+                if index == lookup.count - 1 {
+                    return anyObj[str] as? T
+                }
+                if let o = (anyObj as? [String: AnyObject]),
+                   let x = o[str]
+                {
+                    anyObj = x
+                } else {
+                    return nil
+                }
+            }
+        }
+        return nil
+    }
+
+    // Convert the instance to a JSON string
+    static func serialize<T: Encodable>(_ data: T) -> String? {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = .prettyPrinted // Makes the JSON output more readable
+        do {
+            let jsonData = try encoder.encode(data)
+            return String(data: jsonData, encoding: .utf8) // Convert Data to String
+        } catch {
+            logger.error("Failed to encode WindowContainerOptions to JSON: \(error)")
+            return nil
+        }
+    }
+}

package/web-spatial/libs/uiKitDelegate/Window.swift

@@ -0,0 +1,34 @@
+//
+//  Window.swift
+//  web-spatial
+//
+//  Created by ByteDance on 7/3/24.
+//
+
+import Foundation
+import SwiftUI
+
+// Access window (https://stackoverflow.com/questions/60359808/how-to-access-own-window-within-swiftui-view/60359809#60359809)
+class SceneDelegate: NSObject, ObservableObject, UIWindowSceneDelegate {
+    var window: UIWindow? // << contract of `UIWindowSceneDelegate`
+
+    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
+        guard let windowScene = scene as? UIWindowScene else { return }
+        window = windowScene.keyWindow // << store !!!
+    }
+
+    // do memory cleanup after scene removed, otherwise windowContainer cannot destroy content after being dismissed
+    func sceneDidDisconnect(_ scene: UIScene) {
+        window = nil
+    }
+}
+
+class AppDelegate: NSObject, UIApplicationDelegate {
+    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+        let configuration = UISceneConfiguration(name: nil, sessionRole: connectingSceneSession.role)
+        if connectingSceneSession.role == .windowApplication {
+            configuration.delegateClass = SceneDelegate.self
+        }
+        return configuration
+    }
+}

package/web-spatial/libs/webView/UpdateSystem.swift

@@ -0,0 +1,33 @@
+//
+//  UpdateSystem.swift
+//  web-spatial
+//
+//  Created by ByteDance on 5/21/24.
+//
+
+import Foundation
+import RealityKit
+
+struct UpdateWebViewComponent: Component {
+    var webView: SpatialWindowComponent?
+    init() {}
+}
+
+class UpdateWebViewSystem: System {
+    static let query = EntityQuery(where: .has(UpdateWebViewComponent.self))
+    required init(scene: RealityKit.Scene) {
+        // Perform required initialization or setup.
+    }
+
+    var pos = 0.0
+    func update(context: SceneUpdateContext) {
+        for entity in context.entities(matching: Self.query, updatingSystemWhen: .rendering) {
+            pos += context.deltaTime
+
+            var x = Transform()
+            x.translation.x = Float(sin(pos)) * 0.3
+            x.translation.z = 0.2
+            entity.move(to: x, relativeTo: nil)
+        }
+    }
+}