Working with Media Playback

import AVFoundation

let videoURL = URL(string: "https://example.com/video.mp4")!
let player = AVPlayer(url: videoURL)

import AVKit

let playerLayer = AVPlayerLayer(player: player)
playerLayer.frame = view.bounds
view.layer.addSublayer(playerLayer)

player.play()

let observer = player.addPeriodicTimeObserver(
    forInterval: CMTimeMake(value: 1, timescale: 1),
    queue: .main
) { time in
    print("Current time: \(time.seconds)")
}

import AVKit
import AVFoundation

class MediaViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        guard let url = Bundle.main.url(forResource: "sample", withExtension: "mp4") else {
            return
        }
        
        let player = AVPlayer(url: url)
        let controller = AVPlayerViewController()
        controller.player = player
        
        addChild(controller)
        view.addSubview(controller.view)
        controller.didMove(toParent: self)
        
        controller.view.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            controller.view.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            controller.view.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            controller.view.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            controller.view.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor)
        ])
    }
}

import AVFoundation

let player = AVPlayer(url: mediaURL)
player.play()
player.rate = 1.5
player.seek(to: CMTime(seconds: 30, preferredTimescale: 1))

import AVFoundation

class MediaPlaybackObserver: NSObject {
    private let player = AVPlayer()
    
    func observePlaybackState() {
        // Observe playback state changes
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(playbackStateChanged),
            name: .AVPlayerItemDidPlayToEndTime,
            object: player.currentItem
        )
        
        // Observe rate changes
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(rateChanged),
            name: .AVPlayerRateDidChange,
            object: player
        )
    }
    
    @objc private func playbackStateChanged() {
        print("Playback completed")
    }
    
    @objc private func rateChanged() {
        print("Rate changed to: \(player.rate)")
    }
}

import AVFoundation

class AudioPlayerManager {
    var audioPlayer: AVAudioPlayer?

    func playAudio(named fileName: String) {
        guard let url = Bundle.main.url(forResource: fileName, withExtension: "mp3") else {
            print("Could not find audio file")
            return
        }

        do {
            audioPlayer = try AVAudioPlayer(contentsOf: url)
            audioPlayer?.delegate = self
            audioPlayer?.play()
        } catch {
            print("Error initializing audio player: \(error)")
        }
    }
}

extension AudioPlayerManager: AVAudioPlayerDelegate {
    func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
        print("Finished playing audio")
    }
}

audioPlayer?.volume = 0.7
audioPlayer?.rate = 1.2 // Play at 1.2x speed

import AVFoundation

do {
    let audioSession = AVAudioSession.sharedInstance()
    try audioSession.setCategory(.playback)
    try audioSession.setMode(.default)
    try audioSession.setActive(true)
} catch {
    print("Audio session setup failed: \(error)")
}

import AVFoundation

do {
    try AVAudioSession.sharedInstance().setCategory(.playback, mode: .default, options: [.allowBluetooth, .mixWithOthers])
    try AVAudioSession.sharedInstance().setActive(true)
} catch {
    print("Failed to set up audio session: \(error)")
}

import AVFoundation

@objc func handleInterruption(_ notification: Notification) {
    guard let interruption = notification.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt else { return }
    
    switch interruption {
    case AVAudioSession.InterruptionType.began.rawValue:
        // Pause playback
        player?.pause()
    case AVAudioSession.InterruptionType.ended.rawValue:
        // Resume playback if interruption was not due to an app switch
        if let options = notification.userInfo?[AVAudioSessionInterruptionOptionKey] as? UInt {
            if options & AVAudioSession.InterruptionOptions.shouldResume.rawValue != 0 {
                player?.play()
            }
        }
    default:
        break
    }
}

import AVFoundation

class AudioPlayerManager {
    private let audioSession = AVAudioSession.sharedInstance()
    
    func setupAudioSession() {
        do {
            try audioSession.setCategory(.playback)
            try audioSession.setActive(true)
        } catch {
            print("Failed to set up audio session: \(error)")
        }
    }
    
    func handleInterruption(_ notification: Notification) {
        guard let type = notification.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt else { return }
        
        switch type {
        case AVAudioSessionInterruptionType.began.rawValue:
            // Pause playback
            print("Audio interruption began")
        case AVAudioSessionInterruptionType.ended.rawValue:
            // Resume playback if needed
            print("Audio interruption ended")
        default:
            break
        }
    }
}

import AVFoundation

let url = URL(string: "https://example.com/media.mp4")!
let player = AVPlayer(url: url)
player.play()

import AVKit

let player = AVPlayer(url: url)
let playerViewController = AVPlayerViewController()
playerViewController.player = player

present(playerViewController, animated: true) {
    player.play()
}

import MediaPlayer

let query = MPMediaQuery.songs()
query.addFilterPredicate(MPMediaPropertyPredicate(value: "Song Title", forProperty: MPMediaItemPropertyTitle))

if let items = query.items {
    for item in items {
        print(item.title ?? "Unknown Title")
    }
}

import MediaPlayer

let nowPlayingInfo = [
    MPMediaItemPropertyTitle: "Song Title",
    MPMediaItemPropertyArtist: "Artist Name",
    MPMediaItemPropertyAlbumTitle: "Album Name",
    MPMediaItemPropertyArtwork: MPMediaItemArtwork(boundsSize: CGSize(width: 100, height: 100)) { _ in
        UIImage(named: "albumArt")
    },
    MPMediaItemPropertyPlaybackDuration: 180.0,
    MPNowPlayingInfoPropertyElapsedPlaybackTime: 30.0
] as [String: Any]

MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo