# expo-video'yu TikTok Tarzı Bir Feed'de Çalıştırmak

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

# expo-video ile Akıcı, TikTok Tarzı Bir Video Feed'i Oluşturmak

Ekranda tek bir player olduğunda expo-video kolay.

Aynı uygulamada bir hero video, dikey bir feed, yatay satırlar ve gerçek kontrolleri olan bir sonuç ekranı olduğunda iş zorlaşıyor.

Benim kurulumum buydu ve asıl problem "Expo'da nasıl video oynatırım?" değildi.

Asıl problem, çok fazla farklı video yüzeyim olması ve hepsine aynı şeymiş gibi davranmamdı.

Hata buydu.

Bazı yüzeyler player'ı erkenden oluşturmalı. Bazıları sadece odaktayken oynatmalı. Bazıları kullanıcı yaklaşana kadar sadece thumbnail göstermeli. Bazılarının ise uzaktan oynatma takılırsa bir yedek (fallback) yolu olmalı.

Bu yazı, çözüm tek bir sihirli prop olmadığı için var. Çözüm, bir oynatma politikası tanımlamaktı.

## Bu iş neden bu kadar çabuk karışıyor

Her şeyden önce problemi dört karara böldüm:

- bu yüzey bir player oluşturmalı mı?
- bu player şu anda oynatıyor olmalı mı?
- bu player ne kadar maliyetli olmalı?
- kullanıcı ilk kareden önce ne görmeli?

Bu kararlar birbirinden ayrıldığında, mimarinin geri kalanı üzerine düşünmek çok daha kolaylaştı.

## expo-video'yu bir wrapper'ın arkasında tutun

Herhangi bir şeyi optimize etmeden önce expo-video'yu bir wrapper ile sardım.

Buffer ayarlarının, tam ekran davranışının, surface tipinin ve player kurulumunun uygulamanın her yerine dağılmasını istemedim. Bu seçimleri tek bir yerde tutmak için bir wrapper yeterliydi.

