Blog

Jak zmusić expo-video do działania w feedzie w stylu TikToka

10 stycznia 2026 11 min czytania

Jak sprawiłem, że expo-video dobrze działa w feedzie w stylu TikToka: oddzieliłem tworzenie playera od odtwarzania, a feed, hero, wiersze i ekrany wyników potraktowałem jak różne powierzchnie.

Jak zmusić expo-video do działania w feedzie w stylu TikToka
ExpoReact Nativeexpo-videoWydajnośćWideo

Płynny feed wideo w stylu TikToka z expo-video

expo-video jest proste, kiedy na ekranie jest tylko jeden player.

Robi się trudniej, gdy ta sama aplikacja ma wideo w hero, pionowy feed, poziome rzędy i ekran wyniku z prawdziwymi kontrolkami.

Tak wyglądał mój setup i problemem wcale nie było pytanie „jak odtworzyć wideo w Expo?”.

Prawdziwy problem polegał na tym, że miałem za dużo różnych powierzchni z wideo i traktowałem je tak, jakby były tym samym.

To był błąd.

Niektóre powierzchnie powinny tworzyć player wcześnie. Niektóre powinny odtwarzać tylko wtedy, gdy mają focus. Niektóre powinny pokazywać tylko miniaturę, dopóki użytkownik się do nich nie zbliży. Niektóre potrzebują ścieżki awaryjnej, jeśli zdalne odtwarzanie się zatnie.

Ten artykuł powstał, bo rozwiązaniem nie był jeden magiczny props. Rozwiązaniem było zdefiniowanie polityki odtwarzania.

Dlaczego to tak szybko robi się chaotyczne

Zanim zrobiłem cokolwiek innego, podzieliłem problem na cztery decyzje:

  • czy ta powierzchnia powinna tworzyć player?
  • czy ten player powinien teraz odtwarzać?
  • jak kosztowny powinien być ten player?
  • co użytkownik powinien zobaczyć przed pierwszą klatką?

Kiedy te decyzje zostały rozdzielone, łatwiej było myśleć o całej reszcie architektury.

Trzymaj expo-video za wrapperem

Zanim cokolwiek zoptymalizowałem, opakowałem expo-video we wrapper.

Nie chciałem, żeby ustawienia bufora, zachowanie pełnego ekranu, typ powierzchni i konfiguracja playera były rozrzucone po całej aplikacji. Wrapper wystarczył, żeby trzymać te decyzje w jednym miejscu.

Oficjalna dokumentacja jest tutaj: dokumentacja 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,
  },
};

Ten wrapper nie robi nic magicznego. Daje mi po prostu jedno miejsce, w którym definiuję:

  • player szczegółów
  • player podglądu
  • aktywny player w feedzie
  • sąsiedni player w feedzie

Profile dla Androida mają znaczenie, ale są tylko jedną częścią setupu. Większe zyski dało kontrolowanie, kiedy playery istnieją i kiedy wolno im odtwarzać.

Stworzenie playera to nie to samo co jego odtworzenie

To była najważniejsza zmiana w myśleniu.

Na ekranie feedu przestałem traktować tworzenie playera i odtwarzanie jako jedno i to samo.

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

const shouldPlay =
  isActive &&
  isAppInForeground &&
  isScreenFocused;

Te dwa booleany rozwiązują różne problemy.

  • shouldCreatePlayer odpowiada na pytanie, czy powierzchnia w ogóle zasługuje na player
  • shouldPlay odpowiada na pytanie, czy ten player powinien teraz działać

To rozróżnienie ma w feedzie ogromne znaczenie.

Jeśli je pominiesz, zwykle kończysz z za dużą liczbą playerów, za dużym buforowaniem i mnóstwem bezsensownej pracy.

Stan aktywny i sąsiedni w pionowym feedzie

W głównym feedzie tworzę playery tylko dla aktywnego elementu i jego sąsiadów.

Dzięki temu aktywna karta działa natychmiast, a ja nie płacę pełnej ceny za całą listę.

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

