ExoPlayer: vad är det, funktioner och konfiguration

Vad är ExoPlayer?

ExoPlayer är ett bibliotek för multimediauppspelning på Android med öppen källkod (Apache 2.0), vars första version släpptes av Google 2014. Till skillnad från den inbyggda MediaPlayer, som är ett tunt lager ovanför systemets mediacodec (MediaCodec), är ExoPlayer helt implementerad på Java/Kotlin-nivå, vilket ger utvecklare full kontroll över varje steg i uppspelningen.

Arkitekturmässigt är ExoPlayer byggd på modulär princip: varje aspekt av uppspelningen implementeras av en separat komponent. Huvudmodulen (exoplayer-core) innehåller spelaren, renderare, spårväljare och buffert hantering. Ytterligare moduler (exoplayer-dash, exoplayer-hls, exoplayer-rtsp, exoplayer-smoothstreaming) lägger till stöd för respektive streamingprotokoll. Denna arkitektur gör att appar endast kan ansluta nödvändiga komponenter, vilket minimerar APK-storleken.

ExoPlayer 2 (nuvarande huvudversion) släpptes 2018 och medförde en genomgripande omarbetning av API:et: introduktion av Player Interface, stöd för Compose via AndroidX Media3, förbättrad felhantering och adaptiva algoritmer för spårval. Från och med version 2.19 (2024) blev ExoPlayer en del av AndroidX Media-biblioteket, vilket förenklade integration och uppdatering via den standardiserade Android-beroendehanteraren.

ExoPlayers arkitektur

I hjärtat av ExoPlayer finns komponenten ExoPlayerImpl, som hanterar uppspelningens livscykel. Den innehåller MediaSource (mediakälla), TrackSelector (spårval), LoadControl (buffert hantering) och en lista med Renderer (renderare för video, ljud, undertexter och metadata). Varje komponent kan ersättas med en egen implementering via Builder eller fabriksmetoder.

För videorendering använder ExoPlayer SurfaceView, TextureView eller SphericalSurfaceView (för 360-gradersvideo). Det rekommenderade alternativet är SurfaceView eftersom det ger hårdvaruacceleration och minimal energiförbrukning. För Jetpack Compose tillhandahåller AndroidX Media3-biblioteket komponenten `AndroidView`, som omsluter SurfaceView, och experimentella `Media3Compose` med inbyggd Compose-integration.

ExoPlayers funktioner

ExoPlayer erbjuder en bred uppsättning funktioner som går utöver en vanlig mediaspelare. Huvudfunktionerna inkluderar stöd för alla populära streamingprotokoll, ett flexibelt DRM-system, adaptiv bitrate-växling (ABR) och analysverktyg för uppspelning.

Adaptiv bitrate-växling

ABR (Adaptive Bitrate) i ExoPlayer är implementerad via gränssnittet AdaptiveTrackSelection. Som standard används AdaptiveTrackSelectionFactory, som skapar DefaultAdaptiveTrackSelection — en balanserad algoritm som tar hänsyn till nätverksbandbredd och buffertstorlek. För specifika scenarier kan alternativa implementeringar anslutas: BOLA (minimering av växlingar), RandomAdaptiveTrackSelection (testning) eller en egen implementering via gränssnittet TrackSelection.

BandwidthMeter är en annan nyckelkomponent som ansvarar för att mäta nätverksbandbredd. Som standard används DefaultBandwidthMeter, som samlar in statistik från alla HTTP-förfrågningar från spelaren. Utvecklaren kan utöka den för att ta hänsyn till ytterligare faktorer: nätverkstyp (Wi-Fi, 4G, 5G), signal från mobiltorn eller trafikkostnad för användaren.

DRM och innehållsskydd

ExoPlayer stöder Widevine (L1, L3), PlayReady och ClearKey DRM. Licensanskaffning konfigureras via DrmSessionManager, som interagerar med licensservern. För premiumvideo (4K HDR) krävs hårdvarustöd för Widevine L1, vilket ger skydd på chipt nivå och förhindrar skärminsamling. Valet av DRM-system beror på målplattformen: Widevine används på Android och Chromecast, PlayReady på Xbox och Windows, FairPlay på iOS och Apple TV. ExoPlayer bestämmer automatiskt tillgängligt DRM-system baserat på MPD-filen och kräver ingen manuell konfiguration för grundläggande scenarier.

Hur man integrerar ExoPlayer i ett Android-projekt

Anslutning av ExoPlayer till ett Android-projekt görs via Gradle-beroenden. Från och med version 2.19 är ExoPlayer en del av AndroidX Media (androidx.media3), vilket säkerställer kompatibilitet med Jetpack Compose och andra AndroidX-komponenter. Låt oss titta på steg-för-steg-integration i Kotlin.

Lägga till beroenden

Lägg till ExoPlayer-moduler i filen build.gradle (Module). Minimisatsen inkluderar core, ui och modulen för det erforderliga streamingprotokollet. För uppspelning av DASH-innehåll krävs exoplayer-dash, för HLS — exoplayer-hls.

