# expo-video in einem Feed im TikTok-Stil zum Laufen bringen

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

# Ein flüssiger Video-Feed im TikTok-Stil mit expo-video

expo-video ist einfach, solange nur ein Player auf dem Screen ist.

Schwieriger wird es, wenn dieselbe App ein Hero-Video, einen vertikalen Feed, horizontale Reihen und einen Ergebnis-Screen mit echten Controls hat.

Genau das war mein Setup, und das Problem war eigentlich nicht "Wie spiele ich ein Video in Expo ab?"

Das eigentliche Problem war, dass ich zu viele verschiedene Video-Oberflächen hatte und sie alle so behandelt habe, als wären sie dasselbe.

Das war der Fehler.

Manche Oberflächen sollten früh einen Player erzeugen. Manche sollten nur abspielen, wenn sie im Fokus sind. Manche sollten nur ein Thumbnail zeigen, bis der Nutzer in die Nähe kommt. Manche brauchen einen Fallback, wenn die Remote-Wiedergabe hängt.

Diesen Artikel gibt es, weil die Lösung nicht ein magisches Prop war. Die Lösung war, eine Playback-Policy festzulegen.

## Warum das schnell unübersichtlich wird

Als Erstes habe ich das Problem in vier Entscheidungen aufgeteilt:

- Soll diese Oberfläche einen Player erzeugen?
- Soll dieser Player gerade abspielen?
- Wie teuer darf dieser Player sein?
- Was soll der Nutzer vor dem ersten Frame sehen?

Sobald diese Entscheidungen getrennt waren, ließ sich der Rest der Architektur viel leichter durchdenken.

## expo-video hinter einem Wrapper halten

Bevor ich irgendetwas optimiert habe, habe ich expo-video in einen Wrapper gepackt.

Ich wollte nicht, dass Buffer-Einstellungen, Fullscreen-Verhalten, Surface-Typ und Player-Setup über die ganze App verstreut sind. Ein Wrapper hat gereicht, um diese Entscheidungen an einem Ort zu halten.

