🎬 SharePlay

import GroupActivities

struct Movie: Hashable, Codable {
    let id: String
    let title: String
    let url: URL
}

// GroupActivity 프로토콜 채택
struct WatchingMovie: GroupActivity {
    // 공유할 영화 정보
    let movie: Movie

    // 메타데이터 (FaceTime UI에 표시)
    var metadata: GroupActivityMetadata {
        var metadata = GroupActivityMetadata()
        metadata.title = movie.title
        metadata.type = .watchTogether
        metadata.fallbackURL = movie.url

        // 선택 사항: 이미지, 부제목
        // metadata.previewImage = ...
        // metadata.subtitle = "영화"

        return metadata
    }
}

import GroupActivities
import Combine

@Observable
class SharePlayManager {
    var groupSession: GroupSession<WatchingMovie>?
    var isSharePlayActive = false
    var activeParticipants: [Participant] = []

    private var cancellables = Set<AnyCancellable>()
    private var tasks = Set<Task<Void, Never>>()

    init() {
        observeGroupSessions()
    }

    // GroupSession 변화 관찰
    func observeGroupSessions() {
        let task = Task {
            for await session in WatchingMovie.sessions() {
                configureGroupSession(session)
            }
        }
        tasks.insert(task)
    }

    // SharePlay 세션 시작
    func startSharePlay(movie: Movie) async throws {
        let activity = WatchingMovie(movie: movie)

        // 세션 활성화 시도
        switch await activity.prepareForActivation() {
        case .activationPreferred:
            // 사용자가 SharePlay 선택 → 세션 활성화
            try await activity.activate()

        case .activationDisabled:
            // SharePlay 비활성화 → 로컬에서만 재생
            print("SharePlay 비활성화됨")

        case .cancelled:
            // 사용자가 취소
            print("SharePlay 취소됨")

        @unknown default:
            break
        }
    }

    // GroupSession 설정
    func configureGroupSession(_ session: GroupSession<WatchingMovie>) {
        groupSession = session
        isSharePlayActive = true

        // 참가자 목록 업데이트
        session.$activeParticipants
            .sink { [weak self] participants in
                self?.activeParticipants = Array(participants)
            }
            .store(in: &cancellables)

        // 세션 상태 변화 관찰
        session.$state
            .sink { [weak self] state in
                if state == .invalidated {
                    self?.isSharePlayActive = false
                    self?.groupSession = nil
                }
            }
            .store(in: &cancellables)

        // 세션 조인
        session.join()
    }

    // SharePlay 세션 종료
    func endSharePlay() {
        groupSession?.end()
        groupSession = nil
        isSharePlayActive = false
    }

    deinit {
        tasks.forEach { $0.cancel() }
    }
}

import AVFoundation
import GroupActivities

@Observable
class VideoPlayerManager {
    var player: AVPlayer?
    var groupSession: GroupSession<WatchingMovie>?

    private var playbackCoordinator: AVPlayerPlaybackCoordinator?

    // SharePlay로 비디오 재생
    func playVideo(url: URL, session: GroupSession<WatchingMovie>?) {
        // AVPlayer 생성
        let playerItem = AVPlayerItem(url: url)
        let player = AVPlayer(playerItem: playerItem)
        self.player = player

        // SharePlay 세션과 연결
        if let session {
            playbackCoordinator = player.playbackCoordinator
            playbackCoordinator?.coordinateWithSession(session)
        }

        // 재생 시작
        player.play()
    }

    // 재생/일시정지 토글
    func togglePlayback() {
        guard let player else { return }

        if player.timeControlStatus == .playing {
            player.pause()
        } else {
            player.play()
        }
    }

    // 특정 시간으로 이동
    func seek(to time: CMTime) {
        player?.seek(to: time)
    }
}

import GroupActivities
import MusicKit

struct Song: Hashable, Codable {
    let id: String
    let title: String
    let artist: String
}

struct ListeningTogether: GroupActivity {
    let song: Song

    var metadata: GroupActivityMetadata {
        var metadata = GroupActivityMetadata()
        metadata.title = song.title
        metadata.subtitle = song.artist
        metadata.type = .listenTogether
        return metadata
    }
}

@Observable
class MusicSharePlayManager {
    var groupSession: GroupSession<ListeningTogether>?

    func startListeningTogether(song: Song) async throws {
        let activity = ListeningTogether(song: song)

        switch await activity.prepareForActivation() {
        case .activationPreferred:
            try await activity.activate()
        default:
            break
        }
    }
}

import GroupActivities

// 전송할 메시지 정의
struct ChatMessage: Codable {
    let senderID: UUID
    let text: String
    let timestamp: Date
}

