ExoPlayer: o que é, recursos e configuração

O que é ExoPlayer?

ExoPlayer é uma biblioteca de reprodução multimídia de código aberto (Apache 2.0) para Android, cuja primeira versão foi lançada pelo Google em 2014. Ao contrário do MediaPlayer integrado, que é uma camada fina sobre o codec de mídia do sistema (MediaCodec), o ExoPlayer é implementado inteiramente no nível Java/Kotlin, dando aos desenvolvedores controle total sobre cada etapa da reprodução.

Arquiteturalmente, o ExoPlayer é construído sobre um princípio modular: cada aspecto da reprodução é implementado por um componente separado. O módulo principal (exoplayer-core) contém o player, renderizadores, seletores de faixa e gerenciamento de buffer. Módulos adicionais (exoplayer-dash, exoplayer-hls, exoplayer-rtsp, exoplayer-smoothstreaming) adicionam suporte para os protocolos de streaming correspondentes. Esta arquitetura permite que os aplicativos incluam apenas os componentes necessários, minimizando o tamanho do APK.

ExoPlayer 2 (a versão principal atual) foi lançado em 2018 e trouxe uma reformulação radical da API: introdução da interface Player, suporte a Compose através do AndroidX Media3, tratamento de erros melhorado e algoritmos adaptativos de seleção de faixas. A partir da versão 2.19 (2024), o ExoPlayer tornou-se parte da biblioteca AndroidX Media, simplificando a integração e atualizações através do gerenciador de dependências padrão do Android.

Arquitetura do ExoPlayer

No núcleo do ExoPlayer está o componente ExoPlayerImpl, que gerencia o ciclo de vida da reprodução. Ele contém MediaSource (fonte de mídia), TrackSelector (seleção de faixas), LoadControl (gerenciamento de buffer) e uma lista de Renderer (renderizadores para vídeo, áudio, legendas e metadados). Cada componente pode ser substituído por uma implementação personalizada através do Builder ou métodos de fábrica.

Para renderização de vídeo, o ExoPlayer usa SurfaceView, TextureView ou SphericalSurfaceView (para vídeo de 360 graus). A opção recomendada é SurfaceView, pois fornece aceleração de hardware e consumo mínimo de energia. Para Jetpack Compose, a biblioteca AndroidX Media3 fornece o componente `AndroidView`, que envolve SurfaceView, e o experimental `Media3Compose` com integração nativa do Compose.

Recursos do ExoPlayer

ExoPlayer oferece uma ampla gama de recursos além de um player de mídia comum. As principais capacidades incluem suporte para todos os protocolos de streaming populares, um sistema DRM flexível, comutação adaptativa de taxa de bits (ABR) e ferramentas de análise de reprodução.

Comutação adaptativa de taxa de bits

ABR (Adaptive Bitrate) no ExoPlayer é implementado através da interface AdaptiveTrackSelection. Por padrão, é usado AdaptiveTrackSelectionFactory, que cria DefaultAdaptiveTrackSelection — um algoritmo equilibrado que leva em conta a largura de banda da rede e o tamanho do buffer. Para cenários específicos, implementações alternativas podem ser conectadas: BOLA (minimização de comutações), RandomAdaptiveTrackSelection (testes) ou uma implementação personalizada através da interface TrackSelection.

BandwidthMeter — outro componente chave responsável por medir a largura de banda da rede. Por padrão, é usado DefaultBandwidthMeter, que coleta estatísticas de todas as solicitações HTTP do player. O desenvolvedor pode estendê-lo para considerar fatores adicionais: tipo de rede (Wi-Fi, 4G, 5G), sinal de torre de celular ou custo de dados para o usuário.

DRM e proteção de conteúdo

ExoPlayer suporta Widevine (L1, L3), PlayReady e ClearKey DRM. A obtenção de licença é configurada através do DrmSessionManager, que interage com o servidor de licenças. Para vídeo premium (4K HDR), é necessário suporte de hardware Widevine L1, que fornece proteção em nível de chip e impede captura de tela. A escolha do sistema DRM depende da plataforma alvo: Widevine é usado no Android e Chromecast, PlayReady no Xbox e Windows, FairPlay no iOS e Apple TV. O ExoPlayer determina automaticamente o sistema DRM disponível com base no arquivo MPD e não requer configuração manual para cenários básicos.

