# TikTok जैसी Feed में expo-video को सही से चलाना

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

# expo-video के साथ एक smooth, TikTok जैसी Video Feed बनाना

जब screen पर सिर्फ एक player हो, तब expo-video आसान है।

मुश्किल तब होती है जब उसी app में एक hero video, एक vertical feed, horizontal rows, और असली controls वाली एक result screen हो।

मेरा setup यही था, और असली सवाल यह नहीं था कि "Expo में video कैसे play करूँ?"

असली समस्या यह थी कि मेरे पास बहुत सारी अलग अलग video surfaces थीं, और मैं उन सबको एक ही चीज़ मानकर चल रहा था।

यही गलती थी।

कुछ surfaces को player जल्दी बना लेना चाहिए। कुछ को तभी play करना चाहिए जब वे focus में हों। कुछ को तब तक सिर्फ thumbnail रहना चाहिए जब तक user पास न आ जाए। कुछ को एक fallback path चाहिए अगर remote playback अटक जाए।

यह article इसलिए है क्योंकि इसका हल कोई एक जादुई prop नहीं था। हल था एक playback policy तय करना।

## यह इतनी जल्दी उलझ क्यों जाता है

सबसे पहले, मैंने समस्या को चार फैसलों में बाँटा:

- क्या इस surface को player बनाना चाहिए?
- क्या यह player अभी play होना चाहिए?
- यह player कितना महँगा होना चाहिए?
- पहले frame से पहले user को क्या दिखना चाहिए?

जब ये फैसले अलग अलग हो गए, तो बाकी architecture को समझना काफी आसान हो गया।

## expo-video को एक wrapper के पीछे रखें

कुछ भी optimize करने से पहले, मैंने expo-video को wrap किया।

मैं नहीं चाहता था कि buffer settings, fullscreen behavior, surface type और player setup पूरे app में बिखरे रहें। इन फैसलों को एक जगह रखने के लिए एक wrapper काफी था।

