AVPlayer — nyckelbegrepp, funktioner och användning

Vad är AVPlayer?

AVPlayer — är den centrala komponenten i AVFoundation-ramverket, ansvarig för uppspelning av multimediainnehåll på alla Apple-plattformar. Introducerad i iOS 4.0 (2010) som ersättning för den föråldrade MPMoviePlayerController, ger AVPlayer lågnivåkontroll över uppspelning med möjlighet till finjustering av avkodningsparametrar, synkronisering av ljud och video samt integration med systemtjänster som AirPlay och Picture in Picture.

Till skillnad från tredjepartsspelare drar AVPlayer nytta av hårdvaruacceleration på Apple Silicon-chips. Videavkodning sker via VideoToolbox med hjälp av dedikerade mediamotorer i M-serien (Media Engine), vilket möjliggör 8K HDR-uppspelning med minimal energiförbrukning. För HEVC (H.265) och ProRes sker avkodning på specialiserade chipblock utan att belasta CPU.

AVPlayer är tätt integrerat med Apple-ekosystemet: stöd för Handoff för att överföra uppspelning mellan enheter, AirPlay 2 för streaming till Apple TV, rumsligt ljud med dynamisk huvudspårning och synkronisering med systemkontroller via MPNowPlayingInfoCenter. Dessa integrationer gör AVPlayer till de facto-standard för alla applikationer som arbetar med media på Apple-plattformar.

AVFoundation och klasshierarki

AVFoundation-ramverket tillhandahåller en tre-nivåers hierarki för uppspelning: AVAsset (metadata och information om innehåll), AVPlayerItem (status och hantering av en specifik innehållsinstans) och AVPlayer (hantering av uppspelning). Denna arkitektur gör det möjligt att separera inläsning av metadata, förberedelse för uppspelning och själva uppspelningsprocessen, vilket är särskilt viktigt för HLS-strömmar med flera bitrate-varianter.

AVAsset representerar en modell av mediainnehåll — en fil eller ström. AVAsset är inte i sig själv uppspelningsbar; den innehåller spår (AVAssetTrack), metadata (commonMetadata), varaktighetsinformation och andra egenskaper. Från AVAsset skapas AVPlayerItem, som sedan kan överföras till AVPlayer för uppspelning.

AVPlayers huvudsakliga funktioner

AVPlayer erbjuder en uppsättning funktioner som täcker de flesta uppspelningsscenarier — från enkel filuppspelning till komplexa livesändningar med DRM. Låt oss undersöka nyckelfunktionerna med exempel på deras tillämpning.

HLS-stöd och adaptiv växling

AVPlayer har inbyggt stöd för HLS utan att ytterligare bibliotek behöver installeras. Vid uppspelning av en HLS-ström hanterar AVPlayer automatiskt adaptiv bitrate-växling med hjälp av den inbyggda ABR-algoritmen som är optimerad för Apple-plattformar. Algoritmen tar inte bara hänsyn till nätverkets bandbredd utan även enhetens termiska tillstånd — vid överhettning kan AVPlayer sänka bitraten för att minska processorbelastningen.

För HLS-strömmar med FairPlay Streaming hanterar AVPlayer automatiskt inhämtning och förnyelse av licenser via AVContentKeySession-delegaten. Utvecklaren måste implementera protokollet AVContentKeySessionDelegate, som anropas av spelaren när en dekrypteringsnyckel behöver hämtas eller förnyas. Detta är det enda sättet att skydda HLS-innehåll på Apple-plattformar eftersom Widevine inte stöds på iOS.

Picture in Picture

PiP — läge som låter användaren fortsätta titta på video i ett flytande fönster medan de växlar mellan appar. På iPad och iPhone (iOS 14+) integreras AVPlayer med AVPictureInPictureController för att aktivera detta läge. På macOS 15+ är PiP också tillgängligt men aktiveras via systemmenyn eller en knapp i spelarfönstret.

Hur man använder AVPlayer i iOS-applikationen

Integrering av AVPlayer i en iOS-applikation kan göras på två sätt: via den högnivåbaserade AVPlayerViewController (för typiska scenarier) eller direkt via AVPlayer + AVPlayerLayer (för fullständig anpassning av gränssnittet). Låt oss undersöka båda metoderna i Swift.

Integrering via AVPlayerViewController

AVPlayerViewController — en färdig UI-komponent som tillhandahåller inbyggda kontroller: play/paus, spola tillbaka, volym, AirPlay, PiP och helskärmsläge. Minimal integrering kräver bara några rader kod: skapa en AVPlayer-instans, skicka den till AVPlayerViewController och visa kontrollen på skärmen.

import AVKit

let url = URL(string: "https://example.com/video.mp4")!
let asset = AVAsset(url: url)
let playerItem = AVPlayerItem(asset: asset)
let player = AVPlayer(playerItem: playerItem)

let controller = AVPlayerViewController()
controller.player = player
controller.allowsPictureInPicturePlayback = true

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

Direkt integrering via AVPlayerLayer

För applikationer med anpassat gränssnitt, använd AVPlayerLayer — ett Core Animation-lager som renderar video inuti vilken UIView som helst. Denna metod ger full kontroll över gränssnittet: du kan lägga till egna kontroller, animationer och ytterligare lager ovanpå videon.

class VideoPlayerView: UIView {

    var player: AVPlayer? {
        get { (layer as! AVPlayerLayer).player }
        set { (layer as! AVPlayerLayer).player = newValue }
    }

