Blog

Cómo hacer que expo-video funcione en un feed estilo TikTok

10 de enero de 2026 11 min de lectura

Cómo conseguí que expo-video funcionara bien en un feed estilo TikTok: separar la creación del reproductor de la reproducción y tratar el feed, el destacado, las filas y la pantalla de resultado como superficies distintas.

Cómo hacer que expo-video funcione en un feed estilo TikTok
ExpoReact Nativeexpo-videoRendimientoVideo

Cómo construir un feed de video fluido estilo TikTok con expo-video

expo-video es fácil cuando solo hay un reproductor en pantalla.

Se complica cuando la misma app tiene un video destacado, un feed vertical, filas horizontales y una pantalla de resultado con controles reales.

Esa era mi configuración, y el problema no era realmente "¿cómo reproduzco un video en Expo?".

El problema real era que tenía demasiadas superficies de video distintas y las estaba tratando como si fueran lo mismo.

Ese fue el error.

Algunas superficies deben crear un reproductor pronto. Otras solo deben reproducir cuando tienen el foco. Otras deben quedarse solo con la miniatura hasta que el usuario se acerque. Otras necesitan un camino alternativo si la reproducción remota se atasca.

Este artículo existe porque la solución no fue una prop mágica. La solución fue definir una política de reproducción.

Por qué esto se complica rápido

Antes que nada, dividí el problema en cuatro decisiones:

  • ¿debe esta superficie crear un reproductor?
  • ¿debe este reproductor estar reproduciendo ahora mismo?
  • ¿cuánto debe costar este reproductor?
  • ¿qué debe ver el usuario antes del primer fotograma?

Una vez separadas esas decisiones, el resto de la arquitectura se volvió mucho más fácil de razonar.

Mantén expo-video detrás de un wrapper

Antes de optimizar nada, envolví expo-video.

No quería la configuración del buffer, el comportamiento a pantalla completa, el tipo de superficie y la configuración del reproductor dispersos por la app. Un wrapper bastaba para mantener esas decisiones en un solo lugar.

La documentación oficial está aquí: documentación de 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,
  },
};

Ese wrapper no hace nada mágico. Solo me da un lugar donde definir:

  • reproductor de detalle
  • reproductor de vista previa
  • reproductor activo del feed
  • reproductor adyacente del feed

Los perfiles de Android importan, pero son solo una parte de la configuración. Las mayores ganancias vinieron de controlar cuándo existen los reproductores y cuándo se les permite reproducir.

Crear un reproductor no es lo mismo que reproducirlo

Este fue el cambio mental más importante.

En la pantalla del feed, dejé de tratar la creación del reproductor y la reproducción como si fueran lo mismo.

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

const shouldPlay =
  isActive &&
  isAppInForeground &&
  isScreenFocused;

Esos dos booleanos resuelven problemas distintos.

  • shouldCreatePlayer responde si la superficie merece siquiera un reproductor
  • shouldPlay responde si ese reproductor debe estar en marcha ahora mismo

Esa distinción importa mucho en un feed.

Si te la saltas, normalmente acabas con demasiados reproductores, demasiado buffering y mucho trabajo inútil.

Estados activo y adyacente en el feed vertical

En el feed principal, solo creo reproductores para el elemento activo y sus elementos adyacentes.

Así la tarjeta activa se siente instantánea sin pagar el precio completo por toda la lista.

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",
});

La tarjeta activa recibe el perfil más generoso.

La tarjeta adyacente recibe uno más barato porque puede que nunca llegue a ser la principal.

Pero la parte más importante sigue siendo la regla de reproducción, no la del buffer.

Silencio y pauso los elementos no activos de inmediato:

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

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

Esa parte es multiplataforma. Es el cambio de comportamiento real.

En las superficies de vista previa también mantuve useCaching desactivado en iOS. No es una regla universal de expo-video. Fue una decisión para esta app, porque la caché de las vistas previas era más estable para mí en Android que en iOS.

Renderizar primero la miniatura no es negociable

Si una celda del feed muestra un rectángulo negro mientras el reproductor arranca, ya parece rota.

Así que siempre mantengo la miniatura como capa base y solo muestro el reproductor después del primer fotograma renderizado.

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

Esa pequeña condición de opacidad marca una diferencia enorme.

El video no necesita aparecer al instante. Solo tiene que reemplazar la miniatura de forma limpia.

Lo importante de ese fragmento es el traspaso en el primer fotograma. La línea de textureView es solo un detalle de renderizado específico de Android.

Ajustes por plataforma: bufferOptions y surfaceType

Esta parte necesita un poco más de precisión.

expo-video expone bufferOptions de forma multiplataforma, pero algunos de los campos individuales dentro de ese objeto son específicos de cada plataforma.

En la práctica, eso significa:

  • bufferOptions como API existe tanto en Android como en iOS
  • campos como minBufferForPlayback y prioritizeTimeOverSizeThreshold son los ajustes enfocados en Android que usé aquí
  • waitsToMinimizeStalling es un ajuste de buffer específico de iOS dentro de la misma API
  • surfaceType es solo de Android

