Blog

Fazendo o expo-video funcionar em um feed estilo TikTok

10 de janeiro de 2026 11 min de leitura

Como fiz o expo-video funcionar bem em um feed estilo TikTok: separar a criação do player da reprodução e tratar feed, hero, linhas e telas de resultado como superfícies diferentes.

Fazendo o expo-video funcionar em um feed estilo TikTok
ExpoReact Nativeexpo-videoPerformanceVídeo

Construindo um feed de vídeo fluido estilo TikTok com expo-video

O expo-video é fácil quando existe só um player na tela.

Fica mais difícil quando o mesmo app tem um vídeo de hero, um feed vertical, linhas horizontais e uma tela de resultado com controles de verdade.

Esse era o meu cenário, e o problema não era bem "como eu toco um vídeo no Expo?".

O problema real era que eu tinha superfícies de vídeo diferentes demais e estava tratando todas como se fossem a mesma coisa.

Esse foi o erro.

Algumas superfícies devem criar um player cedo. Algumas só devem tocar quando estão em foco. Algumas devem ficar só com a thumbnail até o usuário chegar perto. Algumas precisam de um caminho de fallback se a reprodução remota travar.

Este artigo existe porque a correção não foi uma prop mágica. A correção foi definir uma política de reprodução.

Por que isso vira bagunça rápido

Antes de qualquer coisa, dividi o problema em quatro decisões:

  • esta superfície deve criar um player?
  • este player deve estar tocando agora?
  • quão caro este player deve ser?
  • o que o usuário deve ver antes do primeiro frame?

Quando essas decisões ficaram separadas, o resto da arquitetura ficou muito mais fácil de entender.

Mantenha o expo-video atrás de um wrapper

Antes de otimizar qualquer coisa, encapsulei o expo-video em um wrapper.

Eu não queria configurações de buffer, comportamento de fullscreen, tipo de superfície e setup do player espalhados pelo app. Um wrapper bastava para manter essas escolhas em um só lugar.

A documentação oficial está aqui: documentação do expo-video.

export type AndroidBufferProfile =
  | "detail"
  | "preview"
  | "feed-active"
  | "feed-adjacent";

const ANDROID_BUFFER_PROFILES: Record<
  AndroidBufferProfile,
  BufferOptions
> = {
  detail: {
    preferredForwardBufferDuration: 1.75,
    minBufferForPlayback: 0.35,
    prioritizeTimeOverSizeThreshold: true,
  },
  preview: {
    preferredForwardBufferDuration: 1.1,
    minBufferForPlayback: 0.2,
    prioritizeTimeOverSizeThreshold: true,
  },
  "feed-active": {
    preferredForwardBufferDuration: 2.5,
    minBufferForPlayback: 0.4,
    prioritizeTimeOverSizeThreshold: true,
  },
  "feed-adjacent": {
    preferredForwardBufferDuration: 0.6,
    minBufferForPlayback: 0.15,
    prioritizeTimeOverSizeThreshold: true,
  },
};

Esse wrapper não faz nada de mágico. Ele só me dá um lugar para definir:

  • player de detalhe
  • player de preview
  • player ativo do feed
  • player adjacente do feed

Os perfis do Android importam, mas são só uma parte do setup. Os maiores ganhos vieram de controlar quando os players existem e quando eles podem tocar.

Criar um player não é o mesmo que tocá-lo

Essa foi a mudança de mentalidade mais importante.

Na tela do feed, parei de tratar a criação do player e a reprodução como a mesma coisa.

const shouldCreatePlayer =
  isTransitionFinished &&
  (isActive || isAdjacent) &&
  !!videoUrl;

const shouldPlay =
  isActive &&
  isAppInForeground &&
  isScreenFocused;

Esses dois booleanos resolvem problemas diferentes.

  • shouldCreatePlayer responde se a superfície merece ter um player
  • shouldPlay responde se esse player deve estar rodando agora

Essa distinção importa muito em um feed.

Se você pula essa etapa, geralmente acaba com players demais, buffering demais e muito trabalho inútil.

Estados ativo e adjacente no feed vertical

No feed principal, só crio players para o item ativo e para os itens adjacentes.

Isso faz o card ativo parecer instantâneo sem pagar o preço cheio pela lista inteira.

