🎬 AVFoundation

import SwiftUI
import AVFoundation

@Observable
class CameraManager: NSObject {
    let captureSession = AVCaptureSession()
    var videoOutput = AVCaptureMovieFileOutput()
    var previewLayer: AVCaptureVideoPreviewLayer?
    var isRecording = false

    func setupCamera() {
        // 세션 설정
        captureSession.beginConfiguration()

        // 비디오 입력 추가
        guard let videoDevice = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back),
              let videoInput = try? AVCaptureDeviceInput(device: videoDevice),
              captureSession.canAddInput(videoInput)
        else { return }

        captureSession.addInput(videoInput)

        // 오디오 입력 추가
        if let audioDevice = AVCaptureDevice.default(for: .audio),
           let audioInput = try? AVCaptureDeviceInput(device: audioDevice),
           captureSession.canAddInput(audioInput) {
            captureSession.addInput(audioInput)
        }

        // 비디오 출력 추가
        if captureSession.canAddOutput(videoOutput) {
            captureSession.addOutput(videoOutput)
        }

        // 세션 품질 설정
        captureSession.sessionPreset = .high

        captureSession.commitConfiguration()
    }

    func startSession() {
        Task(priority: .background) {
            captureSession.startRunning()
        }
    }

    func stopSession() {
        Task(priority: .background) {
            captureSession.stopRunning()
        }
    }

    func startRecording(to url: URL) {
        videoOutput.startRecording(to: url, recordingDelegate: self)
        isRecording = true
    }

    func stopRecording() {
        videoOutput.stopRecording()
        isRecording = false
    }
}

// 녹화 델리게이트
extension CameraManager: AVCaptureFileOutputRecordingDelegate {
    func fileOutput(
        _ output: AVCaptureFileOutput,
        didFinishRecordingTo outputFileURL: URL,
        from connections: [AVCaptureConnection],
        error: Error?
    ) {
        if let error = error {
            print("녹화 오류: \(error.localizedDescription)")
        } else {
            print("녹화 완료: \(outputFileURL)")
        }
    }
}

struct CameraView: View {
    @State private var cameraManager = CameraManager()

    var body: some View {
        ZStack {
            CameraPreview(session: cameraManager.captureSession)
                .ignoresSafeArea()

            VStack {
                Spacer()

                Button {
                    if cameraManager.isRecording {
                        cameraManager.stopRecording()
                    } else {
                        let url = FileManager.default.temporaryDirectory.appendingPathComponent("video.mov")
                        cameraManager.startRecording(to: url)
                    }
                } label: {
                    Circle()
                        .fill(cameraManager.isRecording ? Color.red : Color.white)
                        .frame(width: 70, height: 70)
                        .overlay(
                            Circle()
                                .stroke(Color.white, lineWidth: 4)
                        )
                }
                .padding(.bottom, 50)
            }
        }
        .onAppear {
            cameraManager.setupCamera()
            cameraManager.startSession()
        }
        .onDisappear {
            cameraManager.stopSession()
        }
    }
}

struct CameraPreview: UIViewRepresentable {
    let session: AVCaptureSession

    func makeUIView(context: Context) -> UIView {
        let view = UIView(frame: .zero)
        let previewLayer = AVCaptureVideoPreviewLayer(session: session)
        previewLayer.videoGravity = .resizeAspectFill
        view.layer.addSublayer(previewLayer)

        DispatchQueue.main.async {
            previewLayer.frame = view.bounds
        }

        return view
    }

    func updateUIView(_ uiView: UIView, context: Context) {
        if let layer = uiView.layer.sublayers?.first as? AVCaptureVideoPreviewLayer {
            layer.frame = uiView.bounds
        }
    }
}

import SwiftUI
import AVFoundation

@Observable
class AudioRecorderManager: NSObject {
    var audioRecorder: AVAudioRecorder?
    var isRecording = false
    var recordingTime: TimeInterval = 0

    func setupRecorder() {
        // 오디오 세션 설정
        let audioSession = AVAudioSession.sharedInstance()
        try? audioSession.setCategory(.playAndRecord, mode: .default)
        try? audioSession.setActive(true)

        // 녹음 설정
        let settings: [String: Any] = [
            AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
            AVSampleRateKey: 44100.0,
            AVNumberOfChannelsKey: 2,
            AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
        ]

        let url = FileManager.default.temporaryDirectory.appendingPathComponent("recording.m4a")

        do {
            audioRecorder = try AVAudioRecorder(url: url, settings: settings)
            audioRecorder?.delegate = self
            audioRecorder?.prepareToRecord()
        } catch {
            print("녹음 설정 오류: \(error)")
        }
    }

    func startRecording() {
        audioRecorder?.record()
        isRecording = true
    }

    func stopRecording() {
        audioRecorder?.stop()
        isRecording = false
    }

    func pauseRecording() {
        audioRecorder?.pause()
        isRecording = false
    }
}

