refactor(apple): load render context async (#11810) b311089408

Co-authored-by: David Skuza <david@rive.app>

Author: dskuza

.rive_head

@@ -1 +1 @@
-dd441653dfa8ac2cf63eeaf68d5a047bc0fbed67
+b311089408d38ffe9a176298f962266c334a02e0

Example-iOS/Source/Examples/Experimental/SharedWorkerView.swift

@@ -0,0 +1,44 @@
+//
+//  SharedWorkerView.swift
+//  RiveExample
+//
+//  Created by David Skuza on 3/4/26.
+//  Copyright © 2026 Rive. All rights reserved.
+//
+
+import SwiftUI
+@_spi(RiveExperimental) import RiveRuntime
+
+actor WorkerCache {
+    static let shared = WorkerCache()
+
+    @MainActor
+    private var cachedWorker: Worker?
+
+    @MainActor
+    func worker() async throws -> Worker {
+        if let cachedWorker {
+            return cachedWorker
+        }
+
+        let worker = try await Worker()
+        cachedWorker = worker
+        return worker
+    }
+}
+
+struct SharedWorkerView: View {
+    var body: some View {
+        ScrollView {
+            ForEach(0..<4) { _ in
+                AsyncRiveUIViewRepresentable {
+                    let worker = try await WorkerCache.shared.worker()
+                    let file = try await File(source: .local("marty_v2", .main), worker: worker)
+                    return try await Rive(file: file)
+                }
+                .frame(maxWidth: .infinity)
+                .frame(height: 240)
+            }
+        }
+    }
+}

Example-iOS/Source/ExamplesMaster.swift

@@ -63,7 +63,8 @@ class ExamplesMasterTableViewController: UITableViewController {
     private let experimental: [(String, AnyView)] = [
         ("Simple - Marty", AnyView(MartyView())),
         ("Quick Start - Data Binding", AnyView(QuickStartView())),
-        ("Animation Player", AnyView(PlayerView()))
+        ("Animation Player", AnyView(PlayerView())),
+        ("Shared Worker", AnyView(SharedWorkerView()))
     ]
 }
 

Source/Experimental/Utilities/MetalDevice.swift

@@ -9,80 +9,24 @@
 import Foundation
 import Metal
 
-/// Singleton that safely caches the system default Metal device.
-final class MetalDevice: @unchecked Sendable {
+actor MetalDevice {
     static let shared = MetalDevice()
-
-    private var device: UncheckedSendable<MTLDevice>?
-    private var deviceTask: Task<UncheckedSendable<MTLDevice>?, Never>?
-    private let lock = NSLock()
-
-    func defaultDevice() -> UncheckedSendable<MTLDevice>? {
-        // Serialize access to the cached device.
-        lock.withLock {
-            if let device { return device }
-
-            // First access pays the system lookup cost once.
-            let defaultDevice = MTLCreateSystemDefaultDevice().map(UncheckedSendable.init)
-
-            device = defaultDevice
-            return defaultDevice
-        }
-    }
+    private var defaultDevice: UncheckedSendable<MTLDevice>?
 
     func defaultDevice() async -> UncheckedSendable<MTLDevice>? {
-        // Fast-path: return cached device without spawning a task.
-        if let cached = cachedDevice() {
-            return cached
-        }
-        return await asyncDefaultDevice()
-    }
-
-    private func cachedDevice() -> UncheckedSendable<MTLDevice>? {
-        // Read the cached device under lock to avoid races.
-        lock.withLock { device }
-    }
-
-    private func asyncDefaultDevice() async -> UncheckedSendable<MTLDevice>? {
-        // Ensure only one async task performs device creation.
-        var existingDevice: UncheckedSendable<MTLDevice>?
-        var existingTask: Task<UncheckedSendable<MTLDevice>?, Never>?
-        var createdTask: Task<UncheckedSendable<MTLDevice>?, Never>?
-
-        lock.withLock {
-            if let cachedDevice = self.device {
-                existingDevice = cachedDevice
-                return
-            }
-            if let deviceTask {
-                existingTask = deviceTask
-                return
-            }
-            let task = makeDeviceTask()
-            deviceTask = task
-            createdTask = task
-        }
-
-        if let existingDevice {
-            return existingDevice
+        if let defaultDevice {
+            return defaultDevice
         }
 
-        let task = existingTask ?? createdTask
-        let resolvedDevice = await task?.value
-
-        if createdTask != nil {
-            // Clear in-flight state after completion.
-            lock.withLock {
-                deviceTask = nil
+        let device = await Task.detached { () -> UncheckedSendable<MTLDevice>? in
+            guard let device = MTLCreateSystemDefaultDevice() else {
+                return nil
             }
-        }
 
-        return resolvedDevice
-    }
+            return UncheckedSendable(value: device)
+        }.value
 
-    private func makeDeviceTask() -> Task<UncheckedSendable<MTLDevice>?, Never> {
-        return Task.detached { [weak self] in
-            self?.defaultDevice()
-        }
+        defaultDevice = device
+        return device
     }
 }

Source/Experimental/Worker/Worker.swift

@@ -24,25 +24,31 @@ public class Worker {
     private var images: [String: Image] = [:]
     private var fonts: [String: Font] = [:]
     private var audios: [String: Audio] = [:]
-    
-    /// Creates a new worker that spawns a new background instance of Rive.
-    ///
-    /// The worker will automatically start processing when initialized.
-    @MainActor
-    public convenience init() throws {
-        guard let device = MetalDevice.shared.defaultDevice()?.value else {
-            throw WorkerError.missingDevice
-        }
-
-        self.init(device: device)
-    }
 
     @MainActor
     public convenience init() async throws {
-        guard let device = await MetalDevice.shared.defaultDevice()?.value else {
+        guard let device = await MetalDevice.shared.defaultDevice() else {
             throw WorkerError.missingDevice
         }
-        self.init(device: device)
+
+        let renderContext = await Task.detached(priority: .userInitiated) { () -> UncheckedSendable<RiveRenderContext> in
+            UncheckedSendable(value: RiveRenderContext(device: device.value))
+        }.value
+
+        let commandQueue = CommandQueue()
+        let commandServer = CommandServer(commandQueue: commandQueue, renderContext: renderContext.value)
+
+        self.init(
+            dependencies: .init(
+                workerService: .init(
+                    dependencies: .init(
+                        commandQueue: commandQueue,
+                        commandServer: commandServer,
+                        renderContext: renderContext.value
+                    )
+                )
+            )
+        )
     }
 
     @MainActor

Tests/Experimental/Artboard/ArtboardTests.swift

@@ -140,7 +140,7 @@ class ArtboardTests: XCTestCase {
         let artboard = Artboard(dependencies: dependencies, artboardHandle: 1)
 
         // Create a mock file with dependencies
-        let (file, _, _, _) = File.mock(fileHandle: 123)
+        let (file, _, _, _) = await File.mock(fileHandle: 123)
 
         // Mock the command queue to trigger the onDefaultViewModelInfoReceived callback
         let expectation = expectation(description: "default view model info received")
@@ -175,7 +175,7 @@ class ArtboardTests: XCTestCase {
         let artboard = Artboard(dependencies: dependencies, artboardHandle: 42)
 
         // Create a mock file with dependencies
-        let (file, _, _, _) = File.mock(fileHandle: 456)
+        let (file, _, _, _) = await File.mock(fileHandle: 456)
 
         // Mock the command queue to verify correct handles are passed
         let expectation = expectation(description: "default view model info received")