struct ReactionMessage: Codable {
    let senderID: UUID
    let emoji: String
}

@Observable
class GroupSessionMessenger {
    var groupSession: GroupSession<WatchingMovie>?
    var messages: [ChatMessage] = []
    var reactions: [ReactionMessage] = []

    private var messenger: GroupSessionMessenger?
    private var tasks = Set<Task<Void, Never>>()

    func configureMessenger(session: GroupSession<WatchingMovie>) {
        groupSession = session
        messenger = GroupSessionMessenger(session: session)

        // 채팅 메시지 수신
        let chatTask = Task {
            for await (message, context) in messenger!.messages(of: ChatMessage.self) {
                handleChatMessage(message, from: context.source)
            }
        }
        tasks.insert(chatTask)

        // 반응 메시지 수신
        let reactionTask = Task {
            for await (reaction, _) in messenger!.messages(of: ReactionMessage.self) {
                handleReaction(reaction)
            }
        }
        tasks.insert(reactionTask)
    }

    // 채팅 메시지 전송
    func sendChatMessage(_ text: String) async {
        guard let messenger, let localParticipant = groupSession?.localParticipant else { return }

        let message = ChatMessage(
            senderID: localParticipant.id,
            text: text,
            timestamp: Date()
        )

        do {
            try await messenger.send(message)
        } catch {
            print("메시지 전송 실패: \(error)")
        }
    }

    // 반응 전송
    func sendReaction(_ emoji: String) async {
        guard let messenger, let localParticipant = groupSession?.localParticipant else { return }

        let reaction = ReactionMessage(
            senderID: localParticipant.id,
            emoji: emoji
        )

        try? await messenger.send(reaction, to: .all)
    }

    private func handleChatMessage(_ message: ChatMessage, from sender: Participant.ID) {
        messages.append(message)
    }

    private func handleReaction(_ reaction: ReactionMessage) {
        reactions.append(reaction)

        // 3초 후 자동 제거
        Task {
            try? await Task.sleep(for: .seconds(3))
            reactions.removeAll { $0.senderID == reaction.senderID }
        }
    }

    deinit {
        tasks.forEach { $0.cancel() }
    }
}

import SwiftUI
import AVKit

struct SharePlayDemoView: View {
    @State private var sharePlayManager = SharePlayManager()
    @State private var videoManager = VideoPlayerManager()
    @State private var messenger = GroupSessionMessenger()

    let sampleMovie = Movie(
        id: "1",
        title: "샘플 영화",
        url: URL(string: "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4")!
    )

    var body: some View {
        NavigationStack {
            VStack {
                // 비디오 플레이어
                if let player = videoManager.player {
                    VideoPlayer(player: player)
                        .frame(height: 250)
                }

                // SharePlay 상태
                Section {
                    if sharePlayManager.isSharePlayActive {
                        Label("SharePlay 활성", systemImage: "shareplay")
                            .foregroundStyle(.green)

                        Text("참가자: \(sharePlayManager.activeParticipants.count)명")
                            .font(.caption)

                        Button("SharePlay 종료", role: .destructive) {
                            sharePlayManager.endSharePlay()
                        }
                    } else {
                        Button("SharePlay 시작") {
                            Task {
                                try? await sharePlayManager.startSharePlay(movie: sampleMovie)
                            }
                        }
                        .buttonStyle(.borderedProminent)
                    }
                }
                .padding()

                // 재생 컨트롤
                HStack(spacing: 20) {
                    Button {
                        videoManager.togglePlayback()
                    } label: {
                        Image(systemName: videoManager.player?.timeControlStatus == .playing ? "pause.circle.fill" : "play.circle.fill")
                            .font(.system(size: 50))
                    }
                }
                .padding()

                // 반응 버튼
                if sharePlayManager.isSharePlayActive {
                    HStack(spacing: 15) {
                        ForEach(["❤️", "😂", "😮", "👏"], id: \.self) { emoji in
                            Button(emoji) {
                                Task {
                                    await messenger.sendReaction(emoji)
                                }
                            }
                            .font(.title)
                        }
                    }
                    .padding()

                    // 반응 표시
                    HStack {
                        ForEach(messenger.reactions, id: \.senderID) { reaction in
                            Text(reaction.emoji)
                                .font(.largeTitle)
                                .transition(.scale.combined(with: .opacity))
                        }
                    }
                }

                Spacer()
            }
            .navigationTitle("SharePlay 데모")
            .onChange(of: sharePlayManager.groupSession) { _, session in
                if let session {
                    videoManager.playVideo(
                        url: sampleMovie.url,
                        session: session
                    )
                    messenger.configureMessenger(session: session)
                }
            }
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
 "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.developer.group-activities</key>
    <true/>
</dict>
</plist>