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.
shouldCreatePlayerodpowiada na pytanie, czy powierzchnia w ogóle zasługuje na playershouldPlayodpowiada 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:
bufferOptionsjako API istnieje zarówno na Androidzie, jak i na iOS- pola takie jak
minBufferForPlaybackiprioritizeTimeOverSizeThresholdto pokrętła do strojenia pod Androida, których tu użyłem waitsToMinimizeStallingto ustawienie bufora specyficzne dla iOS w tym samym APIsurfaceTypedział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.