Aktywna karta dostaje hojniejszy profil.

Sąsiednia karta dostaje tańszy, bo może nigdy nie stać się główną.

Ale ważniejsza nadal jest reguła odtwarzania, nie reguła bufora.

Nieaktywne elementy od razu wyciszam i pauzuję:

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

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

Ta część jest cross-platformowa. To jest właściwa zmiana zachowania.

Na powierzchniach podglądu zostawiłem też useCaching wyłączone na iOS. To nie jest uniwersalna reguła expo-video. To była decyzja dla tej aplikacji, bo cache'owanie podglądów działało u mnie stabilniej na Androidzie niż na iOS.

Najpierw miniatura, bez dyskusji

Jeśli komórka feedu pokazuje czarny prostokąt, gdy player się rozgrzewa, już wygląda na zepsutą.

Dlatego miniatura zawsze jest warstwą bazową, a player odsłaniam dopiero po wyrenderowaniu pierwszej klatki.

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

Ten mały warunek na opacity robi ogromną różnicę.

Wideo nie musi pojawić się natychmiast. Musi tylko czysto zastąpić miniaturę.

Najważniejsze w tym fragmencie jest przekazanie pałeczki przy pierwszej klatce. Linia z textureView to tylko jeden szczegół renderowania specyficzny dla Androida.

Strojenie per platforma: bufferOptions i surfaceType

Ta część wymaga trochę więcej precyzji.

expo-video udostępnia cross-platformowe bufferOptions, ale niektóre pojedyncze pola w tym obiekcie są specyficzne dla platformy.

W praktyce oznacza to, że:

  • bufferOptions jako API istnieje zarówno na Androidzie, jak i na iOS
  • pola takie jak minBufferForPlayback i prioritizeTimeOverSizeThreshold to pokrętła do strojenia pod Androida, których tu użyłem
  • waitsToMinimizeStalling to ustawienie bufora specyficzne dla iOS w tym samym API
  • surfaceType działa tylko na Androidzie

To właśnie pozwoliło mi rozróżnić:

  • aktywne karty feedu
  • sąsiednie karty feedu
  • playery szczegółów
  • playery podglądu

To także powód, dla którego jawnie użyłem textureView w miejscach, gdzie liczyły się nakładające się widoki wideo albo warstwowe przejścia.

Dokumentacja Expo wprost wskazuje surfaceType="textureView" jako obejście problemów z nakładającymi się VideoView na Androidzie.

Więc kiedy pokazuję taki kod:

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

ta sekcja dotyczy tak naprawdę strojenia kosztu odtwarzania na Androidzie, a nie całego rozwiązania.

Pełnym rozwiązaniem nadal jest polityka cyklu życia wokół tworzenia, odtwarzania, pauzowania, wyciszania i ścieżki awaryjnej.

Poziome rzędy potrzebują budżetu odtwarzania

Feed nie był jedyną powierzchnią z wideo w aplikacji.

Miałem też poziome rzędy na ekranie głównym, a te rzędy nie mogą zachowywać się jak TikTok. Jeśli każda widoczna karta w każdym widocznym rzędzie dostaje player, zużywasz za dużo pamięci na powierzchnię, która tego nie potrzebuje.

Dlatego dodałem budżet odtwarzania na poziomie rzędu.

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

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

To dało mi prostą regułę:

  • playery dostaje tylko kilka pierwszych kwalifikujących się kart w widocznych rzędach
  • wszystko inne pokazuje tylko miniaturę

Lekko opóźniłem też unmount, gdy karta przestaje się kwalifikować, żeby szybkie zmiany progu nie powodowały zbyt agresywnego tworzenia i niszczenia playerów.

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

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

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

Dzięki temu poziome rzędy były znacznie tańsze niż pełnoekranowy feed.

Hero nie powinno zachowywać się jak feed

Hero miało inny problem.

Chciałem, żeby karuzela była interaktywna, a jednocześnie pokazywała wideo, kiedy się zatrzyma.

