# Как заставить expo-video работать в ленте в стиле TikTok

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

# Плавная видеолента в стиле TikTok на expo-video

С expo-video всё просто, пока на экране один плеер.

Сложнее становится, когда в одном приложении есть hero-видео, вертикальная лента, горизонтальные ряды и экран результата с полноценными элементами управления.

У меня была именно такая конфигурация, и проблема на самом деле была не в том, «как воспроизвести видео в Expo?»

Настоящая проблема была в том, что у меня было слишком много разных видеоповерхностей, и я обращался с ними так, будто это одно и то же.

В этом и была ошибка.

Некоторые поверхности должны создавать плеер заранее. Некоторые должны воспроизводить видео, только когда они в фокусе. Некоторые должны показывать только превью, пока пользователь не подберётся ближе. Некоторым нужен запасной путь, если удалённое воспроизведение зависло.

Эта статья появилась потому, что решением оказался не один волшебный prop. Решением стало определение политики воспроизведения.

## Почему всё быстро запутывается

Прежде всего я разбил проблему на четыре решения:

- должна ли эта поверхность создавать плеер?
- должен ли этот плеер играть прямо сейчас?
- насколько дорогим должен быть этот плеер?
- что пользователь должен видеть до первого кадра?

Когда эти решения разделились, всю остальную архитектуру стало гораздо проще продумывать.

## Держите expo-video за обёрткой

Прежде чем что-то оптимизировать, я обернул expo-video.

Я не хотел, чтобы настройки буфера, поведение полноэкранного режима, тип поверхности и настройка плеера были разбросаны по всему приложению. Обёртки хватило, чтобы держать все эти решения в одном месте.

Официальная документация здесь: [документация 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,
  },
};
```

Эта обёртка не делает ничего волшебного. Она просто даёт одно место, где определяются:

- плеер детального экрана
- плеер превью
- активный плеер ленты
- соседний плеер ленты

Профили для Android важны, но это лишь одна часть настройки. Больший выигрыш дал контроль над тем, когда плееры существуют и когда им разрешено играть.

## Создать плеер не то же самое, что запустить его

Это был самый важный сдвиг в мышлении.

На экране ленты я перестал считать создание плеера и воспроизведение одним и тем же.

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

const shouldPlay =
  isActive &&
  isAppInForeground &&
  isScreenFocused;
```

Эти два boolean решают разные задачи.

- `shouldCreatePlayer` отвечает на вопрос, заслуживает ли поверхность плеера вообще
- `shouldPlay` отвечает на вопрос, должен ли этот плеер работать прямо сейчас

В ленте это различие очень важно.

Если его пропустить, обычно получается слишком много плееров, слишком много буферизации и много бессмысленной работы.

## Активное и соседние состояния в вертикальной ленте

В основной ленте я создаю плееры только для активного элемента и его соседей.

Так активная карточка ощущается мгновенной, и при этом не приходится платить полную цену за весь список.

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

Активная карточка получает более щедрый профиль.

Соседняя получает более дешёвый, потому что она может так и не стать основной.

Но важнее всё равно правило воспроизведения, а не правило буфера.

Неактивные элементы я сразу глушу и ставлю на паузу:

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

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

Эта часть кроссплатформенная. Именно она меняет поведение.

На поверхностях превью я также оставил `useCaching` выключенным на iOS. Это не универсальное правило expo-video. Это решение для конкретного приложения, потому что кэширование превью у меня работало стабильнее на Android, чем на iOS.

## Сначала превью, и это не обсуждается

Если ячейка ленты показывает чёрный прямоугольник, пока плеер прогревается, она уже выглядит сломанной.

Поэтому превью у меня всегда остаётся базовым слоем, а плеер появляется только после первого отрендеренного кадра.

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

Это маленькое условие на прозрачность даёт огромную разницу.

Видео не обязано появляться мгновенно. Ему нужно просто аккуратно заменить превью.

Главное в этом фрагменте: передача управления на первом кадре. Строка с `textureView` лишь одна деталь рендеринга, специфичная для Android.

## Настройка под платформы: bufferOptions и surfaceType

Здесь нужно чуть больше точности.

expo-video предоставляет кроссплатформенный [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions), но некоторые отдельные поля внутри этого объекта зависят от платформы.

На практике это значит:

- `bufferOptions` как API существует и на Android, и на iOS
- поля вроде `minBufferForPlayback` и `prioritizeTimeOverSizeThreshold` это ручки настройки для Android, которые я здесь использовал
- `waitsToMinimizeStalling` это настройка буфера только для iOS в том же API
- [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) есть только на Android

Именно это позволило мне различать:

- активные карточки ленты
- соседние карточки ленты
- плееры детального экрана
- плееры превью

И поэтому же я явно использовал `textureView` там, где были важны перекрывающиеся видеоэлементы или многослойные переходы.