const videoSource = useMemo(() => {
  if (!shouldCreatePlayer || !videoUrl) return null;

  return {
    uri: videoUrl,
    useCaching: Platform.OS !== "ios",
  };
}, [shouldCreatePlayer, videoUrl]);

const player = useAppVideoPlayer(videoSource, {
  loop: true,
  muted: true,
  androidBufferProfile: isActive
    ? "feed-active"
    : "feed-adjacent",
});

O card ativo recebe o perfil mais generoso.

O card adjacente recebe um mais barato, porque talvez ele nunca se torne o principal.

Mas a parte mais importante continua sendo a regra de reprodução, não a regra de buffer.

Eu coloco os itens não ativos no mudo e pauso imediatamente:

useEffect(() => {
  if (!player) return;

  if (shouldPlay) {
    player.muted = false;
    player.play();
  } else {
    player.muted = true;
    player.pause();
  }
}, [player, shouldPlay]);

Essa parte é multiplataforma. É ela a mudança real de comportamento.

Nas superfícies de preview, também mantive o useCaching desativado no iOS. Isso não é uma regra universal do expo-video. Foi uma decisão para este app, porque o cache de preview foi mais estável para mim no Android do que no iOS.

Renderizar a thumbnail primeiro é inegociável

Se uma célula do feed mostra um retângulo preto enquanto o player está aquecendo, ela já parece quebrada.

Então sempre mantenho a thumbnail como camada base e só revelo o player depois do primeiro frame renderizado.

<AppVideoView
  player={player}
  contentFit="cover"
  nativeControls={false}
  pointerEvents="none"
  style={[
    StyleSheet.absoluteFill,
    { opacity: hasFirstFrame ? 1 : 0 },
  ]}
  androidSurfaceType="textureView"
  onFirstFrameRender={() => setHasFirstFrame(true)}
/>

Esse pequeno controle de opacidade faz uma diferença enorme.

O vídeo não precisa aparecer instantaneamente. Ele só precisa substituir a thumbnail de forma limpa.

A parte importante nesse trecho é a passagem no primeiro frame. A linha do textureView é só um detalhe de renderização específico do Android.

Ajustes por plataforma: bufferOptions e surfaceType

Esta parte precisa de um pouco mais de precisão.

O expo-video expõe bufferOptions multiplataforma, mas alguns dos campos dentro desse objeto são específicos de cada plataforma.

Na prática, isso significa:

  • bufferOptions como API existe tanto no Android quanto no iOS
  • campos como minBufferForPlayback e prioritizeTimeOverSizeThreshold são os ajustes focados em Android que usei aqui
  • waitsToMinimizeStalling é uma configuração de buffer específica do iOS na mesma API
  • surfaceType é só para Android

Foi isso que me permitiu diferenciar entre:

  • cards ativos do feed
  • cards adjacentes do feed
  • players de detalhe
  • players de preview

É também por isso que usei textureView explicitamente nos lugares em que views de vídeo sobrepostas ou transições em camadas importavam.

A documentação do Expo até cita surfaceType="textureView" como solução alternativa para problemas de VideoView sobrepostas no Android.

Então, quando eu mostro um código como este:

const player = useAppVideoPlayer(videoSource, {
  loop: true,
  muted: true,
  androidBufferProfile: isActive
    ? "feed-active"
    : "feed-adjacent",
});

essa seção trata, na verdade, de ajustar o custo de reprodução no Android, e não da solução inteira.

A solução completa continua sendo a política de ciclo de vida em torno de criar, tocar, pausar, colocar no mudo e fazer fallback.

Linhas horizontais precisam de um orçamento de reprodução

O feed não era a única superfície de vídeo do app.

Eu também tinha linhas horizontais na tela inicial, e essas linhas não podem se comportar como o TikTok. Se todo card visível de toda linha visível ganhar um player, você queima memória demais em uma superfície que não precisa disso.

Então adicionei um orçamento de reprodução por linha.

const remainingSlots = heroVisible ? 3 : 4;
const rowBudget = Math.min(2, remainingSlots);

const shouldPlayCard =
  isRowVisible &&
  isCardVisibleHorizontally &&
  cardIndex < rowBudget;

Isso me deu uma regra simples:

  • só os primeiros cards elegíveis das linhas visíveis ganham players
  • todo o resto fica só com a thumbnail

Também atrasei um pouco o unmount quando um card deixa de ser elegível, para que mudanças rápidas de limite não fiquem criando e destruindo players de forma agressiva.