extension AudioRecorderManager: AVAudioRecorderDelegate {
    func audioRecorderDidFinishRecording(_ recorder: AVAudioRecorder, successfully flag: Bool) {
        if flag {
            print("녹음 완료: \(recorder.url)")
        }
    }
}

struct AudioRecorderView: View {
    @State private var recorderManager = AudioRecorderManager()

    var body: some View {
        VStack(spacing: 30) {
            Text(recorderManager.isRecording ? "녹음 중..." : "준비됨")
                .font(.title)
                .foregroundStyle(recorderManager.isRecording ? .red : .primary)

            HStack(spacing: 40) {
                Button {
                    if recorderManager.isRecording {
                        recorderManager.stopRecording()
                    } else {
                        recorderManager.startRecording()
                    }
                } label: {
                    Image(systemName: recorderManager.isRecording ? "stop.circle.fill" : "record.circle")
                        .font(.system(size: 64))
                        .foregroundStyle(recorderManager.isRecording ? .red : .blue)
                }

                if recorderManager.isRecording {
                    Button {
                        recorderManager.pauseRecording()
                    } label: {
                        Image(systemName: "pause.circle.fill")
                            .font(.system(size: 64))
                    }
                }
            }
        }
        .onAppear {
            recorderManager.setupRecorder()
        }
    }
}

import SwiftUI
import AVFoundation

@Observable
class VideoPlayerManager {
    var player: AVPlayer?
    var isPlaying = false
    var currentTime: TimeInterval = 0
    var duration: TimeInterval = 0

    func loadVideo(from url: URL) {
        let asset = AVAsset(url: url)
        let playerItem = AVPlayerItem(asset: asset)
        player = AVPlayer(playerItem: playerItem)

        // 재생 시간 관찰
        player?.addPeriodicTimeObserver(
            forInterval: CMTime(seconds: 0.5, preferredTimescale: 600),
            queue: .main
        ) { [weak self] time in
            self?.currentTime = time.seconds
        }

        // 영상 길이 가져오기
        Task {
            if let duration = try? await asset.load(.duration) {
                self.duration = duration.seconds
            }
        }
    }

    func play() {
        player?.play()
        isPlaying = true
    }

    func pause() {
        player?.pause()
        isPlaying = false
    }

    func seek(to time: TimeInterval) {
        let cmTime = CMTime(seconds: time, preferredTimescale: 600)
        player?.seek(to: cmTime)
    }
}

struct VideoPlayerView: View {
    let url: URL
    @State private var playerManager = VideoPlayerManager()

    var body: some View {
        VStack {
            // 비디오 뷰
            VideoPlayerLayer(player: playerManager.player)
                .frame(height: 300)
                .background(Color.black)

            // 재생 컨트롤
            VStack(spacing: 16) {
                // 진행 바
                Slider(
                    value: Binding(
                        get: { playerManager.currentTime },
                        set: { playerManager.seek(to: $0) }
                    ),
                    in: 0...max(playerManager.duration, 1)
                )

                // 시간 표시
                HStack {
                    Text(formatTime(playerManager.currentTime))
                    Spacer()
                    Text(formatTime(playerManager.duration))
                }
                .font(.caption)
                .foregroundStyle(.secondary)

                // 재생 버튼
                Button {
                    if playerManager.isPlaying {
                        playerManager.pause()
                    } else {
                        playerManager.play()
                    }
                } label: {
                    Image(systemName: playerManager.isPlaying ? "pause.circle.fill" : "play.circle.fill")
                        .font(.system(size: 64))
                }
            }
            .padding()
        }
        .onAppear {
            playerManager.loadVideo(from: url)
        }
    }

    func formatTime(_ time: TimeInterval) -> String {
        let minutes = Int(time) / 60
        let seconds = Int(time) % 60
        return String(format: "%d:%02d", minutes, seconds)
    }
}

struct VideoPlayerLayer: UIViewRepresentable {
    let player: AVPlayer?

    func makeUIView(context: Context) -> UIView {
        let view = UIView(frame: .zero)
        let playerLayer = AVPlayerLayer(player: player)
        playerLayer.videoGravity = .resizeAspect
        view.layer.addSublayer(playerLayer)

        DispatchQueue.main.async {
            playerLayer.frame = view.bounds
        }

        return view
    }

    func updateUIView(_ uiView: UIView, context: Context) {
        if let layer = uiView.layer.sublayers?.first as? AVPlayerLayer {
            layer.frame = uiView.bounds
        }
    }
}

import AVFoundation
import UIKit

