Blog

Làm cho expo-video chạy tốt trong một feed kiểu TikTok

10 tháng 1, 2026 11 phút đọc

Cách tôi làm cho expo-video chạy đúng trong một feed kiểu TikTok: tách việc tạo player khỏi việc phát, rồi coi feed, hero, các hàng và màn hình kết quả là những bề mặt khác nhau.

Làm cho expo-video chạy tốt trong một feed kiểu TikTok
ExpoReact Nativeexpo-videoHiệu năngVideo

Xây dựng một video feed kiểu TikTok mượt mà với expo-video

expo-video rất dễ dùng khi màn hình chỉ có một player.

Mọi thứ khó hơn khi cùng một app có video hero, một feed dọc, các hàng cuộn ngang và một màn hình kết quả với các nút điều khiển thật.

Đó chính là trường hợp của tôi, và vấn đề thực ra không phải là "làm sao để phát video trong Expo?"

Vấn đề thật sự là tôi có quá nhiều kiểu bề mặt video khác nhau, và tôi lại đối xử với chúng như thể chúng là một.

Đó là sai lầm.

Có bề mặt nên tạo player sớm. Có bề mặt chỉ nên phát khi được focus. Có bề mặt nên chỉ hiện thumbnail cho đến khi người dùng cuộn tới gần. Có bề mặt cần một đường dự phòng nếu việc phát từ xa bị kẹt.

Bài viết này ra đời vì cách sửa không phải là một prop thần kỳ nào đó. Cách sửa là định ra một chính sách phát video.

Vì sao mọi thứ rối lên rất nhanh

Trước hết, tôi chia vấn đề thành bốn quyết định:

  • bề mặt này có nên tạo player không?
  • player này có nên đang phát ngay lúc này không?
  • player này nên tốn bao nhiêu tài nguyên?
  • người dùng nên thấy gì trước frame đầu tiên?

Khi đã tách riêng các quyết định đó, phần còn lại của kiến trúc trở nên dễ suy luận hơn nhiều.

Đặt expo-video sau một wrapper

Trước khi tối ưu bất cứ thứ gì, tôi bọc expo-video lại.

Tôi không muốn các thiết lập buffer, hành vi fullscreen, surface type và cách khởi tạo player nằm rải rác khắp app. Một wrapper là đủ để giữ các lựa chọn đó ở một chỗ.

Tài liệu chính thức ở đây: tài liệu expo-video.

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 đó không làm gì thần kỳ cả. Nó chỉ cho tôi một chỗ duy nhất để định nghĩa:

  • player cho màn hình chi tiết
  • player cho preview
  • player đang active trong feed
  • player liền kề trong feed

Các profile cho Android có quan trọng, nhưng chúng chỉ là một phần của thiết lập. Lợi ích lớn hơn đến từ việc kiểm soát khi nào player tồn tại và khi nào nó được phép phát.

Tạo player không giống với phát player

Đây là thay đổi tư duy quan trọng nhất.

Trong màn hình feed, tôi thôi coi việc tạo player và việc phát video là cùng một thứ.

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

const shouldPlay =
  isActive &&
  isAppInForeground &&
  isScreenFocused;

Hai boolean đó giải quyết hai vấn đề khác nhau.

  • shouldCreatePlayer trả lời câu hỏi bề mặt này có đáng có một player hay không
  • shouldPlay trả lời câu hỏi player đó có nên đang chạy ngay lúc này hay không

Sự phân biệt đó rất quan trọng trong một feed.

Nếu bỏ qua nó, bạn thường sẽ có quá nhiều player, quá nhiều buffering và rất nhiều việc vô ích.

Trạng thái active và liền kề trong feed dọc

Với feed chính, tôi chỉ tạo player cho item đang active và các item liền kề với nó.

Cách này giúp card đang active có cảm giác tức thì mà không phải trả giá đầy đủ cho cả danh sách.

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

Card đang active nhận profile rộng rãi hơn.

Card liền kề nhận profile rẻ hơn vì có thể nó sẽ không bao giờ trở thành card chính.