Como integrar ExoPlayer em um projeto Android

A conexão do ExoPlayer a um projeto Android é feita através de dependências Gradle. A partir da versão 2.19, o ExoPlayer faz parte do AndroidX Media (androidx.media3), garantindo compatibilidade com Jetpack Compose e outros componentes AndroidX. Vamos ver uma integração passo a passo em Kotlin.

Adicionando dependências

Adicione os módulos ExoPlayer ao arquivo build.gradle (Module). O conjunto mínimo inclui core, ui e o módulo para o protocolo de streaming necessário. Para reprodução de conteúdo DASH, é necessário exoplayer-dash, para 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"
}

Integração básica em Activity

Criação e configuração do player em uma Activity ou Fragment. O ExoPlayer usa PlayerView (ou StyledPlayerView para personalização) para exibir vídeo e controles integrados. A configuração mínima inclui criar o player através de ExoPlayer.Builder e passar um MediaItem com a URI de origem.

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()
    }
}

Tratamento de erros e estados

Para aplicações de produção, é necessário o tratamento de possíveis erros de reprodução: falhas de rede, formatos não suportados, erros de licenciamento DRM. O ExoPlayer fornece a interface Player.Listener com métodos onPlayerError, onPlaybackStateChanged e onPlayWhenReadyChanged. Recomenda-se exibir ao usuário mensagens de erro informativas com opção de repetição.

ExoPlayer vs MediaPlayer: comparação

Escolher entre ExoPlayer e o MediaPlayer integrado é uma pergunta comum ao desenvolver aplicativos Android. O MediaPlayer faz parte do Android SDK desde a versão 1.0, enquanto o ExoPlayer é uma biblioteca que requer dependência Gradle. Vamos ver suas diferenças por critérios-chave.

ExoPlayer vence em cenários que exigem streaming (DASH, HLS), personalização de UI, suporte DRM e independência da versão do Android. MediaPlayer é adequado para aplicativos simples que reproduzem arquivos de mídia locais onde o tamanho do APK é crítico e não há requisitos de streaming adaptativo. Para aplicativos modernos com conteúdo da rede, o ExoPlayer é a escolha clara.

Exceção — aplicativos com SDK mínimo abaixo de API 16 (Android 4.1), que praticamente não existem no mercado. Para todos os aplicativos com targetSdk 33+ e SDK mínimo 21+, o ExoPlayer não é apenas preferível, mas necessário para suportar formatos modernos como AV1 e Dolby Vision através das extensões apropriadas.

Configuração avançada do ExoPlayer

Para aplicações de produção, a integração básica do ExoPlayer frequentemente requer configuração adicional: gerenciamento de cache, otimização de buffer para redes móveis, integração com análise e personalização da seleção de faixas de áudio. Vamos ver cenários de uso avançados.

Cache de conteúdo

CacheDataSourceFactory permite armazenar em cache segmentos baixados no armazenamento local, economizando tráfego em visualizações repetidas e permitindo reprodução offline. O ExoPlayer usa SimpleCache da biblioteca exoplayer-cas — cache baseado em arquivos com suporte a evicção LRU e limites de tamanho.

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()

Tratamento de comutação de rede

Em aplicativos móveis, o tratamento da comutação entre Wi-Fi e rede celular é crítico. O ExoPlayer fornece ConnectivityManager para rastrear o estado da rede. Ao perder a conexão, recomenda-se não parar o player, mas colocá-lo no estado PAUSED preservando a posição. Após restaurar a conexão, retome a reprodução recarregando os segmentos.

Integração com Jetpack Compose

Com o lançamento do AndroidX Media3, a biblioteca obteve suporte experimental para Jetpack Compose. O componente `AndroidView` envolve SurfaceView ou PlayerView, garantindo compatibilidade com a hierarquia do Compose. Para integração mais profunda, a biblioteca `androidx.media3:media3-ui-compose` é usada, fornecendo controles de player compatíveis com Compose.

@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 } }
    )
}