class VideoEditor {
    // 비디오 자르기
    func trimVideo(
        asset: AVAsset,
        startTime: CMTime,
        endTime: CMTime,
        outputURL: URL
    ) async throws {
        // Composition 생성
        let composition = AVMutableComposition()

        // 비디오 트랙 추가
        guard let videoTrack = composition.addMutableTrack(
            withMediaType: .video,
            preferredTrackID: kCMPersistentTrackID_Invalid
        ) else { return }

        // 오디오 트랙 추가
        guard let audioTrack = composition.addMutableTrack(
            withMediaType: .audio,
            preferredTrackID: kCMPersistentTrackID_Invalid
        ) else { return }

        // 원본 트랙 가져오기
        let assetVideoTrack = try await asset.loadTracks(withMediaType: .video).first
        let assetAudioTrack = try await asset.loadTracks(withMediaType: .audio).first

        // 시간 범위
        let timeRange = CMTimeRange(start: startTime, end: endTime)

        // 트랙 삽입
        if let assetVideoTrack {
            try videoTrack.insertTimeRange(timeRange, of: assetVideoTrack, at: .zero)
        }

        if let assetAudioTrack {
            try audioTrack.insertTimeRange(timeRange, of: assetAudioTrack, at: .zero)
        }

        // 내보내기
        try await exportVideo(composition: composition, to: outputURL)
    }

    // 여러 비디오 합치기
    func mergeVideos(
        assets: [AVAsset],
        outputURL: URL
    ) async throws {
        let composition = AVMutableComposition()

        guard let videoTrack = composition.addMutableTrack(
            withMediaType: .video,
            preferredTrackID: kCMPersistentTrackID_Invalid
        ) else { return }

        guard let audioTrack = composition.addMutableTrack(
            withMediaType: .audio,
            preferredTrackID: kCMPersistentTrackID_Invalid
        ) else { return }

        var currentTime = CMTime.zero

        for asset in assets {
            let duration = try await asset.load(.duration)
            let timeRange = CMTimeRange(start: .zero, duration: duration)

            if let assetVideoTrack = try await asset.loadTracks(withMediaType: .video).first {
                try videoTrack.insertTimeRange(timeRange, of: assetVideoTrack, at: currentTime)
            }

            if let assetAudioTrack = try await asset.loadTracks(withMediaType: .audio).first {
                try audioTrack.insertTimeRange(timeRange, of: assetAudioTrack, at: currentTime)
            }

            currentTime = CMTimeAdd(currentTime, duration)
        }

        try await exportVideo(composition: composition, to: outputURL)
    }

    // 비디오 내보내기
    private func exportVideo(
        composition: AVMutableComposition,
        to url: URL
    ) async throws {
        guard let exportSession = AVAssetExportSession(
            asset: composition,
            presetName: AVAssetExportPresetHighestQuality
        ) else { return }

        exportSession.outputURL = url
        exportSession.outputFileType = .mov

        await exportSession.export()

        if exportSession.status == .failed {
            throw exportSession.error ?? NSError(domain: "", code: -1)
        }
    }

    // 비디오에 워터마크 추가
    func addWatermark(
        to asset: AVAsset,
        watermarkImage: UIImage,
        outputURL: URL
    ) async throws {
        let composition = AVMutableComposition()
        let videoComposition = AVMutableVideoComposition()

        // 비디오 트랙 추가
        guard let videoTrack = composition.addMutableTrack(
            withMediaType: .video,
            preferredTrackID: kCMPersistentTrackID_Invalid
        ) else { return }

        let assetVideoTrack = try await asset.loadTracks(withMediaType: .video).first
        let duration = try await asset.load(.duration)

        if let assetVideoTrack {
            try videoTrack.insertTimeRange(
                CMTimeRange(start: .zero, duration: duration),
                of: assetVideoTrack,
                at: .zero
            )
        }

        // 워터마크 레이어 추가
        let watermarkLayer = CALayer()
        watermarkLayer.contents = watermarkImage.cgImage
        watermarkLayer.frame = CGRect(x: 20, y: 20, width: 100, height: 100)
        watermarkLayer.opacity = 0.7

        let videoLayer = CALayer()
        videoLayer.frame = CGRect(origin: .zero, size: CGSize(width: 1920, height: 1080))

        let outputLayer = CALayer()
        outputLayer.frame = videoLayer.frame
        outputLayer.addSublayer(videoLayer)
        outputLayer.addSublayer(watermarkLayer)

        videoComposition.animationTool = AVVideoCompositionCoreAnimationTool(
            postProcessingAsVideoLayer: videoLayer,
            in: outputLayer
        )

        try await exportVideo(composition: composition, to: outputURL)
    }
}

import SwiftUI
import AVFoundation

struct MediaApp: View {
    @State private var selectedTab = 0

    var body: some View {
        TabView(selection: $selectedTab) {
            CameraView()
                .tabItem {
                    Label("카메라", systemImage: "camera")
                }
                .tag(0)

            AudioRecorderView()
                .tabItem {
                    Label("녹음", systemImage: "mic")
                }
                .tag(1)

            MediaLibraryView()
                .tabItem {
                    Label("라이브러리", systemImage: "photo.stack")
                }
                .tag(2)
        }
    }
}

struct MediaLibraryView: View {
    var body: some View {
        NavigationStack {
            List {
                Section("비디오") {
                    Text("최근 촬영")
                }

                Section("오디오") {
                    Text("최근 녹음")
                }
            }
            .navigationTitle("미디어")
        }
    }
}