Nhưng phần quan trọng hơn vẫn là quy tắc phát, chứ không phải quy tắc buffer.

Tôi tắt tiếng và tạm dừng các item không active ngay lập tức:

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

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

Phần đó chạy trên mọi nền tảng. Đó mới là thay đổi hành vi thực sự.

Ở các bề mặt preview, tôi cũng để useCaching tắt trên iOS. Đó không phải là quy tắc chung của expo-video. Đó là quyết định riêng cho app này, vì với tôi, cache preview ổn định trên Android hơn trên iOS.

Hiển thị thumbnail trước là điều bắt buộc

Nếu một cell trong feed hiện ra một hình chữ nhật đen trong lúc player đang khởi động, nó đã cho cảm giác bị hỏng.

Vì vậy, tôi luôn giữ thumbnail làm lớp nền và chỉ hiện player sau khi frame đầu tiên được render.

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

Cái cổng opacity nhỏ đó tạo ra khác biệt rất lớn.

Video không cần xuất hiện ngay lập tức. Nó chỉ cần thay thế thumbnail một cách gọn gàng.

Phần quan trọng trong đoạn code đó là bước chuyển giao ở frame đầu tiên. Dòng textureView chỉ là một chi tiết render riêng cho Android.

Tinh chỉnh theo từng nền tảng: bufferOptions và surfaceType

Phần này cần chính xác hơn một chút.

expo-video cung cấp bufferOptions cho mọi nền tảng, nhưng một số field riêng lẻ bên trong object đó lại chỉ dành cho một nền tảng.

Trên thực tế, điều đó có nghĩa là:

  • bufferOptions với tư cách một API có trên cả Android và iOS
  • các field như minBufferForPlayback và prioritizeTimeOverSizeThreshold là những nút tinh chỉnh tập trung vào Android mà tôi dùng ở đây
  • waitsToMinimizeStalling là một thiết lập buffer riêng cho iOS trong cùng API đó
  • surfaceType chỉ có trên Android

Đó là thứ giúp tôi phân biệt giữa:

  • card đang active trong feed
  • card liền kề trong feed
  • player cho màn hình chi tiết
  • player cho preview

Đó cũng là lý do tôi chủ động dùng textureView ở những chỗ có các video view chồng lên nhau hoặc có transition nhiều lớp.

Tài liệu Expo thậm chí còn nhắc đến surfaceType="textureView" như một cách xử lý tạm cho lỗi VideoView chồng lên nhau trên Android.

Vì vậy, khi tôi đưa ra đoạn code như thế này:

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

thì phần đó thực ra là về việc tinh chỉnh chi phí phát video trên Android, không phải toàn bộ giải pháp.

Giải pháp đầy đủ vẫn là chính sách vòng đời xoay quanh tạo, phát, tạm dừng, tắt tiếng và dự phòng.

Các hàng cuộn ngang cần một ngân sách phát video

Feed không phải là bề mặt video duy nhất trong app.

Tôi còn có các hàng cuộn ngang ở màn hình chính, và những hàng đó không thể hoạt động như TikTok. Nếu mọi card đang hiển thị trong mọi hàng đang hiển thị đều có player, bạn sẽ đốt quá nhiều bộ nhớ cho một bề mặt không cần đến chúng.

Vì vậy, tôi thêm một ngân sách phát video ở cấp hàng.

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

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

Điều đó cho tôi một quy tắc đơn giản:

  • chỉ vài card đủ điều kiện đầu tiên trong các hàng đang hiển thị mới có player
  • mọi card khác chỉ hiện thumbnail

Tôi cũng trì hoãn unmount một chút khi một card không còn đủ điều kiện, để những thay đổi ngưỡng nhanh không làm player bị tạo rồi hủy quá dồn dập.

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

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

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

Nhờ vậy, các hàng cuộn ngang tốn ít tài nguyên hơn nhiều so với feed toàn màn hình.

Hero không nên hoạt động như feed

Hero có một vấn đề khác.

