# Så fick jag expo-video att fungera i ett flöde i TikTok-stil

By Tarik Pinarci (https://tarikpinarci.com). Published 2026-01-10. Canonical: https://tarikpinarci.com/sv/blog/making-expo-video-work-in-feed-style-uis

# Bygga ett smidigt videoflöde i TikTok-stil med expo-video

expo-video är enkelt när det bara finns en spelare på skärmen.

Det blir svårare när samma app har en hero-video, ett vertikalt flöde, horisontella rader och en resultatskärm med riktiga kontroller.

Så såg min app ut, och problemet var egentligen inte "hur spelar jag upp en video i Expo?"

Det verkliga problemet var att jag hade för många olika videoytor och behandlade dem som om de var samma sak.

Det var misstaget.

Vissa ytor ska skapa en spelare tidigt. Vissa ska bara spela när de är i fokus. Vissa ska bara visa en miniatyrbild tills användaren kommer nära. Vissa behöver en reservväg om fjärruppspelningen hackar.

Den här artikeln finns för att lösningen inte var en magisk prop. Lösningen var att definiera en policy för uppspelning.

## Varför det här blir rörigt snabbt

Innan något annat delade jag upp problemet i fyra beslut:

- ska den här ytan skapa en spelare?
- ska den här spelaren spela just nu?
- hur dyr får den här spelaren vara?
- vad ska användaren se innan den första bildrutan?

När de besluten väl var separerade blev resten av arkitekturen mycket lättare att resonera kring.

## Håll expo-video bakom en wrapper

Innan jag optimerade något lade jag expo-video bakom en wrapper.

Jag ville inte ha buffertinställningar, fullskärmsbeteende, yttyp och konfiguration av spelaren utspridda i hela appen. En wrapper räckte för att samla de valen på ett ställe.

Den officiella dokumentationen finns här: [dokumentation för expo-video](https://docs.expo.dev/versions/latest/sdk/video/).

```tsx
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,
  },
};
```

Den wrappern gör inget magiskt. Den ger mig bara ett ställe där jag definierar:

- spelare för detaljvy
- spelare för förhandsvisning
- aktiv spelare i flödet
- angränsande spelare i flödet

Android-profilerna spelar roll, men de är bara en del av uppsättningen. De större vinsterna kom av att styra när spelare finns och när de får spela.

## Att skapa en spelare är inte samma sak som att spela upp

Det här var det viktigaste skiftet i hur jag tänkte.

På flödesskärmen slutade jag behandla skapandet av spelaren och uppspelningen som samma sak.

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

const shouldPlay =
  isActive &&
  isAppInForeground &&
  isScreenFocused;
```

De två booleska värdena löser olika problem.

- `shouldCreatePlayer` svarar på om ytan ens förtjänar en spelare
- `shouldPlay` svarar på om spelaren ska köras just nu

Den skillnaden spelar stor roll i ett flöde.

Om du hoppar över den får du oftast för många spelare, för mycket buffring och en massa meningslöst arbete.

## Aktiva och angränsande lägen i det vertikala flödet

I huvudflödet skapar jag bara spelare för det aktiva elementet och elementen bredvid.

Det gör att det aktiva kortet känns omedelbart utan att jag betalar fullt pris för hela listan.

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

Det aktiva kortet får den generösare profilen.

Det angränsande kortet får en billigare, eftersom det kanske aldrig blir det primära.

Men den viktigare delen är fortfarande regeln för uppspelning, inte regeln för bufferten.

Jag stänger av ljudet och pausar icke-aktiva element direkt:

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

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

Den delen är plattformsoberoende. Det är den som faktiskt ändrar beteendet.

På ytor för förhandsvisning höll jag också `useCaching` avstängt på iOS. Det är ingen allmän regel för expo-video. Det var ett beslut för den här appen, eftersom cachning av förhandsvisningar var stabilare för mig på Android än på iOS.

## Miniatyrbild först är inte förhandlingsbart

Om en cell i flödet visar en svart rektangel medan spelaren värms upp känns den redan trasig.

Så jag behåller alltid miniatyrbilden som baslager och visar spelaren först efter den första renderade bildrutan.

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

Den lilla opacitetsspärren gör en enorm skillnad.

Videon behöver inte dyka upp direkt. Den behöver bara ersätta miniatyrbilden snyggt.

Det viktiga i den kodsnutten är överlämningen vid första bildrutan. Raden med `textureView` är bara en Android-specifik renderingsdetalj.

## Plattformsspecifik finjustering: bufferOptions och surfaceType

Den här delen kräver lite mer precision.

expo-video exponerar plattformsoberoende [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions), men några av de enskilda fälten i det objektet är plattformsspecifika.

I praktiken betyder det:

- `bufferOptions` som API finns på både Android och iOS
- fält som `minBufferForPlayback` och `prioritizeTimeOverSizeThreshold` är de Android-fokuserade rattarna jag använde här
- `waitsToMinimizeStalling` är en iOS-specifik buffertinställning i samma API
- [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) finns bara på Android

Det var det som lät mig skilja mellan:

- aktiva kort i flödet
- angränsande kort i flödet
- spelare för detaljvy
- spelare för förhandsvisning

Det är också därför jag uttryckligen använde `textureView` där överlappande videovyer eller övergångar i lager spelade roll.

Expo-dokumentationen nämner till och med `surfaceType="textureView"` som en lösning på problem med överlappande `VideoView` på Android.

Så när jag visar kod som den här:

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

handlar det avsnittet egentligen om att finjustera kostnaden för uppspelning på Android, inte om hela lösningen.

Hela lösningen är fortfarande livscykelpolicyn kring att skapa, spela, pausa, stänga av ljudet och falla tillbaka.

## Horisontella rader behöver en budget för uppspelning

Flödet var inte den enda videoytan i appen.

Jag hade också horisontella rader på startskärmen, och de raderna kan inte bete sig som TikTok. Om varje synligt kort i varje synlig rad får en spelare bränner du för mycket minne på en yta som inte behöver det.

Så jag lade till en budget för uppspelning per rad.

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

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

Det gav mig en enkel regel:

- bara de första få kvalificerade korten i synliga rader får spelare
- allt annat visar bara miniatyrbilder

Jag fördröjde också avmonteringen lite när ett kort inte längre kvalificerar sig, så att snabba ändringar kring gränsvärdet inte skapar och river spelare alltför aggressivt.

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

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

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

Det gjorde att de horisontella raderna kändes mycket billigare än helskärmsflödet.

## Hero-ytan ska inte bete sig som flödet

Hero-ytan hade ett annat problem.

Jag ville att karusellen skulle kännas interaktiv men ändå visa video när den hade stannat.

Lösningen var:

- låt miniatyrbilder glida under gesten
- visa den aktiva videon som ett separat lager ovanpå
- tona ut videolagret medan man drar
- spela bara när hero-ytan syns, skärmen är aktiv och gesten har stannat

```tsx
const shouldPlayHero =
  isScreenActive &&
  isHeroVisible &&
  isSettled &&
  !!activeVideoUrl;
```

Det fungerade bättre än att försöka hålla varje hero-bild som en levande spelare.

## Resultatskärmen behöver en annan spelare

Jag använde inte samma spelarkomponent överallt.

Ljudlösa förhandsvisningskort i loop och en fullständig resultatskärm är inte samma problem.

Resultatskärmen använder en delad `VideoPlayer` med:

- uppspelningskontroller
- lyssnare för `playingChange`
- lyssnare för `timeUpdate`
- lyssnare för `statusChange`
- fullskärmsstöd på iOS
- fjärruppspelning först med lokal reserv

Om du använder de här händelserna är de relevanta Expo-dokumenten:

- [översikt över händelserna `playingChange` och `statusChange`](https://docs.expo.dev/versions/latest/sdk/video/)
- [`timeUpdateEventInterval`](https://docs.expo.dev/versions/latest/sdk/video/#timeupdateeventinterval)

Användningen är enkel:

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

Reservlogiken är rak.

Om spelaren stannar för länge i laddningsläget innan den första lyckade laddningen, eller om den hamnar i ett feltillstånd, laddar jag ner MP4-filen till cachekatalogen och byter källa.

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

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

Det handlar inte om mikrooptimering. Det handlar om att göra resultatskärmen pålitlig.

Om ett färdigt resultat öppnas och uppspelningen hackar känns hela funktionen trasig.

## Det som faktiskt spelade roll

Om jag skulle koka ner hela uppsättningen till några praktiska regler blir det dessa:

- håll expo-video bakom en wrapper
- separera skapandet av spelaren från uppspelningen
- behandla flöde, rader, hero och resultatskärmar som olika ytor
- börja med miniatyrbilder som standard
- låt uppspelning bero på fokus och förgrundsläge
- använd buffertprofiler för Android som en detalj, inte som hela strategin
- lägg till en reservväg för viktiga uppspelningsytor

Den sista punkten spelar roll.

Den här artikeln handlar egentligen inte om en enskild buffertflagga på Android.

Den större vinsten var att bestämma:

- var en spelare ska finnas
- när den ska spela
- när den ska vara ljudlös
- när en miniatyrbild är det bättre standardvalet
- vilka ytor som förtjänar en väg tillbaka vid fel

När jag väl accepterade det blev arkitekturen mycket renare.

## Slutresultat

Så här såg flödet ut efter att jag separerat skapandet av spelare från uppspelningen och låtit det aktiva elementet vara den enda verkliga prioriteten:

<div style="display:flex; justify-content:center; margin: 24px 0 32px;">
  <video
    controls
    playsinline
    muted
    loop
    data-autoplay="viewport"
    preload="none"
    poster="/images/blog/expo-video-feed-demo-poster.jpg"
    style="width:100%; max-width:360px; border-radius:24px; box-shadow:0 24px 60px rgba(0,0,0,0.35); background:#000;"
    src="/videos/blog/expo-video-feed/01-vertical-feed-final-demo.mp4"
  >
    Din webbläsare har inte stöd för videotaggen.
  </video>
</div>

## Avslutande tankar

expo-video i sig var inte det svåra här.

Det svåra var att vara ärlig med hur många olika videoytor appen faktiskt hade.

När jag slutade behandla dem alla likadant började flödet kännas mycket bättre.

Och för att ge expo-video lite cred: när policyn för uppspelning väl var tydlig gjorde biblioteket sitt jobb väldigt bra.

Att ha `useVideoPlayer` och `VideoView` på en och samma plattformsoberoende kodväg gjorde det möjligt att hålla arkitekturen mestadels delad och bara förgrena där plattformarna faktiskt skiljer sig, som [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions) på Android, [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) på Android eller fullskärmsbeteendet på iOS.

Om du bygger ett gränssnitt i flödesstil med expo-video är det där jag skulle börja.

