Construire un feed vidéo fluide façon TikTok avec expo-video
expo-video est simple quand il n’y a qu’un seul player à l’écran.
Ça se complique quand la même application a une vidéo hero, un feed vertical, des rangées horizontales et un écran de résultat avec de vrais contrôles.
C’était ma configuration, et le problème n’était pas vraiment « comment lire une vidéo dans Expo ? »
Le vrai problème, c’est que j’avais trop de surfaces vidéo différentes, et que je les traitais comme si elles étaient identiques.
C’était l’erreur.
Certaines surfaces doivent créer un player tôt. Certaines ne doivent lire la vidéo que lorsqu’elles ont le focus. Certaines doivent rester en simple miniature jusqu’à ce que l’utilisateur s’en approche. Certaines ont besoin d’une solution de repli si la lecture distante se bloque.
Cet article existe parce que la solution n’était pas une prop magique. La solution, c’était de définir une politique de lecture.
Pourquoi ça devient vite compliqué
Avant toute chose, j’ai découpé le problème en quatre décisions :
- cette surface doit-elle créer un player ?
- ce player doit-il être en lecture maintenant ?
- combien ce player doit-il coûter ?
- que doit voir l’utilisateur avant la première frame ?
Une fois ces décisions séparées, le reste de l’architecture est devenu beaucoup plus facile à comprendre.
Garder expo-video derrière un wrapper
Avant d’optimiser quoi que ce soit, j’ai enveloppé expo-video dans un wrapper.
Je ne voulais pas que les réglages de buffer, le comportement plein écran, le type de surface et la configuration du player soient éparpillés dans toute l’application. Un wrapper suffisait pour garder ces choix au même endroit.
La documentation officielle est ici : documentation d’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,
},
};
Ce wrapper ne fait rien de magique. Il me donne simplement un seul endroit pour définir :
- le player de détail
- le player d’aperçu
- le player actif du feed
- le player adjacent du feed
Les profils Android comptent, mais ils ne sont qu’une partie de la configuration. Les plus gros gains sont venus du contrôle du moment où les players existent et du moment où ils ont le droit de lire la vidéo.
Créer un player, ce n’est pas le lancer
C’était le changement de mentalité le plus important.
Dans l’écran du feed, j’ai arrêté de traiter la création du player et la lecture comme une seule et même chose.
const shouldCreatePlayer =
isTransitionFinished &&
(isActive || isAdjacent) &&
!!videoUrl;
const shouldPlay =
isActive &&
isAppInForeground &&
isScreenFocused;
Ces deux booléens résolvent des problèmes différents.
shouldCreatePlayerrépond à la question : cette surface mérite-t-elle seulement un player ?shouldPlayrépond à la question : ce player doit-il tourner maintenant ?
Cette distinction compte énormément dans un feed.
Si vous la sautez, vous vous retrouvez généralement avec trop de players, trop de buffering et beaucoup de travail inutile.
États actif et adjacent dans le feed vertical
Pour le feed principal, je ne crée des players que pour l’élément actif et ses voisins.
La carte active paraît ainsi instantanée sans qu’on paie le prix fort pour toute la liste.
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 carte active reçoit le profil le plus généreux.
La carte adjacente reçoit un profil moins coûteux, parce qu’elle ne deviendra peut-être jamais la principale.
Mais la partie la plus importante reste la règle de lecture, pas la règle de buffer.
Je coupe le son et je mets en pause les éléments non actifs immédiatement :
useEffect(() => {
if (!player) return;
if (shouldPlay) {
player.muted = false;
player.play();
} else {
player.muted = true;
player.pause();
}
}, [player, shouldPlay]);
Cette partie est multiplateforme. C’est elle qui change réellement le comportement.
Dans les surfaces d’aperçu, j’ai aussi gardé useCaching désactivé sur iOS. Ce n’est pas une règle universelle d’expo-video. C’était une décision propre à cette application, parce que le cache des aperçus était plus stable chez moi sur Android que sur iOS.
L’affichage de la miniature d’abord n’est pas négociable
Si une cellule du feed affiche un rectangle noir pendant que le player se prépare, elle paraît déjà cassée.
Je garde donc toujours la miniature comme couche de base et je ne révèle le player qu’après la première frame affichée.
<AppVideoView
player={player}
contentFit="cover"
nativeControls={false}
pointerEvents="none"
style={[
StyleSheet.absoluteFill,
{ opacity: hasFirstFrame ? 1 : 0 },
]}
androidSurfaceType="textureView"
onFirstFrameRender={() => setHasFirstFrame(true)}
/>
Ce petit filtre sur l’opacité fait une énorme différence.
La vidéo n’a pas besoin d’apparaître instantanément. Elle doit juste remplacer proprement la miniature.
La partie importante de cet extrait, c’est le passage de relais à la première frame. La ligne textureView n’est qu’un détail de rendu spécifique à Android.
Réglages spécifiques à chaque plateforme : bufferOptions et surfaceType
Cette partie demande un peu plus de précision.
expo-video expose des bufferOptions multiplateformes, mais certains champs de cet objet sont propres à une plateforme.
En pratique, ça veut dire que :
bufferOptionsexiste en tant qu’API sur Android et sur iOS- des champs comme
minBufferForPlaybacketprioritizeTimeOverSizeThresholdsont les leviers de réglage orientés Android que j’ai utilisés ici waitsToMinimizeStallingest un réglage de buffer propre à iOS dans la même APIsurfaceTypen’existe que sur Android
C’est ce qui m’a permis de différencier :
- les cartes actives du feed
- les cartes adjacentes du feed
- les players de détail
- les players d’aperçu
C’est aussi pour ça que j’ai utilisé explicitement textureView aux endroits où des vues vidéo superposées ou des transitions en couches comptaient.
La documentation d’Expo mentionne même surfaceType="textureView" comme contournement pour les problèmes de VideoView superposées sur Android.
Donc quand je montre du code comme celui-ci :
const player = useAppVideoPlayer(videoSource, {
loop: true,
muted: true,
androidBufferProfile: isActive
? "feed-active"
: "feed-adjacent",
});
cette section porte en réalité sur le réglage du coût de lecture sur Android, pas sur la solution complète.
La solution complète reste la politique de cycle de vie autour de la création, de la lecture, de la pause, de la coupure du son et du repli.
Les rangées horizontales ont besoin d’un budget de lecture
Le feed n’était pas la seule surface vidéo de l’application.
J’avais aussi des rangées horizontales sur l’écran d’accueil, et ces rangées ne peuvent pas se comporter comme TikTok. Si chaque carte visible de chaque rangée visible reçoit un player, vous gaspillez trop de mémoire pour une surface qui n’en a pas besoin.
J’ai donc ajouté un budget de lecture par rangée.
const remainingSlots = heroVisible ? 3 : 4;
const rowBudget = Math.min(2, remainingSlots);
const shouldPlayCard =
isRowVisible &&
isCardVisibleHorizontally &&
cardIndex < rowBudget;
Ça m’a donné une règle simple :
- seules les premières cartes éligibles des rangées visibles reçoivent un player
- tout le reste reste en simple miniature
J’ai aussi légèrement retardé le démontage quand une carte perd son éligibilité, pour que des changements rapides de seuil ne créent et ne détruisent pas les players trop agressivement.
useEffect(() => {
if (shouldPlay) {
setShouldRenderVideo(true);
return;
}
const timeout = setTimeout(() => {
setShouldRenderVideo(false);
}, 180);
return () => clearTimeout(timeout);
}, [shouldPlay]);
Grâce à ça, les rangées horizontales sont devenues bien moins coûteuses que le feed plein écran.
Le hero ne doit pas se comporter comme le feed
Le hero posait un autre problème.
Je voulais que le carrousel reste interactif tout en affichant la vidéo une fois stabilisé.
La solution était de :
- faire glisser les miniatures pendant le geste
- afficher la vidéo active dans un overlay séparé
- faire disparaître progressivement l’overlay vidéo pendant le glissement
- ne lancer la lecture que si le hero est visible, si l’écran est actif et si le geste est terminé
const shouldPlayHero =
isScreenActive &&
isHeroVisible &&
isSettled &&
!!activeVideoUrl;
Ça fonctionnait mieux que d’essayer de garder chaque slide du hero comme un player actif.
L’écran de résultat a besoin d’un autre player
Je n’ai pas utilisé le même composant player partout.
Des cartes d’aperçu muettes en boucle et un écran de résultat complet ne posent pas le même problème.
L’écran de résultat utilise un VideoPlayer partagé avec :
- des contrôles de lecture
- des listeners
playingChange - des listeners
timeUpdate - des listeners
statusChange - la prise en charge du plein écran sur iOS
- une lecture distante en priorité avec repli en local
Si vous utilisez ces événements, voici la documentation Expo utile :
L’utilisation est simple :
<VideoPlayer
uri={videoUrl}
controlsVariant="playback"
muted={false}
loop={false}
androidBufferProfile="detail"
iosAllowFullscreen
fallbackToLocal
fallbackTimeoutMs={8000}
/>
La logique de repli est directe.
Si le player reste trop longtemps en chargement avant le premier chargement réussi, ou s’il passe en état d’erreur, je télécharge le MP4 dans le dossier de cache et je remplace la source.
if (
fallbackToLocal &&
!fallbackApplied.current &&
!hasLoadedOnce.current
) {
fallbackTimer.current = setTimeout(() => {
startLocalFallback();
}, fallbackTimeoutMs);
}
if (status === "error" && fallbackToLocal) {
startLocalFallback();
}
Il ne s’agit pas de micro-optimisation. Il s’agit de rendre l’écran de résultat fiable.
Si un résultat terminé s’ouvre et que la lecture se bloque, toute la fonctionnalité paraît cassée.
Ce qui comptait vraiment
Si je devais résumer toute la configuration en quelques règles pratiques, ce seraient celles-ci :
- garder expo-video derrière un wrapper
- séparer la création du player de la lecture
- traiter le feed, les rangées, le hero et les écrans de résultat comme des surfaces différentes
- afficher les miniatures d’abord, par défaut
- conditionner la lecture au focus et au premier plan
- utiliser les profils de buffer Android comme un détail, pas comme toute la stratégie
- ajouter une solution de repli pour les surfaces de lecture importantes
Ce dernier point compte.
Cet article ne parle pas vraiment d’un flag de buffer Android.
Le vrai gain a été de décider :
- où un player doit exister
- quand il doit lire la vidéo
- quand il doit rester muet
- quand une miniature est le meilleur choix par défaut
- quelles surfaces méritent une solution de reprise
Une fois que j’ai accepté ça, l’architecture est devenue beaucoup plus propre.
Résultat final
Voici à quoi ressemblait le feed après avoir séparé la création du player de la lecture et fait de l’élément actif la seule vraie priorité :
Pour conclure
Ici, la difficulté ne venait pas d’expo-video lui-même.
La difficulté, c’était d’être honnête sur le nombre de surfaces vidéo différentes que l’application avait réellement.
Dès que j’ai arrêté de toutes les traiter de la même façon, le feed est devenu beaucoup plus agréable.
Et pour rendre justice à expo-video, une fois la politique de lecture clarifiée, la bibliothèque a très bien fait son travail.
Avoir useVideoPlayer et VideoView sur un seul chemin de code multiplateforme m’a permis de garder une architecture en grande partie partagée, et de ne diverger que là où les plateformes diffèrent vraiment, comme les bufferOptions d’Android, le surfaceType d’Android ou le comportement plein écran d’iOS.
Si vous construisez une interface de type feed avec expo-video, c’est par là que je commencerais.