# Fazendo o expo-video funcionar em um feed estilo TikTok

By Tarik Pinarci (https://tarikpinarci.com). Published 2026-01-10. Canonical: https://tarikpinarci.com/pt/blog/making-expo-video-work-in-feed-style-uis

# 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](https://docs.expo.dev/versions/latest/sdk/video/).

```tsx
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.

```tsx
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.

```tsx
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:

```tsx
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.

```tsx
<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`](https://docs.expo.dev/versions/latest/sdk/video/#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`](https://docs.expo.dev/versions/latest/sdk/video/#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:

```tsx
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.

```tsx
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.

```tsx
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

```tsx
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 é:

- [visão geral dos eventos `playingChange` e `statusChange`](https://docs.expo.dev/versions/latest/sdk/video/)
- [`timeUpdateEventInterval`](https://docs.expo.dev/versions/latest/sdk/video/#timeupdateeventinterval)

O uso é simples:

```tsx
<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.

```tsx
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:

<div style="display:flex; justify-content:center; margin: 24px 0 32px;">
  <video
    controls
    playsinline
    muted
    loop
    data-autoplay="viewport"
    preload="none"
    poster="/images/blog/expo-video-feed-demo-poster.jpg"
    style="width:100%; max-width:360px; border-radius:24px; box-shadow:0 24px 60px rgba(0,0,0,0.35); background:#000;"
    src="/videos/blog/expo-video-feed/01-vertical-feed-final-demo.mp4"
  >
    Seu navegador não suporta a tag de vídeo.
  </video>
</div>

## 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`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions) no Android, [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#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.