Rozwiązanie wyglądało tak:

  • podczas gestu przesuwają się miniatury
  • aktywne wideo jest pokazywane jako osobna nakładka
  • nakładka z wideo znika podczas przeciągania
  • odtwarzanie startuje tylko wtedy, gdy hero jest widoczne, ekran jest aktywny, a gest się zakończył
const shouldPlayHero =
  isScreenActive &&
  isHeroVisible &&
  isSettled &&
  !!activeVideoUrl;

To działało lepiej niż próba utrzymywania każdego slajdu hero jako żywego playera.

Ekran wyniku potrzebuje innego playera

Nie używałem wszędzie tego samego komponentu playera.

Wyciszone, zapętlone karty podglądu i pełny ekran wyniku to nie ten sam problem.

Ekran wyniku używa współdzielonego VideoPlayer z:

  • kontrolkami odtwarzania
  • listenerami playingChange
  • listenerami timeUpdate
  • listenerami statusChange
  • obsługą pełnego ekranu na iOS
  • odtwarzaniem najpierw zdalnym, z lokalną ścieżką awaryjną

Jeśli używasz tych eventów, przydatne fragmenty dokumentacji Expo to:

Użycie jest proste:

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

Logika awaryjna jest nieskomplikowana.

Jeśli player zbyt długo zostaje w stanie ładowania przed pierwszym udanym załadowaniem albo przechodzi w stan błędu, pobieram MP4 do katalogu cache i podmieniam źródło.

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

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

Nie chodzi tu o mikrooptymalizację. Chodzi o to, żeby ekran wyniku był niezawodny.

Jeśli gotowy wynik się otwiera, a odtwarzanie się zacina, cała funkcja wydaje się zepsuta.

Co naprawdę miało znaczenie

Gdybym miał skompresować cały setup do kilku praktycznych reguł, byłyby to te:

  • trzymaj expo-video za wrapperem
  • oddziel tworzenie playera od odtwarzania
  • traktuj feed, rzędy, hero i ekrany wyniku jako różne powierzchnie
  • domyślnie zaczynaj od miniatur
  • uzależnij odtwarzanie od focusu i stanu pierwszego planu
  • traktuj profile bufora na Androidzie jako szczegół, a nie całą strategię
  • dodaj ścieżkę awaryjną dla ważnych powierzchni odtwarzania

Ten ostatni punkt ma znaczenie.

Ten artykuł tak naprawdę nie jest o jednej fladze bufora na Androidzie.

Większym zyskiem było ustalenie:

  • gdzie player powinien istnieć
  • kiedy powinien odtwarzać
  • kiedy powinien pozostać wyciszony
  • kiedy miniatura jest lepszym domyślnym wyborem
  • które powierzchnie zasługują na ścieżkę odzyskiwania

Kiedy to zaakceptowałem, architektura stała się dużo czystsza.

Efekt końcowy

Tak wyglądał feed po oddzieleniu tworzenia playera od odtwarzania i pozostawieniu aktywnego elementu jako jedynego prawdziwego priorytetu:

Ostatnie przemyślenia

Samo expo-video nie było tu trudną częścią.

Trudne było szczere przyznanie, ile różnych powierzchni z wideo aplikacja faktycznie ma.

Kiedy przestałem traktować je wszystkie tak samo, feed zaczął działać dużo lepiej.

I trzeba oddać expo-video sprawiedliwość: kiedy polityka odtwarzania była już jasna, sama biblioteka wykonała swoją pracę bardzo dobrze.

Dzięki temu, że useVideoPlayer i VideoView działają w jednej cross-platformowej ścieżce kodu, mogłem utrzymać architekturę w większości wspólną i rozgałęziać ją tylko tam, gdzie platformy faktycznie się różnią, na przykład przy androidowych bufferOptions, androidowym surfaceType czy zachowaniu pełnego ekranu na iOS.

Jeśli budujesz UI w stylu feedu z expo-video, zacząłbym właśnie od tego.