Shareplay Activities

import GroupActivities
let observer = GroupStateObserver()
// Check if a FaceTime call or Messages conversation is activeif observer.isEligibleForGroupSession {    showSharePlayButton()}

for await isEligible in observer.$isEligibleForGroupSession.values {    showSharePlayButton(isEligible)}

import GroupActivities
struct WatchTogetherActivity: GroupActivity {    let movieID: String    let movieTitle: String
    var metadata: GroupActivityMetadata {        var meta = GroupActivityMetadata()        meta.title = movieTitle        meta.type = .watchTogether        meta.fallbackURL = URL(string: "https://example.com/movie/\(movieID)")        return meta    }}

@Observable@MainActorfinal class SharePlayManager {    private var session: GroupSession<WatchTogetherActivity>?    private var messenger: GroupSessionMessenger?    private var sessionTasks: [Task<Void, Never>] = []
    func observeSessions() {        Task {            for await session in WatchTogetherActivity.sessions() {                self.configureSession(session)            }        }    }
    private func configureSession(        _ session: GroupSession<WatchTogetherActivity>    ) {        self.session = session        self.messenger = GroupSessionMessenger(session: session)
        // Observe session state changes        let stateTask = Task {            for await state in session.$state.values {                handleState(state)            }        }        sessionTasks.append(stateTask)
        // Observe participant changes        let participantTask = Task {            for await participants in session.$activeParticipants.values {                handleParticipants(participants)            }        }        sessionTasks.append(participantTask)
        // Join the session        session.join()    }
    private func cleanUp() {        sessionTasks.forEach { $0.cancel() }        sessionTasks.removeAll()        session = nil        messenger = nil    }}

private func handleState(_ state: GroupSession<WatchTogetherActivity>.State) {    switch state {    case .waiting:        print("Waiting to join")    case .joined:        print("Joined session")        loadActivity(session?.activity)    case .invalidated(let reason):        print("Session ended: \(reason)")        cleanUp()    @unknown default:        break    }}
private func handleParticipants(_ participants: Set<Participant>) {    print("Active participants: \(participants.count)")}

// Leave the session (other participants continue)session?.leave()
// End the session for all participantssession?.end()

struct SyncMessage: Codable {    let action: String    let timestamp: Date    let data: [String: String]}

func sendSync(_ message: SyncMessage) async throws {    guard let messenger else { return }
    try await messenger.send(message, to: .all)}
// Send to specific participantstry await messenger.send(message, to: .only(participant))

func observeMessages() {    guard let messenger else { return }
    Task {        for await (message, context) in messenger.messages(of: SyncMessage.self) {            let sender = context.source            handleReceivedMessage(message, from: sender)        }    }}

// Reliable (default) -- checked and retried for crucial statelet reliableMessenger = GroupSessionMessenger(    session: session,    deliveryMode: .reliable)
// Unreliable -- lower latency, no delivery guaranteelet unreliableMessenger = GroupSessionMessenger(    session: session,    deliveryMode: .unreliable)

import AVFoundationimport GroupActivities
func configurePlayback(    session: GroupSession<WatchTogetherActivity>,    player: AVPlayer) {    // Connect the player's coordinator to the session    let coordinator = player.playbackCoordinator    coordinator.coordinateWithSession(session)}

import GroupActivitiesimport UIKit
func startSharePlay() async throws {    let activity = WatchTogetherActivity(        movieID: "123",        movieTitle: "Great Movie"    )
    switch await activity.prepareForActivation() {    case .activationPreferred:        // A conversation is active and the user chose to share.        _ = try await activity.activate()
    case .activationDisabled:        // The user chose local playback, or sharing is unavailable.        startLocalExperience()
    case .cancelled:        break
    @unknown default:        break    }}

let controller = try GroupActivitySharingController(activity)present(controller, animated: true)

import GroupActivities
let journal = GroupSessionJournal(session: session)
// Upload a Transferable file or data itemlet attachment = try await journal.add(sharedImageItem)
// Observe incoming attachmentsTask {    for await attachments in journal.attachments {        for attachment in attachments {            let data = try await attachment.load(Data.self)            handleReceivedFile(data)        }    }}

// WRONG -- session stays alive after the user navigates awayfunc viewDidDisappear() {    // Nothing -- session leaks}
// CORRECT -- leave when the view is dismissedfunc viewDidDisappear() {    session?.leave()    session = nil    messenger = nil}

// WRONG -- broadcasting state without handling late joinersfunc onJoin() {    // New participant has no idea what the current state is}
// CORRECT -- send full state to new participantsfunc handleParticipants(_ participants: Set<Participant>) {    let newParticipants = participants.subtracting(knownParticipants)    for participant in newParticipants {        Task {            try await messenger?.send(currentState, to: .only(participant))        }    }    knownParticipants = participants}

// WRONG -- messenger is small/time-sensitive; journal is Transferable and <=100 MBlet imageData = try Data(contentsOf: imageURL)     // 300 KBtry await messenger.send(imageData, to: .all)      // Too large// CORRECT -- journal attachments up to 100 MB; otherwise share a pointer/manifestlet journal = GroupSessionJournal(session: session)try await journal.add(sharedImageItem)// Larger/protected assets: server storage or app-managed file transfer

// WRONG -- manually syncing play/pause when using AVPlayerfunc play() {    player.play()    try await messenger.send(PlayMessage(), to: .all)}
// CORRECT -- let AVPlaybackCoordinator handle itplayer.playbackCoordinator.coordinateWithSession(session)player.play()  // Automatically synced to all participants