Comparte experiencias de visionOS con personas cercanas

6:21 - Expose an activity with GroupActivities and SwiftUI

// Expose an activity with GroupActivities and SwiftUI

import SwiftUI
import GroupActivities

struct BoardGameActivity: GroupActivity, Transferable {
    var metadata: GroupActivityMetadata = {
        var metadata = GroupActivityMetadata()
        metadata.title = "Play Together"
        return metadata
    }()
}

struct BoardGameApp: App {
    var body: some Scene {
        WindowGroup {
            BoardGameView()
            ShareLink(item: BoardGameActivity(), preview: SharePreview("Play Together"))
                .hidden()
        }
        .windowStyle(.volumetric)
    }
}

struct BoardGameView: View {
    var body: some View {
        // Board game content
    }
}

7:14 - Join a GroupSession with GroupActivities

// Join a GroupSession with GroupActivities

func observeSessions() async {

    // Sessions are created automatically when the activity is activated
    for await session in BoardGameActivity.sessions() {

        // Additional configuration and setup

        // Join SharePlay
        session.join()
    }
}

8:57 - Join and configure a GroupSession with GroupActivities

// Join a GroupSession with GroupActivities

func observeSessions() async {

    // Sessions are created automatically when the activity is activated
    for await session in BoardGameActivity.sessions() {

        // Additional configuration and setup

        guard let systemCoordinator = await session.systemCoordinator else { continue }
        systemCoordinator.configuration.supportsGroupImmersiveSpace = true

        // Join SharePlay
        session.join()
    }
}

9:59 - Check for nearby participants with GroupActivities

// Check for nearby participants with GroupActivities

func observeParticipants(session: GroupSession<BoardGameActivity>) async {
    for await activeParticipants in session.$activeParticipants.values {
        let nearbyParticipants = activeParticipants.filter {
            $0.isNearbyWithLocalParticipant && $0 != session.localParticipant
        }
    }
}

11:42 - Observe local participant pose with GroupActivities

// Observe local participant pose with GroupActivities

func observeLocalParticipantState(session: GroupSession<BoardGameActivity>) async {
    guard let systemCoordinator = await session.systemCoordinator else { return }

    for await localParticipantState in systemCoordinator.localParticipantStates {
        let localParticipantPose = localParticipantState.pose
        // Place presented content relative to the local participant pose
    }
}

15:54 - Associate a specific window with GroupActivities and SwiftUI

// Associate a specific window with GroupActivities and SwiftUI

import SwiftUI
import GroupActivities

struct BoardGameApp: App {
    var body: some Scene {
        WindowGroup {
            BoardGameView()
            ShareLink(item: BoardGameActivity(), preview: SharePreview("Play Together"))
                .hidden()
        }
        .windowStyle(.volumetric)
        
        WindowGroup(id: "InstructionalVideo") {
            InstructionalVideoView()
                .groupActivityAssociation(.primary("InstructionalVideo"))
        }
    }
}

struct BoardGameView: View {
    var body: some View {
        // Board game content
    }
}

struct InstructionalVideoView: View {
    var body: some View {
        // Video content
    }
}

18:27 - Create a world anchor with ARKit

// Create a world anchor with ARKit

import ARKit

class AnchorController {

    func setUp(session: ARKitSession, provider: WorldTrackingProvider) async throws {
        try await session.run([provider])
    }

    func createAnchor(at transform: simd_float4x4, provider: WorldTrackingProvider) async throws {
        let anchor = WorldAnchor(originFromAnchorTransform: transform)
        try await provider.addAnchor(anchor)
    }

    func observeWorldTracking(provider: WorldTrackingProvider) async {
       for await update in provider.anchorUpdates {
            switch update.event {
            case .added, .updated, .removed:
                // Add, update, or remove furniture
                break
            }
        }
    }
}

20:02 - Observe sharing availability with ARKit

// Observe sharing availability with ARKit

func observeSharingAvailability(provider: WorldTrackingProvider) async {
    for await sharingAvailability in provider.worldAnchorSharingAvailability {
         if sharingAvailability == .available {
             // Store availability to check when creating a new shared world anchor
         }
     }
}

20:24 - Create a shared world anchor with ARKit

// Create a shared world anchor with ARKit

import ARKit

class SharedAnchorController {
    
    func setUp(session: ARKitSession, provider: WorldTrackingProvider) async throws {
        try await session.run([provider])
    }

    func createAnchor(at transform: simd_float4x4, provider: WorldTrackingProvider) async throws {
        let anchor = WorldAnchor(originFromAnchorTransform: transform,
                                 sharedWithNearbyParticipants: true)
        try await provider.addAnchor(anchor)
    }

    func observeWorldTracking(provider: WorldTrackingProvider) async {
       for await update in provider.anchorUpdates {
            switch update.event {
            case .added, .updated, .removed:
                // Add, update, or remove furniture. Updates with shared anchors from others!
                let anchorIdentifier = update.anchor.id
            }
        }
    }
}