Eso es lo que me permitió diferenciar entre:

  • tarjetas activas del feed
  • tarjetas adyacentes del feed
  • reproductores de detalle
  • reproductores de vista previa

También es la razón por la que usé textureView explícitamente en los sitios donde importaban las vistas de video superpuestas o las transiciones por capas.

La documentación de Expo incluso menciona surfaceType="textureView" como solución para los problemas de VideoView superpuestos en Android.

Así que cuando muestro código como este:

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

esa sección trata en realidad de ajustar el coste de reproducción en Android, no de la solución completa.

La solución completa sigue siendo la política del ciclo de vida en torno a crear, reproducir, pausar, silenciar y recurrir a la alternativa.

Las filas horizontales necesitan un presupuesto de reproducción

El feed no era la única superficie de video de la app.

También tenía filas horizontales en la pantalla de inicio, y esas filas no pueden comportarse como TikTok. Si cada tarjeta visible de cada fila visible recibe un reproductor, gastas demasiada memoria en una superficie que no lo necesita.

Así que añadí un presupuesto de reproducción por fila.

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

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

Eso me dio una regla simple:

  • solo las primeras tarjetas elegibles de las filas visibles reciben reproductores
  • todo lo demás se queda solo con la miniatura

También retrasé un poco el desmontaje cuando una tarjeta deja de ser elegible, para que los cambios rápidos de umbral no creen y destruyan reproductores de forma demasiado agresiva.

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

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

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

Eso hizo que las filas horizontales resultaran mucho más baratas que el feed a pantalla completa.

El video destacado no debe comportarse como el feed

El video destacado tenía otro problema.

Quería que el carrusel se sintiera interactivo y que aun así mostrara video cuando estuviera quieto.

La solución fue:

  • deslizar miniaturas durante el gesto
  • mostrar el video activo como una capa superpuesta aparte
  • desvanecer esa capa de video mientras se arrastra
  • reproducir solo cuando el destacado es visible, la pantalla está activa y el gesto ha terminado
const shouldPlayHero =
  isScreenActive &&
  isHeroVisible &&
  isSettled &&
  !!activeVideoUrl;

Eso funcionó mejor que intentar mantener cada diapositiva del destacado como un reproductor en vivo.

La pantalla de resultado necesita otro reproductor

No usé el mismo componente de reproductor en todas partes.

Las tarjetas de vista previa silenciadas y en bucle y una pantalla de resultado completa no son el mismo problema.

La pantalla de resultado usa un VideoPlayer compartido con:

  • controles de reproducción
  • listeners de playingChange
  • listeners de timeUpdate
  • listeners de statusChange
  • soporte de pantalla completa en iOS
  • reproducción remota primero con alternativa local

Si usas esos eventos, la documentación relevante de Expo es:

El uso es simple:

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

La lógica de respaldo es directa.

Si el reproductor se queda cargando demasiado tiempo antes de la primera carga correcta, o si pasa a un estado de error, descargo el MP4 en el directorio de caché y cambio la fuente.

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

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

No se trata de microoptimización. Se trata de hacer que la pantalla de resultado sea fiable.

Si se abre un resultado terminado y la reproducción se atasca, toda la funcionalidad parece rota.

Lo que realmente importó

Si tuviera que resumir toda la configuración en unas pocas reglas prácticas, serían estas:

  • mantener expo-video detrás de un wrapper
  • separar la creación del reproductor de la reproducción
  • tratar el feed, las filas, el destacado y la pantalla de resultado como superficies distintas
  • mostrar miniaturas primero por defecto
  • condicionar la reproducción al foco y a que la app esté en primer plano
  • usar los perfiles de buffer de Android como un detalle, no como toda la estrategia
  • añadir un camino alternativo para las superficies de reproducción importantes

Ese último punto importa.

Este artículo no trata realmente de un flag de buffer de Android.

La mayor ganancia fue decidir:

  • dónde debe existir un reproductor
  • cuándo debe reproducir
  • cuándo debe seguir silenciado
  • cuándo una miniatura es la mejor opción por defecto
  • qué superficies merecen un camino de recuperación

Una vez que lo acepté, la arquitectura quedó mucho más limpia.

Resultado final

Así quedó el feed después de separar la creación del reproductor de la reproducción y mantener el elemento activo como la única prioridad real:

Reflexiones finales

expo-video en sí no fue lo difícil aquí.

Lo difícil fue ser honesto sobre cuántas superficies de video distintas tenía realmente la app.

En cuanto dejé de tratarlas todas igual, el feed empezó a sentirse mucho mejor.

Y para darle algo de mérito a expo-video, una vez que la política de reproducción estuvo clara, la librería hizo su trabajo muy bien.

Tener useVideoPlayer y VideoView en un único camino de código multiplataforma me permitió mantener la arquitectura casi toda compartida, y bifurcar solo donde las plataformas realmente difieren, como bufferOptions en Android, surfaceType en Android o el comportamiento a pantalla completa en iOS.

Si estás construyendo una interfaz tipo feed con expo-video, yo empezaría por ahí.