# Membuat expo-video Berjalan Mulus di Feed ala TikTok

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

# Membangun Feed Video ala TikTok yang Mulus dengan expo-video

expo-video mudah dipakai kalau hanya ada satu player di layar.

Semuanya jadi lebih sulit saat aplikasi yang sama punya video hero, feed vertikal, baris horizontal, dan layar hasil dengan kontrol sungguhan.

Itulah setup saya, dan masalahnya sebenarnya bukan "bagaimana cara memutar video di Expo?"

Masalah sebenarnya adalah saya punya terlalu banyak permukaan video yang berbeda, dan saya memperlakukan semuanya seolah sama.

Itulah kesalahannya.

Beberapa permukaan sebaiknya membuat player lebih awal. Beberapa hanya boleh memutar saat sedang fokus. Beberapa sebaiknya tetap hanya menampilkan thumbnail sampai pengguna mendekat. Beberapa butuh jalur fallback kalau pemutaran remote macet.

Artikel ini ada karena perbaikannya bukan satu prop ajaib. Perbaikannya adalah mendefinisikan kebijakan pemutaran.

## Kenapa ini cepat jadi berantakan

Sebelum melakukan apa pun, saya memecah masalahnya menjadi empat keputusan:

- apakah permukaan ini perlu membuat player?
- apakah player ini harus sedang diputar saat ini?
- seberapa mahal player ini boleh menjadi?
- apa yang harus dilihat pengguna sebelum frame pertama muncul?

Begitu keputusan-keputusan itu dipisahkan, sisa arsitekturnya jadi jauh lebih mudah dipahami.

## Simpan expo-video di balik wrapper

Sebelum mengoptimasi apa pun, saya membungkus expo-video.

Saya tidak ingin pengaturan buffer, perilaku fullscreen, jenis surface, dan setup player tersebar di seluruh aplikasi. Sebuah wrapper sudah cukup untuk menyimpan pilihan-pilihan itu di satu tempat.