Tôi muốn carousel có cảm giác tương tác được, trong khi vẫn hiện video khi nó đã dừng yên.

Giải pháp là:

  • trượt thumbnail trong lúc thực hiện cử chỉ
  • hiện video đang active như một overlay riêng
  • làm mờ dần overlay video trong lúc kéo
  • chỉ phát khi hero đang hiển thị, màn hình đang active và cử chỉ đã kết thúc
const shouldPlayHero =
  isScreenActive &&
  isHeroVisible &&
  isSettled &&
  !!activeVideoUrl;

Cách đó hiệu quả hơn so với việc cố giữ mọi slide của hero là một player đang chạy.

Màn hình kết quả cần một player khác

Tôi không dùng cùng một component player ở mọi nơi.

Các card preview lặp lại không tiếng và một màn hình kết quả đầy đủ không phải là cùng một vấn đề.

Màn hình kết quả dùng một VideoPlayer dùng chung với:

  • các nút điều khiển phát
  • listener playingChange
  • listener timeUpdate
  • listener statusChange
  • hỗ trợ fullscreen trên iOS
  • ưu tiên phát từ xa, có dự phòng từ file cục bộ

Nếu bạn dùng những sự kiện đó, đây là các tài liệu Expo liên quan:

Cách dùng rất đơn giản:

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

Logic dự phòng khá đơn giản.

Nếu player ở trạng thái loading quá lâu trước lần tải thành công đầu tiên, hoặc chuyển sang trạng thái lỗi, tôi tải file MP4 về thư mục cache và đổi source.

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

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

Đây không phải là chuyện tối ưu vi mô. Đây là chuyện làm cho màn hình kết quả đáng tin cậy.

Nếu một kết quả đã hoàn thành được mở ra mà video bị kẹt, cả tính năng sẽ có cảm giác bị hỏng.

Điều thực sự quan trọng

Nếu phải gói gọn toàn bộ thiết lập thành vài quy tắc thực tế, thì đó sẽ là:

  • đặt expo-video sau một wrapper
  • tách việc tạo player khỏi việc phát
  • coi feed, các hàng, hero và màn hình kết quả là những bề mặt khác nhau
  • mặc định hiện thumbnail trước
  • chỉ cho phát khi được focus và app ở foreground
  • coi các profile buffer của Android là một chi tiết, không phải toàn bộ chiến lược
  • thêm đường dự phòng cho các bề mặt phát video quan trọng

Điểm cuối cùng đó rất quan trọng.

Bài viết này thực ra không nói về một cờ buffer nào đó của Android.

Thắng lợi lớn hơn là quyết định được:

  • player nên tồn tại ở đâu
  • khi nào nó nên phát
  • khi nào nó nên tắt tiếng
  • khi nào thumbnail là lựa chọn mặc định tốt hơn
  • bề mặt nào xứng đáng có một đường phục hồi

Khi tôi chấp nhận điều đó, kiến trúc trở nên gọn gàng hơn nhiều.

Kết quả cuối cùng

Đây là feed sau khi tách việc tạo player khỏi việc phát và chỉ giữ item đang active là ưu tiên thực sự duy nhất:

Suy nghĩ cuối cùng

Bản thân expo-video không phải là phần khó ở đây.

Phần khó là thành thật về việc app thực sự có bao nhiêu kiểu bề mặt video khác nhau.

Khi tôi thôi đối xử với tất cả chúng như nhau, feed bắt đầu mượt hơn hẳn.

Và công bằng mà nói với expo-video, khi chính sách phát video đã rõ ràng, bản thân thư viện làm rất tốt việc của nó.

Có useVideoPlayer và VideoView trên cùng một luồng code chạy trên mọi nền tảng giúp tôi giữ phần lớn kiến trúc dùng chung, và chỉ rẽ nhánh ở những chỗ các nền tảng thực sự khác nhau, như bufferOptions trên Android, surfaceType trên Android, hay hành vi fullscreen trên iOS.

Nếu bạn đang xây dựng một UI dạng feed với expo-video, tôi sẽ bắt đầu từ đó.