Official docs यहाँ हैं: [expo-video documentation](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 कोई जादू नहीं करता। वह बस मुझे एक जगह देता है जहाँ मैं ये define कर सकूँ:

- detail player
- preview player
- feed active player
- feed adjacent player

Android profiles मायने रखते हैं, लेकिन वे setup का सिर्फ एक हिस्सा हैं। बड़ा फायदा इस बात को control करने से आया कि players कब मौजूद रहें और उन्हें कब play करने की इजाज़त हो।

## Player बनाना और उसे play करना एक बात नहीं है

यह सबसे ज़रूरी सोच का बदलाव था।

Feed screen में मैंने player creation और playback को एक ही चीज़ मानना बंद कर दिया।

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

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

ये दोनों booleans अलग अलग समस्याएँ हल करते हैं।

- `shouldCreatePlayer` बताता है कि क्या यह surface player की हकदार भी है
- `shouldPlay` बताता है कि क्या वह player अभी चलना चाहिए

Feed में यह फर्क बहुत मायने रखता है।

अगर आप इसे छोड़ देते हैं, तो आमतौर पर बहुत ज़्यादा players, बहुत ज़्यादा buffering और ढेर सारा बेकार काम हाथ लगता है।

## Vertical feed में active और adjacent states

Main feed के लिए मैं सिर्फ active item और उसके आस पास वाले (adjacent) items के लिए players बनाता हूँ।

इससे active card तुरंत चलता हुआ लगता है, और पूरी 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",
});
```

Active card को ज़्यादा उदार profile मिलती है।

Adjacent card को सस्ती profile मिलती है, क्योंकि हो सकता है वह कभी primary बने ही नहीं।

लेकिन ज़्यादा ज़रूरी हिस्सा अब भी playback rule है, buffer rule नहीं।

मैं non-active items को तुरंत mute और pause कर देता हूँ:

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

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

यह हिस्सा cross-platform है। असली behavior change यही है।

Preview surfaces में मैंने iOS पर `useCaching` को disabled ही रखा। यह expo-video का कोई universal rule नहीं है। यह इस app के लिए लिया गया फैसला था, क्योंकि मेरे लिए preview caching Android पर iOS के मुकाबले ज़्यादा stable थी।

## पहले thumbnail दिखाना ज़रूरी है, इस पर कोई समझौता नहीं

अगर player के तैयार होते समय feed cell एक काला rectangle दिखाती है, तो वह पहले से ही टूटी हुई लगती है।

इसलिए मैं हमेशा thumbnail को base layer के रूप में रखता हूँ और player को पहला frame render होने के बाद ही दिखाता हूँ।

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

वह छोटा सा opacity gate बहुत बड़ा फर्क डालता है।

Video को तुरंत दिखने की ज़रूरत नहीं है। बस उसे thumbnail की जगह साफ तरीके से लेनी है।

उस snippet में ज़रूरी हिस्सा पहले frame का handoff है। `textureView` वाली line बस Android से जुड़ी एक rendering detail है।

## Platform के हिसाब से tuning: bufferOptions और surfaceType

इस हिस्से में थोड़ी और सटीकता चाहिए।

expo-video cross-platform [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions) देता है, लेकिन उस object के अंदर के कुछ fields platform-specific हैं।

व्यवहार में इसका मतलब है:

- `bufferOptions` एक API के रूप में Android और iOS दोनों पर मौजूद है
- `minBufferForPlayback` और `prioritizeTimeOverSizeThreshold` जैसे fields वे Android-focused tuning knobs हैं जो मैंने यहाँ इस्तेमाल किए
- `waitsToMinimizeStalling` उसी API में iOS की एक खास buffer setting है
- [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype) सिर्फ Android के लिए है

इसी की मदद से मैं इनके बीच फर्क कर पाया:

- active feed cards
- adjacent feed cards
- detail players
- preview players

इसी वजह से मैंने उन जगहों पर साफ तौर पर `textureView` इस्तेमाल किया जहाँ overlap होते video views या layered transitions मायने रखते थे।

Expo docs खुद Android पर overlap होते `VideoView` की समस्याओं के workaround के रूप में `surfaceType="textureView"` का ज़िक्र करते हैं।

तो जब मैं इस तरह का code दिखाता हूँ:

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

तो वह section असल में Android पर playback की लागत को tune करने के बारे में है, पूरे हल के बारे में नहीं।

पूरा हल अब भी create, play, pause, mute और fallback के आस पास की lifecycle policy ही है।

## Horizontal rows को एक playback budget चाहिए

App में video surface सिर्फ feed नहीं थी।

Home screen पर horizontal rows भी थीं, और वे rows TikTok की तरह behave नहीं कर सकतीं। अगर हर दिखने वाली row के हर दिखने वाले card को player मिल जाए, तो आप एक ऐसी surface के लिए बहुत ज़्यादा memory खर्च कर देते हैं जिसे उसकी ज़रूरत ही नहीं।

इसलिए मैंने row के level पर एक playback budget जोड़ा।

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

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

इससे मुझे एक सीधा rule मिला:

- दिखने वाली rows में सिर्फ पहले कुछ eligible cards को players मिलते हैं
- बाकी सब सिर्फ thumbnail रहते हैं

जब कोई card eligibility से बाहर होता है, तो मैंने unmount को थोड़ा delay भी किया, ताकि threshold में जल्दी जल्दी होने वाले बदलाव players को बार बार बनाते और मिटाते न रहें।

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

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

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

इससे horizontal rows पूरी screen वाली feed के मुकाबले काफी सस्ती महसूस होने लगीं।

## Hero को feed की तरह behave नहीं करना चाहिए

Hero की समस्या अलग थी।

मैं चाहता था कि carousel interactive लगे, और जब वह रुक जाए तब video भी दिखाए।

हल यह था:

- gesture के दौरान thumbnails को slide करना
- active video को एक अलग overlay के रूप में दिखाना
- drag करते समय video overlay को fade out करना
- सिर्फ तभी play करना जब hero दिख रहा हो, screen active हो, और gesture रुक चुका हो

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

यह हर hero slide को live player रखने की कोशिश से बेहतर काम किया।

## Result screen को अलग player चाहिए

मैंने हर जगह एक ही player component इस्तेमाल नहीं किया।

Mute होकर loop करने वाले preview cards और पूरी result screen एक ही समस्या नहीं हैं।

Result screen एक shared `VideoPlayer` इस्तेमाल करती है, जिसमें ये हैं:

- playback controls
- `playingChange` listeners
- `timeUpdate` listeners
- `statusChange` listeners
- iOS पर fullscreen support
- remote-first playback, local fallback के साथ

अगर आप ये events इस्तेमाल कर रहे हैं, तो काम के Expo docs ये हैं:

- [`playingChange` और `statusChange` events का overview](https://docs.expo.dev/versions/latest/sdk/video/)
- [`timeUpdateEventInterval`](https://docs.expo.dev/versions/latest/sdk/video/#timeupdateeventinterval)

इस्तेमाल आसान है:

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

Fallback logic सीधा है।

अगर पहले सफल load से पहले player बहुत देर तक loading में रहता है, या error state में चला जाता है, तो मैं MP4 को cache directory में download करता हूँ और source बदल देता हूँ।

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

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

यह micro-optimization के बारे में नहीं है। यह result screen को भरोसेमंद बनाने के बारे में है।

अगर एक तैयार result खुलता है और playback अटक जाता है, तो पूरा feature टूटा हुआ लगता है।

## असल में क्या मायने रखा

अगर मुझे पूरे setup को कुछ practical rules में समेटना हो, तो वे ये होंगे:

- expo-video को एक wrapper के पीछे रखें
- player creation को playback से अलग रखें
- feed, rows, hero और result screens को अलग अलग surfaces मानें
- default रूप से पहले thumbnails दिखाएँ
- playback को focus और foreground state पर निर्भर रखें
- Android buffer profiles को एक detail की तरह इस्तेमाल करें, पूरी strategy की तरह नहीं
- ज़रूरी playback surfaces के लिए एक fallback path जोड़ें

वह आखिरी बात मायने रखती है।

यह article असल में किसी एक Android buffer flag के बारे में नहीं है।

बड़ी जीत यह तय करने में थी कि:

- player कहाँ मौजूद होना चाहिए
- उसे कब play करना चाहिए
- उसे कब mute रहना चाहिए
- कब thumbnail बेहतर default है
- किन surfaces को recovery path मिलना चाहिए

जब मैंने यह मान लिया, तो architecture काफी साफ हो गया।

## आखिरी नतीजा

Player creation को playback से अलग करने और सिर्फ active item को असली priority रखने के बाद feed ऐसी दिखती थी:

<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 video tag को support नहीं करता।
  </video>
</div>

## आखिरी बातें

यहाँ मुश्किल हिस्सा खुद expo-video नहीं था।

मुश्किल हिस्सा यह ईमानदारी से मानना था कि app में असल में कितनी अलग अलग video surfaces थीं।

जब मैंने उन सबको एक जैसा मानना बंद किया, तो feed काफी बेहतर महसूस होने लगी।

और expo-video को उसका श्रेय देते हुए कहूँ, जब playback policy साफ हो गई, तो library ने अपना काम बहुत अच्छे से किया।

`useVideoPlayer` और `VideoView` के एक ही cross-platform code path पर होने से architecture का ज़्यादातर हिस्सा shared रखना मुमकिन हुआ, और branch सिर्फ वहाँ करनी पड़ी जहाँ platforms सच में अलग हैं, जैसे Android [`bufferOptions`](https://docs.expo.dev/versions/latest/sdk/video/#bufferoptions), Android [`surfaceType`](https://docs.expo.dev/versions/latest/sdk/video/#surfacetype), या iOS का fullscreen behavior।

अगर आप expo-video के साथ feed जैसा UI बना रहे हैं, तो मैं यहीं से शुरू करूँगा।