Dokumentasi resminya ada di sini: [dokumentasi 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,
  },
};
```

Wrapper itu tidak melakukan sesuatu yang ajaib. Ia hanya memberi saya satu tempat untuk mendefinisikan:

- player detail
- player preview
- player aktif di feed
- player tetangga di feed

Profil Android memang penting, tetapi itu hanya satu bagian dari setup. Peningkatan yang lebih besar datang dari mengontrol kapan player ada dan kapan player boleh memutar.

## Membuat player tidak sama dengan memutarnya

Inilah perubahan cara pikir yang paling penting.

Di layar feed, saya berhenti memperlakukan pembuatan player dan pemutaran sebagai hal yang sama.

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

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

Kedua boolean itu menyelesaikan masalah yang berbeda.

- `shouldCreatePlayer` menjawab apakah permukaan ini memang layak mendapat player
- `shouldPlay` menjawab apakah player itu harus berjalan saat ini

Perbedaan itu sangat penting di sebuah feed.

Kalau kamu melewatkannya, biasanya kamu berakhir dengan terlalu banyak player, terlalu banyak buffering, dan banyak pekerjaan yang sia-sia.

## State aktif dan tetangga di feed vertikal

Untuk feed utama, saya hanya membuat player untuk item yang aktif dan item di sebelahnya.

Dengan begitu kartu yang aktif terasa instan tanpa harus membayar harga penuh untuk seluruh list.

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

Kartu yang aktif mendapat profil yang lebih longgar.

Kartu tetangga mendapat profil yang lebih murah karena mungkin tidak akan pernah menjadi yang utama.

Tapi bagian yang lebih penting tetaplah aturan pemutarannya, bukan aturan buffer-nya.

Saya langsung melakukan mute dan pause pada item yang tidak aktif:

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

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

Bagian itu lintas platform. Itulah perubahan perilaku yang sebenarnya.

Di permukaan preview, saya juga tetap menonaktifkan `useCaching` di iOS. Itu bukan aturan umum expo-video. Itu keputusan untuk aplikasi ini karena caching preview lebih stabil bagi saya di Android dibandingkan di iOS.

## Render dengan thumbnail terlebih dahulu itu wajib

Kalau sebuah sel feed menampilkan kotak hitam saat player sedang bersiap, sel itu sudah terasa rusak.

Jadi saya selalu menjadikan thumbnail sebagai lapisan dasar dan baru menampilkan player setelah frame pertama dirender.

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

Gerbang opacity kecil itu membuat perbedaan besar.

Videonya tidak perlu muncul seketika. Videonya hanya perlu menggantikan thumbnail dengan rapi.

Bagian penting dari potongan itu adalah serah terima di frame pertama. Baris `textureView` hanyalah satu detail rendering khusus Android.

## Penyetelan khusus platform: bufferOptions dan surfaceType

Bagian ini butuh sedikit lebih banyak ketelitian.

expo-video menyediakan [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions) yang lintas platform, tetapi beberapa field di dalam objek itu khusus untuk platform tertentu.

Dalam praktiknya, artinya:

- `bufferOptions` sebagai API ada di Android dan iOS
- field seperti `minBufferForPlayback` dan `prioritizeTimeOverSizeThreshold` adalah pengaturan yang berfokus pada Android yang saya pakai di sini
- `waitsToMinimizeStalling` adalah pengaturan buffer khusus iOS di API yang sama
- [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) hanya untuk Android

Itulah yang memungkinkan saya membedakan antara:

- kartu feed yang aktif
- kartu feed tetangga
- player detail
- player preview

Itu juga alasan saya secara eksplisit memakai `textureView` di tempat yang melibatkan view video yang saling tumpang tindih atau transisi berlapis.

Dokumentasi Expo bahkan menyebut `surfaceType="textureView"` sebagai workaround untuk masalah `VideoView` yang tumpang tindih di Android.

Jadi saat saya menunjukkan kode seperti ini:

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

bagian itu sebenarnya tentang penyetelan biaya pemutaran di Android, bukan keseluruhan solusinya.

Solusi lengkapnya tetaplah kebijakan lifecycle seputar create, play, pause, mute, dan fallback.

## Baris horizontal butuh anggaran pemutaran

Feed bukan satu-satunya permukaan video di aplikasi ini.

Saya juga punya baris horizontal di layar home, dan baris-baris itu tidak boleh berperilaku seperti TikTok. Kalau setiap kartu yang terlihat di setiap baris yang terlihat mendapat player, kamu membakar terlalu banyak memori untuk permukaan yang sebenarnya tidak membutuhkannya.

Jadi saya menambahkan anggaran pemutaran per baris.

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

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

Itu memberi saya aturan sederhana:

- hanya beberapa kartu pertama yang memenuhi syarat di baris yang terlihat yang mendapat player
- sisanya tetap hanya menampilkan thumbnail

Saya juga sedikit menunda unmount saat sebuah kartu tidak lagi memenuhi syarat, supaya perubahan ambang batas yang cepat tidak membuat player dibuat dan dihancurkan terlalu agresif.

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

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

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

Hasilnya, baris horizontal terasa jauh lebih ringan daripada feed layar penuh.

## Hero tidak boleh berperilaku seperti feed

Hero punya masalah yang berbeda.

Saya ingin carousel terasa interaktif sambil tetap menampilkan video saat posisinya sudah diam.

Solusinya:

- geser thumbnail selama gesture berlangsung
- tampilkan video yang aktif sebagai overlay terpisah
- pudarkan overlay video saat sedang di-drag
- hanya putar saat hero terlihat, layar aktif, dan gesture sudah selesai

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

Cara itu bekerja lebih baik daripada mencoba menjadikan setiap slide hero sebagai player yang hidup.

## Layar hasil butuh player yang berbeda

Saya tidak memakai komponen player yang sama di mana-mana.

Kartu preview yang di-mute dan berulang tidak sama masalahnya dengan layar hasil penuh.

Layar hasil memakai `VideoPlayer` bersama dengan:

- kontrol pemutaran
- listener `playingChange`
- listener `timeUpdate`
- listener `statusChange`
- dukungan fullscreen di iOS
- pemutaran remote terlebih dahulu dengan fallback lokal

Kalau kamu memakai event-event itu, dokumentasi Expo yang relevan adalah:

- [Ringkasan event `playingChange` dan `statusChange`](https://docs.expo.dev/versions/latest/sdk/video/)
- [`timeUpdateEventInterval`](https://docs.expo.dev/versions/latest/sdk/video/#timeupdateeventinterval)

Cara pakainya sederhana:

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

Logika fallback-nya juga lugas.

Kalau player terlalu lama dalam status loading sebelum berhasil dimuat pertama kali, atau kalau player masuk ke status error, saya mengunduh MP4 ke direktori cache lalu mengganti source-nya.

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

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

Ini bukan soal optimasi mikro. Ini soal membuat layar hasil bisa diandalkan.

Kalau hasil yang sudah jadi dibuka lalu pemutarannya macet, seluruh fitur terasa rusak.

## Apa yang benar-benar penting

Kalau harus meringkas seluruh setup menjadi beberapa aturan praktis, inilah aturannya:

- simpan expo-video di balik wrapper
- pisahkan pembuatan player dari pemutaran
- perlakukan feed, baris, hero, dan layar hasil sebagai permukaan yang berbeda
- gunakan thumbnail sebagai default
- batasi pemutaran berdasarkan fokus dan status foreground
- pakai profil buffer Android sebagai detail, bukan keseluruhan strategi
- tambahkan jalur fallback untuk permukaan pemutaran yang penting

Poin terakhir itu penting.

Artikel ini sebenarnya bukan tentang satu flag buffer Android.

Kemenangan yang lebih besar adalah memutuskan:

- di mana sebuah player harus ada
- kapan player harus memutar
- kapan player harus tetap di-mute
- kapan thumbnail adalah default yang lebih baik
- permukaan mana yang layak mendapat jalur pemulihan

Begitu saya menerima hal itu, arsitekturnya jadi jauh lebih rapi.

## Hasil akhir

Seperti inilah tampilan feed setelah pembuatan player dipisahkan dari pemutaran dan item yang aktif dijadikan satu-satunya prioritas nyata:

<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"
  >
    Browser kamu tidak mendukung tag video.
  </video>
</div>

## Penutup

expo-video sendiri bukan bagian yang sulit di sini.

Bagian sulitnya adalah jujur tentang berapa banyak permukaan video berbeda yang sebenarnya dimiliki aplikasi ini.

Begitu saya berhenti memperlakukan semuanya dengan cara yang sama, feed mulai terasa jauh lebih baik.

Dan sebagai pujian untuk expo-video, begitu kebijakan pemutarannya jelas, library-nya sendiri bekerja dengan sangat baik.

Dengan `useVideoPlayer` dan `VideoView` di satu jalur kode lintas platform, arsitekturnya bisa sebagian besar dipakai bersama, dan hanya bercabang di tempat platformnya memang berbeda, seperti [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions) Android, [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) Android, atau perilaku fullscreen di iOS.

Kalau kamu sedang membangun UI bergaya feed dengan expo-video, dari situlah saya akan mulai.