В документации Expo даже прямо упоминается `surfaceType="textureView"` как обходной путь для проблем с перекрывающимися `VideoView` на Android.

Так что когда я показываю такой код:

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

этот раздел на самом деле про настройку стоимости воспроизведения на Android, а не про всё решение целиком.

Полное решение это всё равно политика жизненного цикла вокруг создания, воспроизведения, паузы, отключения звука и запасного пути.

## Горизонтальным рядам нужен бюджет воспроизведения

Лента была не единственной видеоповерхностью в приложении.

На главном экране у меня были ещё и горизонтальные ряды, и они не могут вести себя как TikTok. Если каждая видимая карточка в каждом видимом ряду получает плеер, вы сжигаете слишком много памяти на поверхности, которой это не нужно.

Поэтому я добавил бюджет воспроизведения на уровне ряда.

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

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

Это дало простое правило:

- плееры получают только первые несколько подходящих карточек в видимых рядах
- всё остальное остаётся просто превью

Я также немного откладывал размонтирование, когда карточка перестаёт подходить, чтобы быстрые изменения порога не пересоздавали плееры слишком агрессивно.

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

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

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

После этого горизонтальные ряды стали заметно дешевле полноэкранной ленты.

## Hero не должен вести себя как лента

У hero была другая проблема.

Я хотел, чтобы карусель ощущалась интерактивной, но при этом показывала видео, когда она остановилась.

Решение было такое:

- во время жеста двигать превью
- показывать активное видео отдельным оверлеем
- плавно скрывать видеооверлей во время перетаскивания
- воспроизводить, только когда hero виден, экран активен и жест завершился

```tsx
const shouldPlayHero =
  isScreenActive &&
  isHeroVisible &&
  isSettled &&
  !!activeVideoUrl;
```

Это сработало лучше, чем попытка держать каждый слайд hero живым плеером.

## Экрану результата нужен другой плеер

Я не использовал один и тот же компонент плеера везде.

Беззвучные зацикленные карточки превью и полноценный экран результата это разные задачи.

Экран результата использует общий `VideoPlayer` с:

- элементами управления воспроизведением
- слушателями `playingChange`
- слушателями `timeUpdate`
- слушателями `statusChange`
- поддержкой полноэкранного режима на iOS
- воспроизведением сначала с сервера и локальным запасным вариантом

Если вы используете эти события, вот нужные разделы документации Expo:

- [обзор событий `playingChange` и `statusChange`](https://docs.expo.dev/versions/latest/sdk/video/)
- [`timeUpdateEventInterval`](https://docs.expo.dev/versions/latest/sdk/video/#timeupdateeventinterval)

Использование простое:

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

Логика запасного пути прямолинейна.

Если плеер слишком долго остаётся в состоянии загрузки до первой успешной загрузки или переходит в состояние ошибки, я скачиваю MP4 в директорию кэша и подменяю источник.

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

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

Дело тут не в микрооптимизации. Дело в надёжности экрана результата.

Если готовый результат открывается, а воспроизведение зависает, вся функция кажется сломанной.

## Что на самом деле было важно

Если сжать всю настройку до нескольких практических правил, получится так:

- держите expo-video за обёрткой
- разделяйте создание плеера и воспроизведение
- считайте ленту, ряды, hero и экраны результата разными поверхностями
- по умолчанию сначала превью
- разрешайте воспроизведение только при фокусе и когда приложение на переднем плане
- используйте профили буфера Android как деталь, а не как всю стратегию
- добавьте запасной путь для важных поверхностей воспроизведения

Последний пункт важен.

Эта статья на самом деле не про один флаг буфера в Android.

Больший выигрыш дало решение о том:

- где должен существовать плеер
- когда он должен играть
- когда он должен оставаться без звука
- когда превью лучше по умолчанию
- каким поверхностям нужен путь восстановления

Как только я это принял, архитектура стала гораздо чище.

## Итоговый результат

Вот как выглядела лента после того, как я разделил создание плеера и воспроизведение и оставил активный элемент единственным настоящим приоритетом:

<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"
  >
    Ваш браузер не поддерживает тег video.
  </video>
</div>

## Итоговые мысли

Сам expo-video здесь не был сложной частью.

Сложно было честно признать, сколько разных видеоповерхностей на самом деле было в приложении.

Как только я перестал обращаться со всеми ними одинаково, лента стала ощущаться гораздо лучше.

И отдам должное expo-video: когда политика воспроизведения стала понятной, сама библиотека отлично справилась со своей работой.

Благодаря `useVideoPlayer` и `VideoView` на одном кроссплатформенном пути кода удалось сделать архитектуру в основном общей и разветвлять её только там, где платформы действительно различаются: Android [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions), Android [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) или поведение полноэкранного режима на iOS.

Если вы строите интерфейс в стиле ленты на expo-video, я бы начал с этого.