    override class var layerClass: AnyClass {
        AVPlayerLayer.self
    }
}

// Användning:
let playerView = VideoPlayerView(frame: view.bounds)
playerView.player = AVPlayer(url: url)
view.addSubview(playerView)

Hantera AVPlayers livscykel

Korrekt hantering av spelarens livscykel är avgörande för applikationens stabilitet. AVPlayer bör skapas när skärmen visas och frigöras när den stängs. När applikationen går i bakgrunden rekommenderas det att pausa uppspelningen för att spara resurser och undvika App Review-påföljder för bakgrundsuppspelning utan uppenbart behov.

AVPlayerLayer och videovisning

AVPlayerLayer — är ett Core Animation-lager, som ärver från CALayer, som renderar video på skärmen. Till skillnad från UIView arbetar AVPlayerLayer direkt med GPU via Metal eller OpenGL, vilket ger minimal fördröjning av bildrutorna. Att förstå hur AVPlayerLayer fungerar är nödvändigt för att implementera anpassade uppspelningsgränssnitt.

Konfigurera videoGravity

Egenskapen videoGravity bestämmer hur videon passar inom lagrets gränser. AVLayerVideoGravity.resizeAspect (bibehåll bildförhållande med svarta kanter) — standardvärdet för AVPlayerViewController. resizeAspectFill (fyll hela skärmen med beskärning) används för helskärmsläge. resize (förvräng bildförhållande till lagrets storlek) används sällan, främst för analytiska applikationer.

Synkronisering med huvudtråden

AVPlayerLayer renderar video i realtid, men alla operationer på spelaren (start, paus, sök) måste utföras på huvudtråden. Nyckelvärdena att observera — timeControlStatus, rate, status och error — spåras via KVO (Key-Value Observing) eller det moderna async/await API som introducerades i iOS 16 via AVPlayer-metoder med Swift Concurrency-stöd.

let player = AVPlayer(url: url)
let statusObservation = player.observe(
    \.status,
    options: [.new, .initial]
) { player, _ in
    switch player.status {
    case .readyToPlay:
        player.play()
    case .failed:
        handleError(player.error)
    default:
        break
    }
}

Stöd för undertexter och alternativa spår

AVPlayer stöder inbyggda undertexter i formaten VTT, CEA-608 och ITT (iTunes Timed Text). Val av ljudspår och undertexter görs via AVMediaSelectionGroup och AVMediaSelectionOption. Användarens undertextinställningar (teckensnitt, storlek, färg) läses från systemets inställningar för tillgänglighet och tillämpas automatiskt på AVPlayerLayer om de inte uttryckligen anges i koden.

Hantera uppspelning och avancerade scenarier

För produktionsapplikationer kräver grundläggande AVPlayer-integration ofta ytterligare konfiguration: cachning av HLS-segment, arbete med FairPlay DRM, integration med “Now Playing”-systemet och implementering av anpassade bitratevalsalgoritmer.

Cachning av HLS via AVAssetResourceLoader

AVAssetResourceLoader — är det enda sättet att fånga inläsningen av HLS-segment och implementera cachning. AVAssetResourceLoaderDelegate-delegaten tar emot förfrågningar om inläsning av nycklar och segment, vilket gör det möjligt att spara dem lokalt och returnera från cache vid upprepade förfrågningar. Detta är särskilt användbart för applikationer som arbetar under ostabila nätverksförhållanden.

let asset = AVURLAsset(url: hlsURL)
asset.resourceLoader.setDelegate(
    resourceLoaderDelegate,
    queue: DispatchQueue(label: "com.app.resourceloader")
)
let playerItem = AVPlayerItem(asset: asset)

FairPlay Streaming — DRM-integration

FairPlay Streaming (FPS) — Apples standard för att skydda HLS-innehåll. För FPS-integration måste protokollet AVContentKeySessionDelegate implementeras, som hanterar förfrågningar om att få dekrypteringsnycklar. Processen omfattar: att få SPC (Server Playback Context) från spelaren, skicka till licenseservern, ta emot CKC (Content Key Context) och skicka tillbaka till AVContentKeySession.

class DRMDelegate: NSObject, AVContentKeySessionDelegate {

    func contentKeySession(
        _ session: AVContentKeySession,
        didProvide keyRequest: AVContentKeyRequest
    ) {
        // 1. Hämta SPC från keyRequest
        // 2. Skicka SPC till licenseservern
        // 3. Hämta CKC och skicka till keyRequest.processContentKeyResponse
    }
}

Now Playing och systemkontroller

För att visa information om aktuell uppspelning på låsskärmen, Kontrollcenter och Apple Watch används MPNowPlayingInfoCenter från MediaPlayer.framework. AVPlayer uppdaterar inte Now Playing automatiskt — utvecklaren måste manuellt ställa in metadata (titel, artist, omslag, förlopp) när uppspelningsstatus ändras. För att uppdatera förloppet används en regelbunden timer eller observe(\.timeControlStatus).

Remote Command Center — ytterligare en systemtjänst som gör att uppspelningen kan styras från låsskärmen, AirPods och CarPlay. MPRemoteCommandCenter registrerar hanterare för kommandona play, paus, nextTrack, previousTrack, changePlaybackPosition och skipForward/skipBackward. AVPlayer bearbetar inte dessa kommandon automatiskt — utvecklaren måste koppla dem till anropen player.play(), player.pause() och player.seek().