Costruire un feed video fluido stile TikTok con expo-video
expo-video è facile quando sullo schermo c'è un solo player.
Diventa più difficile quando la stessa app ha un video hero, un feed verticale, righe orizzontali e una schermata di risultato con controlli veri.
Questa era la mia situazione, e il problema non era davvero "come riproduco un video in Expo?".
Il vero problema era che avevo troppe superfici video diverse e le trattavo come se fossero la stessa cosa.
Era quello l'errore.
Alcune superfici dovrebbero creare un player in anticipo. Alcune dovrebbero riprodurre solo quando sono a fuoco. Alcune dovrebbero restare solo miniatura finché l'utente non si avvicina. Alcune hanno bisogno di un percorso di riserva se la riproduzione remota si blocca.
Questo articolo esiste perché la soluzione non era una prop magica. La soluzione era definire una politica di riproduzione.
Perché le cose si complicano in fretta
Prima di tutto ho diviso il problema in quattro decisioni:
- questa superficie deve creare un player?
- questo player deve essere in riproduzione adesso?
- quanto deve costare questo player?
- cosa deve vedere l'utente prima del primo frame?
Una volta separate queste decisioni, il resto dell'architettura è diventato molto più facile da ragionare.
Tieni expo-video dietro un wrapper
Prima di ottimizzare qualsiasi cosa, ho avvolto expo-video in un wrapper.
Non volevo impostazioni del buffer, comportamento a schermo intero, tipo di superficie e configurazione del player sparsi per tutta l'app. Un wrapper bastava a tenere queste scelte in un unico posto.
La documentazione ufficiale è qui: documentazione di 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,
},
};
Quel wrapper non fa niente di magico. Mi dà solo un posto unico dove definire:
- il player di dettaglio
- il player di anteprima
- il player attivo del feed
- il player adiacente del feed
I profili Android contano, ma sono solo una parte della configurazione. I guadagni più grandi sono venuti dal controllare quando i player esistono e quando hanno il permesso di riprodurre.
Creare un player non equivale a riprodurlo
È stato il cambio di mentalità più importante.
Nella schermata del feed ho smesso di trattare la creazione del player e la riproduzione come la stessa cosa.
const shouldCreatePlayer =
isTransitionFinished &&
(isActive || isAdjacent) &&
!!videoUrl;
const shouldPlay =
isActive &&
isAppInForeground &&
isScreenFocused;
Quei due booleani risolvono problemi diversi.
shouldCreatePlayerrisponde alla domanda se la superficie merita davvero un playershouldPlayrisponde alla domanda se quel player deve girare in questo momento
In un feed questa distinzione conta moltissimo.
Se la salti, di solito finisci con troppi player, troppo buffering e tanto lavoro inutile.
Stati attivo e adiacente nel feed verticale
Nel feed principale creo player solo per l'elemento attivo e per quelli adiacenti.
Così la scheda attiva sembra istantanea senza pagare il prezzo pieno per tutta 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 scheda attiva riceve il profilo più generoso.
La scheda adiacente ne riceve uno più economico, perché potrebbe non diventare mai quella principale.
Ma la parte più importante resta la regola di riproduzione, non quella del buffer.
Metto in muto e in pausa subito gli elementi non attivi:
useEffect(() => {
if (!player) return;
if (shouldPlay) {
player.muted = false;
player.play();
} else {
player.muted = true;
player.pause();
}
}, [player, shouldPlay]);
Questa parte è multipiattaforma. È il vero cambio di comportamento.
Nelle superfici di anteprima ho anche tenuto useCaching disattivato su iOS. Non è una regola universale di expo-video. È stata una decisione per questa app, perché nel mio caso il caching delle anteprime era più stabile su Android che su iOS.
Partire dalla miniatura non è negoziabile
Se una cella del feed mostra un rettangolo nero mentre il player si scalda, sembra già rotta.
Quindi tengo sempre la miniatura come livello di base e mostro il player solo dopo il primo frame renderizzato.
<AppVideoView
player={player}
contentFit="cover"
nativeControls={false}
pointerEvents="none"
style={[
StyleSheet.absoluteFill,
{ opacity: hasFirstFrame ? 1 : 0 },
]}
androidSurfaceType="textureView"
onFirstFrameRender={() => setHasFirstFrame(true)}
/>
Quel piccolo controllo sull'opacità fa una differenza enorme.
Il video non deve comparire all'istante. Deve solo sostituire la miniatura in modo pulito.
La parte importante di quello snippet è il passaggio al primo frame. La riga textureView è solo un dettaglio di rendering specifico di Android.
Ottimizzazioni per piattaforma: bufferOptions e surfaceType
Questa parte richiede un po' più di precisione.
expo-video espone bufferOptions su tutte le piattaforme, ma alcuni dei singoli campi dentro quell'oggetto sono specifici di una piattaforma.
In pratica significa che:
bufferOptionscome API esiste sia su Android sia su iOS- campi come
minBufferForPlaybackeprioritizeTimeOverSizeThresholdsono le leve di ottimizzazione pensate per Android che ho usato qui waitsToMinimizeStallingè un'impostazione del buffer specifica di iOS nella stessa APIsurfaceTypeesiste solo su Android
È questo che mi ha permesso di distinguere tra:
- schede attive del feed
- schede adiacenti del feed
- player di dettaglio
- player di anteprima
Ed è anche il motivo per cui ho usato esplicitamente textureView nei punti in cui contavano viste video sovrapposte o transizioni a più livelli.
La documentazione di Expo cita proprio surfaceType="textureView" come soluzione per i problemi di VideoView sovrapposte su Android.
Quindi quando mostro codice come questo:
const player = useAppVideoPlayer(videoSource, {
loop: true,
muted: true,
androidBufferProfile: isActive
? "feed-active"
: "feed-adjacent",
});
quella sezione riguarda in realtà l'ottimizzazione del costo di riproduzione su Android, non l'intera soluzione.
La soluzione completa resta la politica sul ciclo di vita: creazione, riproduzione, pausa, muto e percorso di riserva.
Le righe orizzontali hanno bisogno di un budget di riproduzione
Il feed non era l'unica superficie video dell'app.
Avevo anche righe orizzontali nella schermata home, e quelle righe non possono comportarsi come TikTok. Se ogni scheda visibile in ogni riga visibile riceve un player, bruci troppa memoria per una superficie che non ne ha bisogno.
Quindi ho aggiunto un budget di riproduzione a livello di riga.
const remainingSlots = heroVisible ? 3 : 4;
const rowBudget = Math.min(2, remainingSlots);
const shouldPlayCard =
isRowVisible &&
isCardVisibleHorizontally &&
cardIndex < rowBudget;
Questo mi ha dato una regola semplice:
- solo le prime schede idonee nelle righe visibili ricevono un player
- tutto il resto resta solo miniatura
Ho anche ritardato leggermente lo smontaggio quando una scheda smette di essere idonea, così i cambi rapidi di soglia non creano e distruggono player in modo troppo aggressivo.
useEffect(() => {
if (shouldPlay) {
setShouldRenderVideo(true);
return;
}
const timeout = setTimeout(() => {
setShouldRenderVideo(false);
}, 180);
return () => clearTimeout(timeout);
}, [shouldPlay]);
Così le righe orizzontali sono diventate molto più leggere del feed a schermo intero.
L'hero non deve comportarsi come il feed
L'hero aveva un problema diverso.
Volevo che il carosello sembrasse interattivo pur mostrando il video quando era fermo.
La soluzione era:
- far scorrere le miniature durante il gesto
- mostrare il video attivo come overlay separato
- far sparire in dissolvenza l'overlay video durante il trascinamento
- riprodurre solo quando l'hero è visibile, la schermata è attiva e il gesto si è fermato
const shouldPlayHero =
isScreenActive &&
isHeroVisible &&
isSettled &&
!!activeVideoUrl;
Ha funzionato meglio che cercare di tenere ogni slide dell'hero come player attivo.
La schermata di risultato ha bisogno di un player diverso
Non ho usato lo stesso componente player ovunque.
Le schede di anteprima in muto e in loop e una schermata di risultato completa non sono lo stesso problema.
La schermata di risultato usa un VideoPlayer condiviso con:
- controlli di riproduzione
- listener
playingChange - listener
timeUpdate - listener
statusChange - supporto allo schermo intero su iOS
- riproduzione prima da remoto con riserva locale
Se usi quegli eventi, la documentazione di Expo che ti serve è:
L'uso è semplice:
<VideoPlayer
uri={videoUrl}
controlsVariant="playback"
muted={false}
loop={false}
androidBufferProfile="detail"
iosAllowFullscreen
fallbackToLocal
fallbackTimeoutMs={8000}
/>
La logica di riserva è lineare.
Se il player resta in caricamento troppo a lungo prima del primo caricamento riuscito, o se passa in uno stato di errore, scarico l'MP4 nella directory di cache e cambio la sorgente.
if (
fallbackToLocal &&
!fallbackApplied.current &&
!hasLoadedOnce.current
) {
fallbackTimer.current = setTimeout(() => {
startLocalFallback();
}, fallbackTimeoutMs);
}
if (status === "error" && fallbackToLocal) {
startLocalFallback();
}
Non si tratta di micro ottimizzazione. Si tratta di rendere affidabile la schermata di risultato.
Se apri un risultato finito e la riproduzione si blocca, tutta la funzione sembra rotta.
Cosa contava davvero
Se dovessi riassumere tutta la configurazione in poche regole pratiche, sarebbero queste:
- tenere expo-video dietro un wrapper
- separare la creazione del player dalla riproduzione
- trattare feed, righe, hero e schermate di risultato come superfici diverse
- partire di default dalle miniature
- subordinare la riproduzione al focus e allo stato in primo piano
- usare i profili di buffer Android come dettaglio, non come strategia intera
- aggiungere un percorso di riserva per le superfici di riproduzione importanti
Quest'ultimo punto conta.
Questo articolo non parla davvero di un singolo flag del buffer su Android.
Il guadagno più grande è stato decidere:
- dove deve esistere un player
- quando deve riprodurre
- quando deve restare in muto
- quando una miniatura è la scelta predefinita migliore
- quali superfici meritano un percorso di recupero
Quando l'ho accettato, l'architettura è diventata molto più pulita.
Risultato finale
Ecco com'era il feed dopo aver separato la creazione del player dalla riproduzione e aver tenuto l'elemento attivo come unica vera priorità:
Considerazioni finali
La parte difficile qui non era expo-video in sé.
La parte difficile era essere onesti su quante superfici video diverse avesse davvero l'app.
Quando ho smesso di trattarle tutte allo stesso modo, il feed ha iniziato a funzionare molto meglio.
E per essere giusti con expo-video, una volta chiarita la politica di riproduzione, la libreria ha fatto il suo lavoro molto bene.
Avere useVideoPlayer e VideoView su un unico percorso di codice multipiattaforma mi ha permesso di mantenere l'architettura in gran parte condivisa, separandola solo dove le piattaforme differiscono davvero, come bufferOptions su Android, surfaceType su Android o il comportamento a schermo intero su iOS.
Se stai costruendo una UI a feed con expo-video, io partirei da qui.