Die offizielle Dokumentation findest du hier: [expo-video-Dokumentation](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,
  },
};
```

Dieser Wrapper macht nichts Magisches. Er gibt mir nur einen Ort, an dem ich Folgendes definiere:

- Detail-Player
- Preview-Player
- aktiver Feed-Player
- benachbarter Feed-Player

Die Android-Profile sind wichtig, aber sie sind nur ein Teil des Setups. Die größeren Gewinne kamen daher, zu steuern, wann Player existieren und wann sie abspielen dürfen.

## Einen Player zu erzeugen ist nicht dasselbe wie ihn abzuspielen

Das war das wichtigste Umdenken.

Im Feed-Screen habe ich aufgehört, das Erzeugen eines Players und das Abspielen als dasselbe zu behandeln.

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

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

Diese zwei Booleans lösen unterschiedliche Probleme.

- `shouldCreatePlayer` beantwortet, ob die Oberfläche überhaupt einen Player verdient
- `shouldPlay` beantwortet, ob dieser Player gerade laufen soll

Diese Unterscheidung ist in einem Feed extrem wichtig.

Wenn du sie überspringst, landest du meistens bei zu vielen Playern, zu viel Buffering und viel sinnloser Arbeit.

## Aktive und benachbarte Zustände im vertikalen Feed

Im Haupt-Feed erzeuge ich Player nur für das aktive Item und die Items direkt daneben.

So fühlt sich die aktive Karte sofort an, ohne dass ich den vollen Preis für die ganze Liste zahle.

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

Die aktive Karte bekommt das großzügigere Profil.

Die benachbarte Karte bekommt ein günstigeres, weil sie vielleicht nie zur primären wird.

Aber der wichtigere Teil ist immer noch die Playback-Regel, nicht die Buffer-Regel.

Nicht aktive Items schalte ich sofort stumm und pausiere sie:

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

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

Dieser Teil ist plattformübergreifend. Das ist die eigentliche Verhaltensänderung.

In Preview-Oberflächen habe ich außerdem `useCaching` auf iOS deaktiviert gelassen. Das ist keine allgemeine expo-video-Regel. Es war eine Entscheidung für diese App, weil das Caching von Previews bei mir auf Android stabiler war als auf iOS.

## Thumbnail zuerst rendern ist nicht verhandelbar

Wenn eine Feed-Zelle ein schwarzes Rechteck zeigt, während der Player warmläuft, fühlt sie sich schon kaputt an.

Deshalb behalte ich das Thumbnail immer als unterste Ebene und blende den Player erst nach dem ersten gerenderten Frame ein.

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

Dieses kleine Opacity-Gate macht einen riesigen Unterschied.

Das Video muss nicht sofort erscheinen. Es muss nur sauber das Thumbnail ersetzen.

Der wichtige Teil in diesem Snippet ist die Übergabe beim ersten Frame. Die Zeile mit `textureView` ist nur ein Android-spezifisches Rendering-Detail.

## Plattformspezifisches Tuning: bufferOptions und surfaceType

Dieser Teil braucht etwas mehr Präzision.

expo-video stellt plattformübergreifende [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions) bereit, aber einige der einzelnen Felder in diesem Objekt sind plattformspezifisch.

In der Praxis heißt das:

- `bufferOptions` als API gibt es auf Android und iOS
- Felder wie `minBufferForPlayback` und `prioritizeTimeOverSizeThreshold` sind die Android-orientierten Stellschrauben, die ich hier genutzt habe
- `waitsToMinimizeStalling` ist eine iOS-spezifische Buffer-Einstellung in derselben API
- [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) gibt es nur auf Android

Damit konnte ich unterscheiden zwischen:

- aktiven Feed-Karten
- benachbarten Feed-Karten
- Detail-Playern
- Preview-Playern

Deshalb habe ich auch explizit `textureView` an Stellen genutzt, an denen sich überlappende Video-Views oder geschichtete Übergänge eine Rolle gespielt haben.

Die Expo-Dokumentation nennt `surfaceType="textureView"` sogar ausdrücklich als Workaround für Probleme mit überlappenden `VideoView`-Komponenten auf Android.

Wenn ich also Code wie diesen zeige:

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

dann geht es in diesem Abschnitt eigentlich um das Tuning der Playback-Kosten auf Android, nicht um die ganze Lösung.

Die vollständige Lösung ist immer noch die Lifecycle-Policy rund um Erzeugen, Abspielen, Pausieren, Stummschalten und Fallback.

## Horizontale Reihen brauchen ein Playback-Budget

Der Feed war nicht die einzige Video-Oberfläche in der App.

Ich hatte auch horizontale Reihen auf dem Home-Screen, und diese Reihen dürfen sich nicht wie TikTok verhalten. Wenn jede sichtbare Karte in jeder sichtbaren Reihe einen Player bekommt, verbrennst du zu viel Speicher für eine Oberfläche, die das nicht braucht.

Also habe ich ein Playback-Budget pro Reihe eingeführt.

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

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

Das gab mir eine einfache Regel:

- nur die ersten paar geeigneten Karten in sichtbaren Reihen bekommen Player
- alles andere zeigt nur ein Thumbnail

Außerdem habe ich das Unmount leicht verzögert, wenn eine Karte nicht mehr geeignet ist, damit schnelle Wechsel an der Schwelle die Player nicht zu aggressiv auf- und abbauen.

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

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

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

Dadurch fühlten sich die horizontalen Reihen viel günstiger an als der Vollbild-Feed.

## Der Hero sollte sich nicht wie der Feed verhalten

Der Hero hatte ein anderes Problem.

Ich wollte, dass sich das Karussell interaktiv anfühlt und trotzdem ein Video zeigt, wenn es zur Ruhe gekommen ist.

Die Lösung war:

- während der Geste die Thumbnails schieben
- das aktive Video als separates Overlay zeigen
- das Video-Overlay beim Ziehen ausblenden
- nur abspielen, wenn der Hero sichtbar ist, der Screen aktiv ist und die Geste abgeschlossen ist

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

Das hat besser funktioniert, als jede Hero-Slide als laufenden Player zu halten.

## Der Ergebnis-Screen braucht einen anderen Player

Ich habe nicht überall dieselbe Player-Komponente verwendet.

Stumme Preview-Karten in Dauerschleife und ein vollständiger Ergebnis-Screen sind nicht dasselbe Problem.

Der Ergebnis-Screen nutzt einen gemeinsamen `VideoPlayer` mit:

- Playback-Controls
- `playingChange`-Listenern
- `timeUpdate`-Listenern
- `statusChange`-Listenern
- Fullscreen-Unterstützung auf iOS
- Remote-Wiedergabe zuerst, mit lokalem Fallback

Wenn du diese Events nutzt, ist das hier die passende Expo-Dokumentation:

- [Überblick über die Events `playingChange` und `statusChange`](https://docs.expo.dev/versions/latest/sdk/video/)
- [`timeUpdateEventInterval`](https://docs.expo.dev/versions/latest/sdk/video/#timeupdateeventinterval)

Die Verwendung ist einfach:

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

Die Fallback-Logik ist geradlinig.

Wenn der Player vor dem ersten erfolgreichen Laden zu lange im Ladezustand bleibt oder in einen Fehlerzustand wechselt, lade ich die MP4 in das Cache-Verzeichnis herunter und tausche die Quelle aus.

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

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

Dabei geht es nicht um Mikro-Optimierung. Es geht darum, den Ergebnis-Screen zuverlässig zu machen.

Wenn sich ein fertiges Ergebnis öffnet und die Wiedergabe hängt, fühlt sich das ganze Feature kaputt an.

## Was wirklich gezählt hat

Wenn ich das ganze Setup auf ein paar praktische Regeln herunterbrechen müsste, wären es diese:

- expo-video hinter einem Wrapper halten
- das Erzeugen eines Players vom Abspielen trennen
- Feed, Reihen, Hero und Ergebnis-Screens als unterschiedliche Oberflächen behandeln
- standardmäßig zuerst Thumbnails zeigen
- Playback an Fokus und Vordergrund-Zustand knüpfen
- Android-Buffer-Profile als Detail nutzen, nicht als ganze Strategie
- einen Fallback für wichtige Playback-Oberflächen einbauen

Der letzte Punkt ist wichtig.

In diesem Artikel geht es eigentlich nicht um ein einzelnes Android-Buffer-Flag.

Der größere Gewinn war, zu entscheiden:

- wo ein Player existieren soll
- wann er abspielen soll
- wann er stumm bleiben soll
- wann ein Thumbnail der bessere Standard ist
- welche Oberflächen einen Wiederherstellungspfad verdienen

Sobald ich das akzeptiert hatte, wurde die Architektur viel sauberer.

## Endergebnis

So sah der Feed aus, nachdem ich das Erzeugen von Playern vom Abspielen getrennt und das aktive Item als einzige echte Priorität behalten hatte:

<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"
  >
    Dein Browser unterstützt das Video-Tag nicht.
  </video>
</div>


## Fazit

expo-video selbst war hier nicht der schwierige Teil.

Der schwierige Teil war, ehrlich zu sein, wie viele verschiedene Video-Oberflächen die App tatsächlich hatte.

Sobald ich aufgehört habe, alle gleich zu behandeln, fühlte sich der Feed viel besser an.

Und um expo-video etwas Anerkennung zu geben: Sobald die Playback-Policy klar war, hat die Library ihren Job sehr gut gemacht.

Weil `useVideoPlayer` und `VideoView` auf einem plattformübergreifenden Code-Pfad laufen, konnte ich die Architektur größtenteils gemeinsam halten und nur dort verzweigen, wo sich die Plattformen wirklich unterscheiden, etwa bei Android-[`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions), Android-[`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) oder dem Fullscreen-Verhalten auf iOS.

Wenn du eine UI im Feed-Stil mit expo-video baust, würde ich genau dort anfangen.