Resmi dokümantasyon burada: [expo-video dokümantasyonu](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,
  },
};
```

Bu wrapper sihirli bir şey yapmıyor. Sadece şunları tanımlayabileceğim tek bir yer sağlıyor:

- detay player'ı
- önizleme player'ı
- feed'deki aktif player
- feed'deki komşu player

Android profilleri önemli, ama kurulumun sadece bir parçası. Asıl büyük kazanç, player'ların ne zaman var olacağını ve ne zaman oynatmalarına izin verileceğini kontrol etmekten geldi.

## Player oluşturmak, onu oynatmakla aynı şey değil

En önemli zihinsel değişim buydu.

Feed ekranında player oluşturmaya ve oynatmaya aynı şeymiş gibi davranmayı bıraktım.

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

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

Bu iki boolean farklı problemleri çözüyor.

- `shouldCreatePlayer`, yüzeyin bir player'ı hak edip etmediği sorusunu cevaplıyor
- `shouldPlay`, o player'ın şu anda çalışıp çalışmaması gerektiği sorusunu cevaplıyor

Bu ayrım bir feed'de çok önemli.

Bunu atlarsanız genelde çok fazla player, çok fazla buffering ve bir sürü anlamsız işle karşılaşırsınız.

## Dikey feed'de aktif ve komşu durumlar

Ana feed'de player'ları sadece aktif öğe ve ona komşu öğeler için oluşturuyorum.

Bu, tüm liste için tam bedel ödemeden aktif kartın anında açılıyormuş gibi hissettirmesini sağlıyor.

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

Aktif kart daha cömert profili alıyor.

Komşu kart daha ucuz bir profil alıyor, çünkü belki hiç birincil olmayacak.

Ama daha önemli olan kısım hâlâ buffer kuralı değil, oynatma kuralı.

Aktif olmayan öğeleri hemen sessize alıp duraklatıyorum:

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

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

Bu kısım cross-platform. Asıl davranış değişikliği bu.

Önizleme yüzeylerinde iOS'ta `useCaching`'i de kapalı tuttum. Bu evrensel bir expo-video kuralı değil. Bu uygulama için verilmiş bir karardı, çünkü önizleme önbelleği benim için Android'de iOS'tan daha stabildi.

## Önce thumbnail ile render etmek pazarlık konusu değil

Bir feed hücresi player ısınırken siyah bir dikdörtgen gösteriyorsa, zaten bozuk hissettiriyor demektir.

Bu yüzden thumbnail'ı her zaman temel katman olarak tutuyorum ve player'ı ancak ilk kare render edildikten sonra gösteriyorum.

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

Bu küçük opacity kapısı çok büyük fark yaratıyor.

Videonun anında görünmesi gerekmiyor. Sadece thumbnail'ın yerini temiz bir şekilde alması gerekiyor.

O kod parçasındaki önemli kısım ilk kare devri. `textureView` satırı sadece Android'e özel bir render detayı.

## Platforma özel ayarlar: bufferOptions ve surfaceType

Bu kısım biraz daha kesinlik gerektiriyor.

expo-video cross-platform [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions) sunuyor, ama bu nesnenin içindeki bazı alanlar platforma özel.

Pratikte bunun anlamı şu:

- bir API olarak `bufferOptions` hem Android'de hem iOS'ta var
- `minBufferForPlayback` ve `prioritizeTimeOverSizeThreshold` gibi alanlar burada kullandığım, Android odaklı ayar düğmeleri
- `waitsToMinimizeStalling` aynı API içinde iOS'a özel bir buffer ayarı
- [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) sadece Android'de var

Şunları birbirinden ayırmamı sağlayan da bu oldu:

- aktif feed kartları
- komşu feed kartları
- detay player'ları
- önizleme player'ları

Üst üste binen video view'ların ya da katmanlı geçişlerin önemli olduğu yerlerde `textureView`'ı açıkça kullanmamın sebebi de bu.

Expo dokümantasyonu bile Android'de üst üste binen `VideoView` sorunları için geçici çözüm olarak `surfaceType="textureView"`'ı özellikle belirtiyor.

Yani şuna benzer bir kod gösterdiğimde:

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

o bölüm aslında çözümün tamamı değil, Android'de oynatma maliyetini ayarlamakla ilgili.

Çözümün tamamı yine oluşturma, oynatma, duraklatma, sessize alma ve fallback etrafındaki yaşam döngüsü politikası.

## Yatay satırların bir oynatma bütçesine ihtiyacı var

Uygulamadaki tek video yüzeyi feed değildi.

Ana ekranda yatay satırlarım da vardı ve bu satırlar TikTok gibi davranamaz. Görünen her satırdaki görünen her kart bir player alırsa, buna ihtiyacı olmayan bir yüzey için çok fazla bellek harcarsınız.

Bu yüzden satır seviyesinde bir oynatma bütçesi ekledim.

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

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

Bu bana basit bir kural verdi:

- görünen satırlarda sadece ilk birkaç uygun kart player alıyor
- geri kalan her şey sadece thumbnail olarak kalıyor

Bir kart uygunluğunu kaybettiğinde unmount'u da biraz geciktirdim, böylece eşikteki hızlı değişimler player'ları gereğinden agresif şekilde oluşturup yok etmiyor.

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

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

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

Bu sayede yatay satırlar tam ekran feed'den çok daha ucuz hissettirdi.

## Hero, feed gibi davranmamalı

Hero'nun farklı bir problemi vardı.

Carousel'in etkileşimli hissettirmesini, ama yerine oturduğunda da video göstermesini istiyordum.

Çözüm şuydu:

- hareket (gesture) sırasında thumbnail'ları kaydırmak
- aktif videoyu ayrı bir overlay olarak göstermek
- sürükleme sırasında video overlay'ini yavaşça gizlemek
- sadece hero görünürken, ekran aktifken ve hareket tamamlandığında oynatmak

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

Bu, her hero slaytını canlı bir player olarak tutmaya çalışmaktan daha iyi çalıştı.

## Sonuç ekranının farklı bir player'a ihtiyacı var

Her yerde aynı player component'ini kullanmadım.

Sessiz, döngüde oynayan önizleme kartları ile tam bir sonuç ekranı aynı problem değil.

Sonuç ekranı ortak bir `VideoPlayer` kullanıyor ve şunlara sahip:

- oynatma kontrolleri
- `playingChange` listener'ları
- `timeUpdate` listener'ları
- `statusChange` listener'ları
- iOS'ta tam ekran desteği
- önce uzaktan oynatma, gerekirse yerel fallback

Bu event'leri kullanıyorsanız ilgili Expo dokümanları şunlar:

- [`playingChange` ve `statusChange` event'lerine genel bakış](https://docs.expo.dev/versions/latest/sdk/video/)
- [`timeUpdateEventInterval`](https://docs.expo.dev/versions/latest/sdk/video/#timeupdateeventinterval)

Kullanımı basit:

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

Fallback mantığı da açık.

Player ilk başarılı yüklemeden önce çok uzun süre loading durumunda kalırsa ya da bir hata durumuna geçerse, MP4'ü cache dizinine indirip kaynağı değiştiriyorum.

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

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

Bu mikro optimizasyonla ilgili değil. Sonuç ekranını güvenilir hale getirmekle ilgili.

Tamamlanmış bir sonuç açıldığında oynatma takılırsa, tüm özellik bozuk hissettirir.

## Gerçekten önemli olan

Tüm kurulumu birkaç pratik kurala sıkıştırmam gerekseydi, şunlar olurdu:

- expo-video'yu bir wrapper'ın arkasında tutun
- player oluşturmayı oynatmadan ayırın
- feed, satırlar, hero ve sonuç ekranlarına farklı yüzeyler olarak davranın
- varsayılan olarak önce thumbnail gösterin
- oynatmayı odak ve ön plan durumuna bağlayın
- Android buffer profillerini stratejinin tamamı olarak değil, bir detay olarak kullanın
- önemli oynatma yüzeyleri için bir fallback yolu ekleyin

Son madde önemli.

Bu yazı aslında tek bir Android buffer flag'i hakkında değil.

Daha büyük kazanç şunlara karar vermekti:

- bir player nerede var olmalı
- ne zaman oynatmalı
- ne zaman sessiz kalmalı
- thumbnail'ın ne zaman daha iyi bir varsayılan olduğu
- hangi yüzeylerin bir kurtarma yolunu hak ettiği

Bunu kabul ettiğimde mimari çok daha temiz hale geldi.

## Nihai sonuç

Player oluşturmayı oynatmadan ayırıp tek gerçek önceliği aktif öğe yaptıktan sonra feed şöyle görünüyordu:

<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"
  >
    Tarayıcınız video etiketini desteklemiyor.
  </video>
</div>

## Son düşünceler

Burada zor olan kısım expo-video'nun kendisi değildi.

Zor olan, uygulamada gerçekte kaç farklı video yüzeyi olduğu konusunda dürüst olmaktı.

Hepsine aynı şekilde davranmayı bıraktığımda feed çok daha iyi hissettirmeye başladı.

expo-video'nun da hakkını vereyim: oynatma politikası netleştiğinde kütüphane kendi işini çok iyi yaptı.

`useVideoPlayer` ve `VideoView`'ın tek bir cross-platform kod yolunda olması, mimarinin büyük kısmını ortak tutmayı ve sadece platformların gerçekten ayrıştığı yerlerde dallanmayı mümkün kıldı: Android [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions), Android [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) ya da iOS tam ekran davranışı gibi.

expo-video ile feed tarzı bir arayüz geliştiriyorsanız, ben olsam işe buradan başlardım.