dependencies {
    implementation "androidx.media3:media3-exoplayer:1.5.0"
    implementation "androidx.media3:media3-ui:1.5.0"
    implementation "androidx.media3:media3-exoplayer-dash:1.5.0"
    implementation "androidx.media3:media3-exoplayer-hls:1.5.0"
}

Grundläggande integration i Activity

Skapa och konfigurera spelaren i Activity eller Fragment. ExoPlayer använder PlayerView (eller StyledPlayerView för anpassning) för att visa video och inbyggda kontroller. Minimikonfigurationen inkluderar att skapa spelaren via ExoPlayer.Builder och skicka en MediaItem med källans URI.

class PlayerActivity : AppCompatActivity() {

    private var player: ExoPlayer? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_player)

        player = ExoPlayer.Builder(this).build()
        val playerView = findViewById<StyledPlayerView>(R.id.playerView)
        playerView.player = player

        val mediaItem = MediaItem
            .Builder()
            .setUri("https://example.com/video.mp4")
            .build()
        player?.setMediaItem(mediaItem)
        player?.prepare()
    }

    override fun onDestroy() {
        player?.release()
        super.onDestroy()
    }
}

Fel- och tillståndshantering

För produktionsappar är hantering av möjliga uppspelningsfel nödvändig: nätverksfel, ej stödda format, DRM-licensfel. ExoPlayer tillhandahåller gränssnittet Player.Listener med metoderna onPlayerError, onPlaybackStateChanged och onPlayWhenReadyChanged. Det rekommenderas att visa informativa felmeddelanden med möjlighet att försöka igen.

ExoPlayer vs MediaPlayer: jämförelse

Valet mellan ExoPlayer och den inbyggda MediaPlayer är en vanlig fråga vid utveckling av Android-appar. MediaPlayer har varit en del av Android SDK sedan version 1.0, medan ExoPlayer är ett bibliotek som kräver anslutning via Gradle. Låt oss titta på deras skillnader baserat på viktiga kriterier.

ExoPlayer vinner i scenarier som kräver streaming (DASH, HLS), UI-anpassning, DRM-stöd och oberoende av Android-version. MediaPlayer är lämplig för enkla appar som spelar upp lokala mediafiler, där APK-storleken är kritisk och det inte finns några krav på adaptiv streaming. För moderna appar med innehåll från nätet är ExoPlayer det självklara valet.

Undantag — appar med minimal SDK lägre än API 16 (Android 4.1), som praktiskt taget inte längre finns på marknaden. För alla appar med targetSdk 33+ och minimal SDK 21+ är ExoPlayer inte bara att föredra, utan nödvändig för stöd av moderna format som AV1 och Dolby Vision via lämpliga tillägg.

Avancerad konfiguration av ExoPlayer

För produktionsappar kräver grundintegrationen av ExoPlayer ofta ytterligare konfiguration: cachehantering, optimering av buffring för mobila nätverk, integration med analysverktyg och anpassning av ljudspårsval. Låt oss titta på avancerade användningsscenarier.

Cache av innehåll

CacheDataSourceFactory gör det möjligt att cachelagra nedladdade segment i lokal lagring, vilket sparar trafik vid upprepad visning och möjliggör offlineuppspelning. ExoPlayer använder SimpleCache från biblioteket exoplayer-cas — filcachelagring med stöd för LRU-utrymning och storleksbegränsningar.

val cache = SimpleCache(
    cacheDir,
    LeastRecentlyUsedCacheEvictor(50 * 1024 * 1024),
    AppDatabaseProvider(this)
)

val cacheDataSourceFactory = CacheDataSource
    .Factory()
    .setCache(cache)

val player = ExoPlayer.Builder(this)
    .setMediaSourceFactory(
        DefaultMediaSourceFactory(cacheDataSourceFactory)
    )
    .build()

Hantering av nätverksväxling

I mobila appar är hantering av växling mellan Wi-Fi och mobilnät avgörande. ExoPlayer tillhandahåller ConnectivityManager för att övervaka nätverksstatus. Vid förlust av anslutning rekommenderas att inte stoppa spelaren, utan att övergå till PAUSED-tillstånd med bibehållen position. Efter återställning av anslutningen, återuppta uppspelningen med omladdning av segment.

Integration med Jetpack Compose

Med lanseringen av AndroidX Media3 fick biblioteket experimentellt stöd för Jetpack Compose. Komponenten `AndroidView` omsluter SurfaceView eller PlayerView och säkerställer kompatibilitet med Compose-hierarkin. För djupare integration används biblioteket `androidx.media3:media3-ui-compose`, som tillhandahåller Compose-kompatibla spelarkontroller.

@Composable
fun VideoPlayer(uri: String) {
    val context = LocalContext.current
    val player = remember {
        ExoPlayer.Builder(context).build()
            .also { it.setMediaItem(MediaItem.fromUri(uri)) }
    }

    DisposableEffect(key = null) {
        player.prepare()
        onDispose { player.release() }
    }

    AndroidView(
        factory = { StyledPlayerView(context).also { it.player = player } }
    )
}