useEffect(() => {
  if (shouldPlay) {
    setShouldRenderVideo(true);
    return;
  }

  const timeout = setTimeout(() => {
    setShouldRenderVideo(false);
  }, 180);

  return () => clearTimeout(timeout);
}, [shouldPlay]);

Isso deixou as linhas horizontais bem mais baratas que o feed em tela cheia.

O hero não deve se comportar como o feed

O hero tinha um problema diferente.

Eu queria que o carrossel parecesse interativo e, ao mesmo tempo, mostrasse vídeo quando estivesse parado.

A solução foi:

  • deslizar as thumbnails durante o gesto
  • mostrar o vídeo ativo como um overlay separado
  • fazer o overlay de vídeo sumir com fade enquanto o usuário arrasta
  • só tocar quando o hero está visível, a tela está ativa e o gesto terminou
const shouldPlayHero =
  isScreenActive &&
  isHeroVisible &&
  isSettled &&
  !!activeVideoUrl;

Isso funcionou melhor do que tentar manter cada slide do hero como um player ao vivo.

A tela de resultado precisa de outro player

Não usei o mesmo componente de player em todo lugar.

Cards de preview em loop e no mudo e uma tela de resultado completa não são o mesmo problema.

A tela de resultado usa um VideoPlayer compartilhado com:

  • controles de reprodução
  • listeners de playingChange
  • listeners de timeUpdate
  • listeners de statusChange
  • suporte a fullscreen no iOS
  • reprodução remota primeiro, com fallback local

Se você está usando esses eventos, a documentação relevante do Expo é:

O uso é simples:

<VideoPlayer
  uri={videoUrl}
  controlsVariant="playback"
  muted={false}
  loop={false}
  androidBufferProfile="detail"
  iosAllowFullscreen
  fallbackToLocal
  fallbackTimeoutMs={8000}
/>

A lógica de fallback é direta.

Se o player fica tempo demais carregando antes do primeiro carregamento bem-sucedido, ou se ele entra em um estado de erro, eu baixo o MP4 para o diretório de cache e troco a source.

if (
  fallbackToLocal &&
  !fallbackApplied.current &&
  !hasLoadedOnce.current
) {
  fallbackTimer.current = setTimeout(() => {
    startLocalFallback();
  }, fallbackTimeoutMs);
}

if (status === "error" && fallbackToLocal) {
  startLocalFallback();
}

Isso não é sobre micro-otimização. É sobre deixar a tela de resultado confiável.

Se um resultado finalizado abre e a reprodução trava, a funcionalidade inteira parece quebrada.

O que realmente importou

Se eu tivesse que resumir o setup inteiro em algumas regras práticas, seriam estas:

  • mantenha o expo-video atrás de um wrapper
  • separe a criação do player da reprodução
  • trate feed, linhas, hero e telas de resultado como superfícies diferentes
  • use thumbnails primeiro por padrão
  • condicione a reprodução ao foco e ao estado de primeiro plano
  • use os perfis de buffer do Android como um detalhe, não como a estratégia inteira
  • adicione um caminho de fallback para as superfícies de reprodução importantes

Esse último ponto importa.

Este artigo não é, na verdade, sobre uma flag de buffer do Android.

O ganho maior foi decidir:

  • onde um player deve existir
  • quando ele deve tocar
  • quando ele deve ficar no mudo
  • quando uma thumbnail é o melhor padrão
  • quais superfícies merecem um caminho de recuperação

Quando aceitei isso, a arquitetura ficou muito mais limpa.

Resultado final

Assim ficou o feed depois de separar a criação do player da reprodução e manter o item ativo como a única prioridade real:

Considerações finais

O expo-video em si não foi a parte difícil aqui.

A parte difícil foi ser honesto sobre quantas superfícies de vídeo diferentes o app realmente tinha.

Quando parei de tratar todas do mesmo jeito, o feed passou a parecer muito melhor.

E, para dar algum crédito ao expo-video, quando a política de reprodução ficou clara, a biblioteca fez muito bem o seu trabalho.

Ter useVideoPlayer e VideoView em um único caminho de código multiplataforma permitiu manter a arquitetura quase toda compartilhada, e só ramificar onde as plataformas realmente diferem, como em bufferOptions no Android, surfaceType no Android ou o comportamento de fullscreen no iOS.

Se você está construindo uma UI estilo feed com expo-video, é por aí que eu começaria.