Een soepele videofeed in TikTok-stijl bouwen met expo-video
expo-video is makkelijk zolang er maar één player op het scherm staat.
Het wordt lastiger als dezelfde app een hero-video, een verticale feed, horizontale rijen en een resultaatscherm met echte bediening heeft.
Zo zat mijn app in elkaar, en het probleem was eigenlijk niet "hoe speel ik een video af in Expo?"
Het echte probleem was dat ik te veel verschillende video-oppervlakken had en ze behandelde alsof ze hetzelfde waren.
Dat was de fout.
Sommige oppervlakken horen vroeg een player aan te maken. Sommige horen alleen af te spelen als ze focus hebben. Sommige horen alleen een thumbnail te tonen tot de gebruiker in de buurt komt. Sommige hebben een terugvalpad nodig als het afspelen vanaf het netwerk vastloopt.
Dit artikel bestaat omdat de oplossing niet één magische prop was. De oplossing was een afspeelbeleid vastleggen.
Waarom dit snel rommelig wordt
Voordat ik iets anders deed, splitste ik het probleem op in vier beslissingen:
- moet dit oppervlak een player aanmaken?
- moet deze player nu afspelen?
- hoe duur mag deze player zijn?
- wat moet de gebruiker zien vóór het eerste frame?
Zodra die beslissingen los van elkaar stonden, werd de rest van de architectuur veel makkelijker te doorgronden.
Houd expo-video achter een wrapper
Voordat ik iets optimaliseerde, zette ik een wrapper om expo-video heen.
Ik wilde niet dat bufferinstellingen, fullscreen-gedrag, surface type en het opzetten van de player overal in de app verspreid zaten. Een wrapper was genoeg om die keuzes op één plek te houden.
De officiële documentatie staat hier: documentatie van 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,
},
};
Die wrapper doet niets magisch. Hij geeft me alleen één plek om deze dingen te definiëren:
- detailplayer
- previewplayer
- actieve feedplayer
- naastliggende feedplayer
De Android-profielen doen ertoe, maar ze zijn maar één onderdeel van de opzet. De grootste winst kwam uit bepalen wanneer players bestaan en wanneer ze mogen afspelen.
Een player aanmaken is niet hetzelfde als hem afspelen
Dit was de belangrijkste omslag in mijn denken.
In het feedscherm hield ik op met het aanmaken van een player en het afspelen als hetzelfde te behandelen.
const shouldCreatePlayer =
isTransitionFinished &&
(isActive || isAdjacent) &&
!!videoUrl;
const shouldPlay =
isActive &&
isAppInForeground &&
isScreenFocused;
Die twee booleans lossen verschillende problemen op.
shouldCreatePlayerbeantwoordt of het oppervlak überhaupt een player verdientshouldPlaybeantwoordt of die player op dit moment moet draaien
Dat onderscheid doet er in een feed heel veel toe.
Als je het overslaat, eindig je meestal met te veel players, te veel buffering en een hoop zinloos werk.
Actieve en naastliggende states in de verticale feed
Voor de hoofdfeed maak ik alleen players aan voor het actieve item en de items ernaast.
Zo voelt de actieve kaart direct aan, zonder dat je de volle prijs betaalt voor de hele lijst.
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",
});
De actieve kaart krijgt het ruimere profiel.
De naastliggende kaart krijgt een goedkoper profiel, omdat die misschien nooit de hoofdrol krijgt.
Maar het belangrijkste deel is nog steeds de afspeelregel, niet de bufferregel.
Items die niet actief zijn, zet ik meteen op mute en op pauze:
useEffect(() => {
if (!player) return;
if (shouldPlay) {
player.muted = false;
player.play();
} else {
player.muted = true;
player.pause();
}
}, [player, shouldPlay]);
Dat deel werkt op alle platforms. Het is de echte gedragsverandering.
In previewoppervlakken liet ik useCaching op iOS ook uitgeschakeld. Dat is geen algemene regel voor expo-video. Het was een beslissing voor deze app, omdat caching van previews voor mij stabieler was op Android dan op iOS.
Eerst de thumbnail renderen is niet onderhandelbaar
Als een feedcel een zwarte rechthoek toont terwijl de player opwarmt, voelt het al kapot.
Daarom houd ik de thumbnail altijd als onderste laag en laat ik de player pas zien na het eerste gerenderde frame.
<AppVideoView
player={player}
contentFit="cover"
nativeControls={false}
pointerEvents="none"
style={[
StyleSheet.absoluteFill,
{ opacity: hasFirstFrame ? 1 : 0 },
]}
androidSurfaceType="textureView"
onFirstFrameRender={() => setHasFirstFrame(true)}
/>
Die kleine opacity-poort maakt een enorm verschil.
De video hoeft niet meteen te verschijnen. Hij moet alleen netjes de thumbnail vervangen.
Het belangrijke deel in die snippet is de overdracht bij het eerste frame. De regel met textureView is maar één Android-specifiek renderdetail.
Afstemming per platform: bufferOptions en surfaceType
Dit deel vraagt om iets meer precisie.
expo-video biedt bufferOptions voor alle platforms aan, maar sommige velden binnen dat object zijn platformspecifiek.
In de praktijk betekent dat:
bufferOptionsbestaat als API op zowel Android als iOS- velden als
minBufferForPlaybackenprioritizeTimeOverSizeThresholdzijn de op Android gerichte knoppen waarmee ik hier heb afgestemd waitsToMinimizeStallingis een iOS-specifieke bufferinstelling in dezelfde APIsurfaceTypeis alleen voor Android
Daarmee kon ik onderscheid maken tussen:
- actieve feedkaarten
- naastliggende feedkaarten
- detailplayers
- previewplayers
Het is ook de reden dat ik expliciet textureView gebruikte op plekken waar overlappende videoviews of gelaagde transities ertoe deden.
De documentatie van Expo noemt surfaceType="textureView" zelfs als workaround voor problemen met overlappende VideoView op Android.
Dus als ik code als deze laat zien:
const player = useAppVideoPlayer(videoSource, {
loop: true,
muted: true,
androidBufferProfile: isActive
? "feed-active"
: "feed-adjacent",
});
gaat dat deel eigenlijk over het afstemmen van de afspeelkosten op Android, niet over de hele oplossing.
De volledige oplossing blijft het levenscyclusbeleid rond aanmaken, afspelen, pauzeren, muten en terugvallen.
Horizontale rijen hebben een afspeelbudget nodig
De feed was niet het enige video-oppervlak in de app.
Ik had ook horizontale rijen op het homescherm, en die rijen kunnen zich niet als TikTok gedragen. Als elke zichtbare kaart in elke zichtbare rij een player krijgt, verbruik je te veel geheugen voor een oppervlak dat dat niet nodig heeft.
Daarom voegde ik een afspeelbudget per rij toe.
const remainingSlots = heroVisible ? 3 : 4;
const rowBudget = Math.min(2, remainingSlots);
const shouldPlayCard =
isRowVisible &&
isCardVisibleHorizontally &&
cardIndex < rowBudget;
Dat gaf me een simpele regel:
- alleen de eerste paar geschikte kaarten in zichtbare rijen krijgen players
- al het andere blijft bij alleen een thumbnail
Ik stelde het unmounten ook iets uit als een kaart niet meer in aanmerking komt, zodat snelle wisselingen rond de drempel niet te agressief players laten aanmaken en weggooien.
useEffect(() => {
if (shouldPlay) {
setShouldRenderVideo(true);
return;
}
const timeout = setTimeout(() => {
setShouldRenderVideo(false);
}, 180);
return () => clearTimeout(timeout);
}, [shouldPlay]);
Daardoor voelden de horizontale rijen veel goedkoper aan dan de feed op volledig scherm.
De hero hoort zich niet als de feed te gedragen
De hero had een ander probleem.
Ik wilde dat de carousel interactief aanvoelde en toch video liet zien als hij tot rust was gekomen.
De oplossing was:
- tijdens de gesture de thumbnails laten schuiven
- de actieve video als aparte overlay tonen
- de video-overlay laten uitfaden tijdens het slepen
- alleen afspelen als de hero zichtbaar is, het scherm actief is en de gesture tot rust is gekomen
const shouldPlayHero =
isScreenActive &&
isHeroVisible &&
isSettled &&
!!activeVideoUrl;
Dat werkte beter dan proberen om elke hero-slide als live player te houden.
Het resultaatscherm heeft een andere player nodig
Ik gebruikte niet overal hetzelfde player-component.
Previewkaarten die gemute in een loop afspelen en een volledig resultaatscherm zijn niet hetzelfde probleem.
Het resultaatscherm gebruikt een gedeelde VideoPlayer met:
- afspeelbediening
- listeners voor
playingChange - listeners voor
timeUpdate - listeners voor
statusChange - fullscreen-ondersteuning op iOS
- eerst afspelen vanaf het netwerk, met een lokale fallback
Als je die events gebruikt, is dit de relevante documentatie van Expo:
Het gebruik is simpel:
<VideoPlayer
uri={videoUrl}
controlsVariant="playback"
muted={false}
loop={false}
androidBufferProfile="detail"
iosAllowFullscreen
fallbackToLocal
fallbackTimeoutMs={8000}
/>
De fallback-logica is rechttoe rechtaan.
Als de player te lang blijft laden vóór de eerste geslaagde load, of als hij in een fouttoestand komt, download ik de MP4 naar de cachemap en wissel ik de bron.
if (
fallbackToLocal &&
!fallbackApplied.current &&
!hasLoadedOnce.current
) {
fallbackTimer.current = setTimeout(() => {
startLocalFallback();
}, fallbackTimeoutMs);
}
if (status === "error" && fallbackToLocal) {
startLocalFallback();
}
Dat gaat niet over micro-optimalisatie. Het gaat erom dat het resultaatscherm betrouwbaar is.
Als een afgerond resultaat opent en het afspelen hapert, voelt de hele feature kapot.
Wat er echt toe deed
Als ik de hele opzet moest samenvatten in een paar praktische regels, zouden het deze zijn:
- houd expo-video achter een wrapper
- scheid het aanmaken van een player van het afspelen
- behandel feed, rijen, hero en resultaatschermen als verschillende oppervlakken
- toon standaard eerst thumbnails
- laat afspelen afhangen van focus en of de app op de voorgrond staat
- gebruik bufferprofielen voor Android als detail, niet als de hele strategie
- voeg een terugvalpad toe voor belangrijke afspeeloppervlakken
Dat laatste punt doet ertoe.
Dit artikel gaat eigenlijk niet over één bufferflag op Android.
De grotere winst was bepalen:
- waar een player hoort te bestaan
- wanneer hij hoort af te spelen
- wanneer hij gemute moet blijven
- wanneer een thumbnail de betere standaard is
- welke oppervlakken een herstelpad verdienen
Toen ik dat eenmaal accepteerde, werd de architectuur veel overzichtelijker.
Eindresultaat
Zo zag de feed eruit nadat ik het aanmaken van players had gescheiden van het afspelen en het actieve item de enige echte prioriteit had gemaakt:
Tot slot
expo-video zelf was hier niet het moeilijke deel.
Het moeilijke deel was eerlijk zijn over hoeveel verschillende video-oppervlakken de app eigenlijk had.
Zodra ik ze niet meer allemaal hetzelfde behandelde, begon de feed veel beter aan te voelen.
En om expo-video wat eer te geven: zodra het afspeelbeleid duidelijk was, deed de library zelf zijn werk heel goed.
Doordat useVideoPlayer en VideoView in één codepad voor alle platforms zitten, kon ik de architectuur grotendeels gedeeld houden en alleen aftakken waar de platforms echt verschillen, zoals bufferOptions op Android, surfaceType op Android of het fullscreen-gedrag op iOS.
Als je een UI in feedstijl bouwt met expo-video, zou ik daar beginnen.