diff --git a/__mocks__/expo-video.tsx b/__mocks__/expo-video.tsx
deleted file mode 100644
index dc6df5395365..000000000000
--- a/__mocks__/expo-video.tsx
+++ /dev/null
@@ -1,114 +0,0 @@
-/* eslint-disable no-underscore-dangle */
-
-/* eslint-disable @typescript-eslint/naming-convention */
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-/* eslint-disable react-compiler/react-compiler */
-import React, {forwardRef, useRef} from 'react';
-import type {ForwardedRef} from 'react';
-import {View} from 'react-native';
-import type {ViewProps} from 'react-native';
-
-type MutedChangeEventPayload = {
-    isMuted: boolean;
-};
-
-type PlayingChangeEventPayload = {
-    isPlaying: boolean;
-};
-
-type StatusChangeEventPayload = {
-    status: string;
-};
-
-type TimeUpdateEventPayload = {
-    currentTime: number;
-};
-
-type VideoPlayer = {
-    /** lightweight “state” */
-    isPlaying: boolean;
-    isMuted: boolean;
-    currentTime: number;
-
-    /** controls */
-    play: jest.Mock<void, []>;
-    pause: jest.Mock<void, []>;
-    replace: jest.Mock<void, [unknown?]>;
-    seekTo: jest.Mock<void, [number]>;
-    setIsMuted: jest.Mock<void, [boolean]>;
-
-    /** simple event API */
-    addListener: jest.Mock<{remove: () => void}, [string, (payload: unknown) => void]>;
-};
-
-function createMockPlayer(): VideoPlayer {
-    let _isPlaying = false;
-    let _isMuted = false;
-    let _currentTime = 0;
-
-    return {
-        get isPlaying() {
-            return _isPlaying;
-        },
-        get isMuted() {
-            return _isMuted;
-        },
-        get currentTime() {
-            return _currentTime;
-        },
-
-        play: jest.fn(() => {
-            _isPlaying = true;
-        }),
-        pause: jest.fn(() => {
-            _isPlaying = false;
-        }),
-        replace: jest.fn((_opts?: unknown) => {
-            // no-op; exist to satisfy code that calls it
-        }),
-        seekTo: jest.fn((time: number) => {
-            _currentTime = time;
-        }),
-        setIsMuted: jest.fn((muted: boolean) => {
-            _isMuted = muted;
-        }),
-
-        addListener: jest.fn((_event: string, _cb: (payload: unknown) => void) => {
-            // minimal, enough for code that calls .remove()
-            return {remove: () => {}};
-        }),
-    };
-}
-
-/**
- * Mocked hook – returns a stable mock player instance.
- * Signature accepts any args to match real API calls.
- */
-function useVideoPlayer(..._args: unknown[]): VideoPlayer {
-    const ref = useRef<VideoPlayer | null>(null);
-    if (!ref.current) {
-        ref.current = createMockPlayer();
-    }
-    return ref.current;
-}
-
-/**
- * Simple stand-in for the native VideoView.
- * Accepts a `player` prop to mirror the real component.
- */
-type VideoViewProps = ViewProps & {player?: VideoPlayer};
-
-const VideoView = forwardRef((props: VideoViewProps, ref: ForwardedRef<View>) => (
-    // eslint-disable-next-line react/jsx-props-no-spreading
-    <View
-        ref={ref}
-        accessibilityLabel="MockVideoView"
-        // eslint-disable-next-line react/jsx-props-no-spreading
-        {...props}
-    />
-));
-
-export {useVideoPlayer, VideoView};
-export type {MutedChangeEventPayload, PlayingChangeEventPayload, StatusChangeEventPayload, TimeUpdateEventPayload};
diff --git a/config/webpack/webpack.common.ts b/config/webpack/webpack.common.ts
index d8b8d683260b..4450bb12d66d 100644
--- a/config/webpack/webpack.common.ts
+++ b/config/webpack/webpack.common.ts
@@ -46,7 +46,6 @@ const includeModules = [
     '@react-native/assets',
     'expo',
     'expo-av',
-    'expo-video',
     'expo-image-manipulator',
     'expo-modules-core',
 ].join('|');
diff --git a/cspell.json b/cspell.json
index 744d8900db04..ec608a23cfa7 100644
--- a/cspell.json
+++ b/cspell.json
@@ -698,7 +698,6 @@
         "unhold",
         "Unlaminated",
         "Unmigrated",
-        "unmuting",
         "unredacted",
         "unscrollable",
         "unsubmitted",
diff --git a/package-lock.json b/package-lock.json
index 067b98ce8070..1bbf17ab015b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -73,7 +73,6 @@
         "expo-image-manipulator": "^13.1.5",
         "expo-modules-core": "3.0.18",
         "expo-secure-store": "~14.2.4",
-        "expo-video": "^3.0.11",
         "fast-equals": "^5.2.2",
         "focus-trap-react": "^11.0.3",
         "group-ib-fp": "file:modules/group-ib-fp",
@@ -22989,17 +22988,6 @@
         "expo": "*"
       }
     },
-    "node_modules/expo-video": {
-      "version": "3.0.11",
-      "resolved": "https://registry.npmjs.org/expo-video/-/expo-video-3.0.11.tgz",
-      "integrity": "sha512-k/xz8Ml/LekuD2U2LomML2mUISvkHzYDz3fXY8Au1fEaYVNTfTs7Gyfo1lvF6S1X7u3XutoAfew8e8e1ZUR2fg==",
-      "license": "MIT",
-      "peerDependencies": {
-        "expo": "*",
-        "react": "*",
-        "react-native": "*"
-      }
-    },
     "node_modules/expo/node_modules/@expo/cli": {
       "version": "54.0.8",
       "resolved": "https://registry.npmjs.org/@expo/cli/-/cli-54.0.8.tgz",
diff --git a/package.json b/package.json
index 4d51a84c06d5..ca7a5816fc6b 100644
--- a/package.json
+++ b/package.json
@@ -144,7 +144,6 @@
     "expo-image-manipulator": "^13.1.5",
     "expo-modules-core": "3.0.18",
     "expo-secure-store": "~14.2.4",
-    "expo-video": "^3.0.11",
     "fast-equals": "^5.2.2",
     "focus-trap-react": "^11.0.3",
     "group-ib-fp": "file:modules/group-ib-fp",
diff --git a/patches/expo-av/details.md b/patches/expo-av/details.md
new file mode 100644
index 000000000000..e24511e138a1
--- /dev/null
+++ b/patches/expo-av/details.md
@@ -0,0 +1,26 @@
+# `expo-av` patches
+
+### [expo-av+15.1.7+001+fix-blank-screen-android.patch](expo-av+15.1.7+001+fix-blank-screen-android.patch)
+
+- Reason:
+  
+    ```
+    This patch fixes blank modal after fullscreen video ends on Android.
+    ```
+  
+- Upstream PR/issue: The maintainer of the upstream lib isn't willing to accept fix for the lib because it's going to be replaced by another lib `expo-video`, see comment https://github.com/expo/expo/issues/19039#issuecomment-2688369708
+- E/App issue: https://github.com/Expensify/App/issues/53904
+- PR introducing patch: https://github.com/Expensify/App/pull/56302
+
+
+### [expo-av+15.1.7+002+handle-unsupported-videos-ios.patch](expo-av+15.1.7+002+handle-unsupported-videos-ios.patch)
+
+- Reason:
+  
+    ```
+    This patch handles unsupported videos in iOS.
+    ```
+  
+- Upstream PR/issue: Probably same reason as the first patch.
+- E/App issue: https://github.com/Expensify/App/issues/52673
+- PR introducing patch: https://github.com/Expensify/App/pull/57353
\ No newline at end of file
diff --git a/patches/expo-av/expo-av+15.1.7+001+fix-blank-screen-android.patch b/patches/expo-av/expo-av+15.1.7+001+fix-blank-screen-android.patch
new file mode 100644
index 000000000000..3b3f30706250
--- /dev/null
+++ b/patches/expo-av/expo-av+15.1.7+001+fix-blank-screen-android.patch
@@ -0,0 +1,221 @@
+diff --git a/node_modules/expo-av/android/src/main/java/expo/modules/av/player/SimpleExoPlayerData.java b/node_modules/expo-av/android/src/main/java/expo/modules/av/player/SimpleExoPlayerData.java
+index 8835a39..87e1964 100644
+--- a/node_modules/expo-av/android/src/main/java/expo/modules/av/player/SimpleExoPlayerData.java
++++ b/node_modules/expo-av/android/src/main/java/expo/modules/av/player/SimpleExoPlayerData.java
+@@ -2,6 +2,7 @@ package expo.modules.av.player;
+ 
+ import android.content.Context;
+ import android.net.Uri;
++import android.os.Build;
+ import android.os.Bundle;
+ import android.os.Looper;
+ 
+@@ -63,6 +64,8 @@ class SimpleExoPlayerData extends PlayerData
+   private boolean mIsLoading = true;
+   private final Context mReactContext;
+ 
++  private Surface mSurface = null;
++
+   SimpleExoPlayerData(final AVManagerInterface avModule, final Context context, final Uri uri, final String overridingExtension, final Map<String, Object> requestHeaders) {
+     super(avModule, uri, requestHeaders);
+     mReactContext = context;
+@@ -228,6 +231,13 @@ class SimpleExoPlayerData extends PlayerData
+ 
+   @Override
+   public void tryUpdateVideoSurface(final Surface surface) {
++    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++      if (mSimpleExoPlayer != null && mSurface != surface) {
++        mSimpleExoPlayer.setVideoSurface(surface);
++        mSurface = surface;
++      }
++      return;
++    }
+     if (mSimpleExoPlayer != null) {
+       mSimpleExoPlayer.setVideoSurface(surface);
+     }
+diff --git a/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoTextureView.java b/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoTextureView.java
+index 41a5979..b378bf4 100644
+--- a/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoTextureView.java
++++ b/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoTextureView.java
+@@ -4,6 +4,7 @@ import android.annotation.SuppressLint;
+ import android.content.Context;
+ import android.graphics.Matrix;
+ import android.graphics.SurfaceTexture;
++import android.os.Build;
+ import android.util.Pair;
+ import android.util.Size;
+ import android.view.Surface;
+@@ -20,6 +21,10 @@ public class VideoTextureView extends TextureView implements TextureView.Surface
+   private boolean mIsAttachedToWindow = false;
+   private Surface mSurface = null;
+   private boolean mVisible = true;
++  private int mBufferWidth = 0;
++  private int mBufferHeight = 0;
++  private int mPositionX = 0;
++  private int mPositionY = 0;
+ 
+   public VideoTextureView(final Context themedReactContext, VideoView videoView) {
+     super(themedReactContext, null, 0);
+@@ -55,6 +60,15 @@ public class VideoTextureView extends TextureView implements TextureView.Surface
+         setTransform(matrix);
+         invalidate();
+       }
++      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++        float[] values = new float[9];
++        matrix.getValues(values);
++        mBufferWidth = (int)(getWidth() * values[Matrix.MSCALE_X]);
++        mBufferHeight = (int)(getHeight() * values[Matrix.MSCALE_Y]);
++        mPositionX = (int)(values[Matrix.MTRANS_X]);
++        mPositionY = (int)(values[Matrix.MTRANS_Y]);
++        mVideoView.updateSurfaceView(mVisible, mBufferWidth, mBufferHeight, mPositionX, mPositionY);
++      }
+     }
+   }
+ 
+@@ -69,6 +83,9 @@ public class VideoTextureView extends TextureView implements TextureView.Surface
+       onVisibilityChanged(this, View.INVISIBLE);
+       onVisibilityChanged(this, View.VISIBLE);
+     }
++    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++      mVideoView.updateSurfaceView(mVisible, mBufferWidth, mBufferHeight, mPositionX, mPositionY);
++    }
+   }
+ 
+   // TextureView
+@@ -76,7 +93,12 @@ public class VideoTextureView extends TextureView implements TextureView.Surface
+   @Override
+   public void onSurfaceTextureAvailable(final SurfaceTexture surfaceTexture, final int width, final int height) {
+     mSurface = new Surface(surfaceTexture);
+-    mVideoView.tryUpdateVideoSurface(mSurface);
++    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++      mVideoView.tryUpdateVideoSurface();
++      mVideoView.updateSurfaceView(mVisible, mBufferWidth, mBufferHeight, mPositionX, mPositionY);
++    } else {
++      mVideoView.tryUpdateVideoSurface(mSurface);
++    }
+   }
+ 
+   @Override
+@@ -86,13 +108,17 @@ public class VideoTextureView extends TextureView implements TextureView.Surface
+ 
+   @Override
+   public void onSurfaceTextureUpdated(final SurfaceTexture surfaceTexture) {
+-    // no-op
++    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++      mVideoView.updateSurfaceView(mVisible, mBufferWidth, mBufferHeight, mPositionX, mPositionY);
++    }
+   }
+ 
+   @Override
+   public boolean onSurfaceTextureDestroyed(final SurfaceTexture surfaceTexture) {
+     mSurface = null;
+-    mVideoView.tryUpdateVideoSurface(null);
++    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
++      mVideoView.tryUpdateVideoSurface(null);
++    }
+     return true;
+   }
+ 
+@@ -108,11 +134,19 @@ public class VideoTextureView extends TextureView implements TextureView.Surface
+   protected void onAttachedToWindow() {
+     super.onAttachedToWindow();
+     mIsAttachedToWindow = true;
+-    mVideoView.tryUpdateVideoSurface(mSurface);
++    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++      mVideoView.tryUpdateVideoSurface();
++      mVideoView.updateSurfaceView(mVisible, mBufferWidth, mBufferHeight, mPositionX, mPositionY);
++    } else {
++      mVideoView.tryUpdateVideoSurface(mSurface);
++    }
+   }
+ 
+   protected void onVisibilityChanged(View changedView, int visibility) {
+     super.onVisibilityChanged(changedView, visibility);
+     mVisible = visibility == View.VISIBLE;
++    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++      mVideoView.updateSurfaceView(mVisible, mBufferWidth, mBufferHeight, mPositionX, mPositionY);
++    }
+   }
+ }
+diff --git a/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoView.java b/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoView.java
+index 1acb32b..6bac2bf 100644
+--- a/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoView.java
++++ b/node_modules/expo-av/android/src/main/java/expo/modules/av/video/VideoView.java
+@@ -2,10 +2,14 @@ package expo.modules.av.video;
+ 
+ import android.annotation.SuppressLint;
+ import android.content.Context;
++import android.os.Build;
+ import android.os.Bundle;
+ import android.util.Pair;
++import android.view.Gravity;
+ import android.view.MotionEvent;
+ import android.view.Surface;
++import android.view.SurfaceControl;
++import android.view.SurfaceView;
+ import android.widget.FrameLayout;
+ 
+ import androidx.annotation.NonNull;
+@@ -62,6 +66,10 @@ public class VideoView extends FrameLayout implements AudioEventHandler, Fullscr
+   private boolean mShouldShowFullscreenPlayerOnLoad = false;
+   private FullscreenVideoPlayerPresentationChangeProgressListener mFullscreenVideoPlayerPresentationOnLoadChangeListener = null;
+ 
++  private Surface mSurface;
++  private SurfaceControl mSurfaceControl;
++  private SurfaceView mSurfaceView;
++
+   public VideoView(@NonNull Context context, VideoViewWrapper videoViewWrapper, AppContext appContext) {
+     super(context);
+ 
+@@ -70,6 +78,13 @@ public class VideoView extends FrameLayout implements AudioEventHandler, Fullscr
+     mAVModule = appContext.getLegacyModuleRegistry().getModule(AVManagerInterface.class);
+     mAVModule.registerVideoViewForAudioLifecycle(this);
+ 
++    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++      mSurfaceView = new SurfaceView(context);
++      mSurfaceControl = new SurfaceControl.Builder().setName("ExpoAVSurfaceControl").setBufferSize(0, 0).build();
++      mSurface = new Surface(mSurfaceControl);
++      addView(mSurfaceView);
++    }
++
+     mVideoTextureView = new VideoTextureView(context, this);
+     addView(mVideoTextureView, generateDefaultLayoutParams());
+ 
+@@ -387,7 +402,11 @@ public class VideoView extends FrameLayout implements AudioEventHandler, Fullscr
+         mVideoTextureView.scaleVideoSize(mPlayerData.getVideoWidthHeight(), mResizeMode);
+ 
+         if (mVideoTextureView.isAttachedToWindow()) {
+-          mPlayerData.tryUpdateVideoSurface(mVideoTextureView.getSurface());
++          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
++            mPlayerData.tryUpdateVideoSurface(mSurface);
++          } else {
++            mPlayerData.tryUpdateVideoSurface(mVideoTextureView.getSurface());
++          }
+         }
+ 
+         if (promise != null) {
+@@ -477,6 +496,24 @@ public class VideoView extends FrameLayout implements AudioEventHandler, Fullscr
+     }
+   }
+ 
++  public void tryUpdateVideoSurface() {
++    if (mPlayerData != null) {
++      mPlayerData.tryUpdateVideoSurface(mSurface);
++    }
++  }
++
++  public void updateSurfaceView(boolean visible, int bufferWidth, int bufferHeight, int positionX, int positionY) {
++    new SurfaceControl.Transaction()
++      .reparent(mSurfaceControl, mSurfaceView.getSurfaceControl())
++      .setBufferSize(mSurfaceControl, bufferWidth, bufferHeight)
++      .setPosition(mSurfaceControl, 0, 0)
++      .setVisibility(mSurfaceControl, visible && bufferWidth > 0 && bufferHeight > 0)
++      .apply();
++    mSurfaceView.layout(positionX, positionY, positionX + Math.max(bufferWidth, 1), positionY + Math.max(bufferHeight, 1));
++    mSurfaceView.setLayoutParams(new FrameLayout.LayoutParams(Math.max(bufferWidth, 1), Math.max(bufferHeight, 1), Gravity.CENTER));
++    mSurfaceView.requestLayout();
++  }
++
+   // AudioEventHandler
+ 
+   @Override
diff --git a/patches/expo-av/expo-av+15.1.7+002+handle-unsupported-videos-ios.patch b/patches/expo-av/expo-av+15.1.7+002+handle-unsupported-videos-ios.patch
new file mode 100644
index 000000000000..b5e27e027e35
--- /dev/null
+++ b/patches/expo-av/expo-av+15.1.7+002+handle-unsupported-videos-ios.patch
@@ -0,0 +1,22 @@
+diff --git a/node_modules/expo-av/ios/EXAV/EXAVPlayerData.m b/node_modules/expo-av/ios/EXAV/EXAVPlayerData.m
+index 99dc808..01e4bb9 100644
+--- a/node_modules/expo-av/ios/EXAV/EXAVPlayerData.m
++++ b/node_modules/expo-av/ios/EXAV/EXAVPlayerData.m
+@@ -158,8 +158,16 @@ NSString *const EXAVPlayerDataObserverMetadataKeyPath = @"timedMetadata";
+   // unless we preload, the asset will not necessarily load the duration by the time we try to play it.
+   // http://stackoverflow.com/questions/20581567/avplayer-and-avfoundationerrordomain-code-11819
+   EX_WEAKIFY(self);
+-  [avAsset loadValuesAsynchronouslyForKeys:@[ @"duration" ] completionHandler:^{
++  [avAsset loadValuesAsynchronouslyForKeys:@[ @"isPlayable", @"duration" ] completionHandler:^{
+     EX_ENSURE_STRONGIFY(self);
++    NSError *error = nil;
++    AVKeyValueStatus status = [avAsset statusOfValueForKey:@"isPlayable" error:&error];
++
++    if (status == AVKeyValueStatusLoaded && !avAsset.isPlayable) {
++      NSString *errorMessage = @"Load encountered an error: [AVAsset isPlayable:] returned false. The asset does not contains a playable content or is not supported by the device.";
++      [self _finishLoadWithError:errorMessage];
++      return;
++    } 
+ 
+     // We prepare three items for AVQueuePlayer, so when the first finishes playing,
+     // second can start playing and the third can start preparing to play.
diff --git a/patches/expo-video/details.md b/patches/expo-video/details.md
deleted file mode 100644
index 84dc26c37428..000000000000
--- a/patches/expo-video/details.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# `expo-video` patches
-
-### [expo-video+3.0.11+001+prevent_double_pause.patch](expo-video+3.0.11+001+prevent_double_pause.patch)
-
-- Reason:
-
-    ```
-    This patch edits the onPause eventListener in expo-video's videoPlayer. It still pauses all mounted videos, but now excludes the video that invoked the listener, preventing it from being paused twice.
-    ```
-
-- Upstream PR/issue: https://github.com/expo/expo/issues/40743
-- E/App issue: 🛑
-- PR Introducing Patch: https://github.com/Expensify/App/pull/66793
diff --git a/patches/expo-video/expo-video+3.0.11+001+prevent_double_pause.patch b/patches/expo-video/expo-video+3.0.11+001+prevent_double_pause.patch
deleted file mode 100644
index d1a996d78051..000000000000
--- a/patches/expo-video/expo-video+3.0.11+001+prevent_double_pause.patch
+++ /dev/null
@@ -1,24 +0,0 @@
-
-diff --git a/node_modules/expo-video/build/VideoPlayer.web.js b/node_modules/expo-video/build/VideoPlayer.web.js
-index 2c7224a..16df18b 100644
---- a/node_modules/expo-video/build/VideoPlayer.web.js
-+++ b/node_modules/expo-video/build/VideoPlayer.web.js
-@@ -305,14 +305,16 @@ export default class VideoPlayerWeb extends globalThis.expo.SharedObject {
-                 mountedVideo.play();
-             });
-         };
--        video.onpause = () => {
-+        video.onpause = (e) => {
-             this._emitOnce(video, 'playingChange', {
-                 isPlaying: false,
-                 oldIsPlaying: this.playing,
-             });
-             this.playing = false;
-             this._mountedVideos.forEach((mountedVideo) => {
--                mountedVideo.pause();
-+                if (e.target !== mountedVideo) {
-+                    mountedVideo.pause();
-+                }
-             });
-         };
-         video.onvolumechange = () => {
diff --git a/src/components/AttachmentPreview.tsx b/src/components/AttachmentPreview.tsx
index 1a07fbc49dcf..560be3304cff 100644
--- a/src/components/AttachmentPreview.tsx
+++ b/src/components/AttachmentPreview.tsx
@@ -1,7 +1,6 @@
 import {Str} from 'expensify-common';
-import type {VideoThumbnail} from 'expo-video';
-import {useVideoPlayer} from 'expo-video';
-import React, {useEffect, useMemo, useState} from 'react';
+import {ResizeMode, Video} from 'expo-av';
+import React, {useMemo, useState} from 'react';
 import {View} from 'react-native';
 import useThemeStyles from '@hooks/useThemeStyles';
 import {cleanFileName, getFileName} from '@libs/fileDownload/FileUtils';
@@ -38,12 +37,6 @@ function AttachmentPreview({source, aspectRatio = 1, onPress, onLoadError}: Atta
         return cleanFileName(rawFileName);
     }, [source]);
 
-    const [thumbnail, setThumbnail] = useState<VideoThumbnail | null>(null);
-    const videoPlayer = useVideoPlayer({uri: source});
-    useEffect(() => {
-        videoPlayer.generateThumbnailsAsync(1).then((thumbnails) => setThumbnail(thumbnails.at(0) ?? null));
-    }, [videoPlayer]);
-
     if (typeof source === 'string' && Str.isVideo(source)) {
         return (
             <PressableWithFeedback
@@ -53,13 +46,17 @@ function AttachmentPreview({source, aspectRatio = 1, onPress, onLoadError}: Atta
                 accessible
                 accessibilityLabel="Attachment Thumbnail"
             >
-                {!!thumbnail && (
-                    <Image
-                        source={thumbnail}
-                        style={[fillStyle, {aspectRatio}]}
-                        resizeMode="cover"
-                    />
-                )}
+                <Video
+                    style={[styles.w100, styles.h100]}
+                    source={{
+                        uri: source,
+                    }}
+                    shouldPlay={false}
+                    useNativeControls={false}
+                    resizeMode={ResizeMode.CONTAIN}
+                    isLooping={false}
+                    onError={onLoadError}
+                />
                 <View style={[styles.h100, styles.w100, styles.pAbsolute, styles.justifyContentCenter, styles.alignItemsCenter]}>
                     <View style={styles.videoThumbnailPlayButton}>
                         <Icon
diff --git a/src/components/Attachments/AttachmentView/index.tsx b/src/components/Attachments/AttachmentView/index.tsx
index 7fd9f3d630e2..71ab5c8b54fa 100644
--- a/src/components/Attachments/AttachmentView/index.tsx
+++ b/src/components/Attachments/AttachmentView/index.tsx
@@ -155,6 +155,9 @@ function AttachmentView({
         }
         const videoSource = isVideo && typeof source === 'string' ? source : undefined;
         updateCurrentURLAndReportID(videoSource, reportID);
+        if (videoSource && currentlyPlayingURL === videoSource) {
+            playVideo();
+        }
     }, [file, isFocused, isInFocusedModal, isUsedInAttachmentModal, isVideo, reportID, source, updateCurrentURLAndReportID, playVideo, currentlyPlayingURL]);
 
     const [imageError, setImageError] = useState(false);
diff --git a/src/components/EmptyStateComponent/index.tsx b/src/components/EmptyStateComponent/index.tsx
index c43efcc46e14..a00475785702 100644
--- a/src/components/EmptyStateComponent/index.tsx
+++ b/src/components/EmptyStateComponent/index.tsx
@@ -1,4 +1,4 @@
-import type {SourceLoadEventPayload} from 'expo-video';
+import type {VideoReadyForDisplayEvent} from 'expo-av';
 import isEmpty from 'lodash/isEmpty';
 import React, {useMemo, useState} from 'react';
 import {View} from 'react-native';
@@ -13,7 +13,7 @@ import useThemeStyles from '@hooks/useThemeStyles';
 import {containsCustomEmoji, containsOnlyCustomEmoji} from '@libs/EmojiUtils';
 import TextWithEmojiFragment from '@pages/home/report/comment/TextWithEmojiFragment';
 import CONST from '@src/CONST';
-import type {EmptyStateComponentProps} from './types';
+import type {EmptyStateComponentProps, VideoLoadedEventType} from './types';
 
 const VIDEO_ASPECT_RATIO = 400 / 225;
 
@@ -40,14 +40,16 @@ function EmptyStateComponent({
     const {shouldUseNarrowLayout} = useResponsiveLayout();
     const doesSubtitleContainCustomEmojiAndMore = containsCustomEmoji(subtitle ?? '') && !containsOnlyCustomEmoji(subtitle ?? '');
 
-    const setAspectRatio = (event: SourceLoadEventPayload) => {
-        const track = event.availableVideoTracks.at(0);
-
-        if (!track) {
+    const setAspectRatio = (event: VideoReadyForDisplayEvent | VideoLoadedEventType | undefined) => {
+        if (!event) {
             return;
         }
 
-        setVideoAspectRatio(track.size.width / track.size.height);
+        if ('naturalSize' in event) {
+            setVideoAspectRatio(event.naturalSize.width / event.naturalSize.height);
+        } else {
+            setVideoAspectRatio(event.srcElement.videoWidth / event.srcElement.videoHeight);
+        }
     };
 
     const HeaderComponent = useMemo(() => {
@@ -56,8 +58,9 @@ function EmptyStateComponent({
                 return (
                     <VideoPlayer
                         url={headerMedia}
-                        videoPlayerStyle={[headerContentStyles, styles.emptyStateVideo, {aspectRatio: videoAspectRatio}]}
-                        onSourceLoaded={setAspectRatio}
+                        videoPlayerStyle={[headerContentStyles, {aspectRatio: videoAspectRatio}]}
+                        videoStyle={styles.emptyStateVideo}
+                        onVideoLoaded={setAspectRatio}
                         controlsStatus={CONST.VIDEO_PLAYER.CONTROLS_STATUS.SHOW}
                         shouldUseControlsBottomMargin={false}
                         shouldPlay
diff --git a/src/components/FeatureTrainingModal.tsx b/src/components/FeatureTrainingModal.tsx
index f322ba4f02b8..f3abf93b8149 100644
--- a/src/components/FeatureTrainingModal.tsx
+++ b/src/components/FeatureTrainingModal.tsx
@@ -1,5 +1,5 @@
+import type {VideoReadyForDisplayEvent} from 'expo-av';
 import type {ImageContentFit} from 'expo-image';
-import type {SourceLoadEventPayload} from 'expo-video';
 import React, {useCallback, useEffect, useMemo, useRef, useState} from 'react';
 import {Image, InteractionManager, View} from 'react-native';
 // eslint-disable-next-line no-restricted-imports
@@ -41,6 +41,13 @@ const VIDEO_ASPECT_RATIO = 1280 / 960;
 
 const MODAL_PADDING = variables.spacing2;
 
+type VideoLoadedEventType = {
+    srcElement: {
+        videoWidth: number;
+        videoHeight: number;
+    };
+};
+
 type VideoStatus = 'video' | 'animation';
 
 type BaseFeatureTrainingModalProps = {
@@ -236,14 +243,16 @@ function FeatureTrainingModal({
         }
     }, [isOffline, isVideoStatusLocked]);
 
-    const setAspectRatio = (event: SourceLoadEventPayload) => {
-        const track = event.availableVideoTracks.at(0);
-
-        if (!track) {
+    const setAspectRatio = (event: VideoReadyForDisplayEvent | VideoLoadedEventType | undefined) => {
+        if (!event) {
             return;
         }
 
-        setIllustrationAspectRatio(track.size.width / track.size.height);
+        if ('naturalSize' in event) {
+            setIllustrationAspectRatio(event.naturalSize.width / event.naturalSize.height);
+        } else {
+            setIllustrationAspectRatio(event.srcElement.videoWidth / event.srcElement.videoHeight);
+        }
     };
 
     const renderIllustration = useCallback(() => {
@@ -283,7 +292,7 @@ function FeatureTrainingModal({
                         <VideoPlayer
                             url={videoURL}
                             videoPlayerStyle={[styles.onboardingVideoPlayer, {aspectRatio}]}
-                            onSourceLoaded={setAspectRatio}
+                            onVideoLoaded={setAspectRatio}
                             controlsStatus={CONST.VIDEO_PLAYER.CONTROLS_STATUS.HIDE}
                             shouldUseControlsBottomMargin={false}
                             shouldPlay
diff --git a/src/components/FullscreenLoadingIndicator.tsx b/src/components/FullscreenLoadingIndicator.tsx
index 302fee3bafde..44dc1d87eb2a 100644
--- a/src/components/FullscreenLoadingIndicator.tsx
+++ b/src/components/FullscreenLoadingIndicator.tsx
@@ -59,7 +59,7 @@ function FullScreenLoadingIndicator({
                     testID={testID}
                     extraLoadingContext={extraLoadingContext}
                 />
-                {showGoBackButton && shouldUseGoBackButton && (
+                {showGoBackButton && (
                     <View style={styles.loadingMessage}>
                         <View style={styles.pv4}>
                             <Text>{translate('common.thisIsTakingLongerThanExpected')}</Text>
diff --git a/src/components/VideoPlayer/BaseVideoPlayer.tsx b/src/components/VideoPlayer/BaseVideoPlayer.tsx
index 9b286c84716d..3cc7e824b86e 100644
--- a/src/components/VideoPlayer/BaseVideoPlayer.tsx
+++ b/src/components/VideoPlayer/BaseVideoPlayer.tsx
@@ -1,13 +1,12 @@
-import {useEvent, useEventListener} from 'expo';
-import type {MutedChangeEventPayload, PlayingChangeEventPayload, StatusChangeEventPayload, TimeUpdateEventPayload, VideoPlayer} from 'expo-video';
-import {useVideoPlayer, VideoView} from 'expo-video';
+/* eslint-disable no-underscore-dangle */
+import type {AVPlaybackStatus, VideoFullscreenUpdateEvent} from 'expo-av';
+import {ResizeMode, Video, VideoFullscreenUpdate} from 'expo-av';
 import debounce from 'lodash/debounce';
 import type {RefObject} from 'react';
 import React, {useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState} from 'react';
 import type {GestureResponderEvent} from 'react-native';
 import {View} from 'react-native';
-import {useAnimatedStyle, useSharedValue, withTiming} from 'react-native-reanimated';
-import {scheduleOnRN} from 'react-native-worklets';
+import {runOnJS, useAnimatedStyle, useSharedValue, withTiming} from 'react-native-reanimated';
 import AttachmentOfflineIndicator from '@components/AttachmentOfflineIndicator';
 import FullScreenLoadingIndicator from '@components/FullscreenLoadingIndicator';
 import Hoverable from '@components/Hoverable';
@@ -21,10 +20,11 @@ import VideoPopoverMenu from '@components/VideoPopoverMenu';
 import useNetwork from '@hooks/useNetwork';
 import useThemeStyles from '@hooks/useThemeStyles';
 import addEncryptedAuthTokenToURL from '@libs/addEncryptedAuthTokenToURL';
-import {isSafari} from '@libs/Browser';
+import {isMobileSafari} from '@libs/Browser';
 import {canUseTouchScreen as canUseTouchScreenLib} from '@libs/DeviceCapabilities';
 import CONST from '@src/CONST';
-import type VideoPlayerProps from './types';
+import shouldReplayVideo from './shouldReplayVideo';
+import type {VideoPlayerProps, VideoWithOnFullScreenUpdate} from './types';
 import useHandleNativeVideoControls from './useHandleNativeVideoControls';
 import * as VideoUtils from './utils';
 import VideoErrorIndicator from './VideoErrorIndicator';
@@ -32,22 +32,26 @@ import VideoPlayerControls from './VideoPlayerControls';
 
 function BaseVideoPlayer({
     url,
-    onSourceLoaded,
+    resizeMode = ResizeMode.CONTAIN,
+    onVideoLoaded,
     isLooping = false,
     style,
     videoPlayerStyle,
+    videoStyle,
     videoControlsStyle,
     videoDuration = 0,
+    controlsStatus = CONST.VIDEO_PLAYER.CONTROLS_STATUS.SHOW,
     shouldUseSharedVideoElement = false,
     shouldUseSmallVideoControls = false,
+    onPlaybackStatusUpdate,
+    onFullscreenUpdate,
+    shouldPlay,
     // TODO: investigate what is the root cause of the bug with unexpected video switching
     // isVideoHovered caused a bug with unexpected video switching. We are investigating the root cause of the issue,
     // but current workaround is just not to use it here for now. This causes not displaying the video controls when
     // user hovers the mouse over the carousel arrows, but this UI bug feels much less troublesome for now.
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     isVideoHovered = false,
-    controlsStatus = CONST.VIDEO_PLAYER.CONTROLS_STATUS.SHOW,
-    shouldPlay,
     isPreview,
     reportID,
 }: VideoPlayerProps & {reportID: string}) {
@@ -55,22 +59,24 @@ function BaseVideoPlayer({
     const {
         pauseVideo,
         playVideo,
-        replayVideo,
         currentlyPlayingURL,
         sharedElement,
         originalParent,
         shareVideoPlayerElements,
         currentVideoPlayerRef,
-        currentVideoViewRef,
         updateCurrentURLAndReportID,
+        videoResumeTryNumberRef,
         setCurrentlyPlayingURL,
-        mountedVideoPlayersRef,
     } = usePlaybackContext();
     const {isFullScreenRef} = useFullScreenContext();
     const {isOffline} = useNetwork();
-    const [duration, setDuration] = useState(videoDuration);
+    const [duration, setDuration] = useState(videoDuration * 1000);
+    const [position, setPosition] = useState(0);
+    const [isPlaying, setIsPlaying] = useState(false);
+    const [isLoading, setIsLoading] = useState(true);
     const [isEnded, setIsEnded] = useState(false);
-    const [isFirstLoad, setIsFirstLoad] = useState(true);
+    const [isBuffering, setIsBuffering] = useState(true);
+    const [hasError, setHasError] = useState(false);
     // we add "#t=0.001" at the end of the URL to skip first millisecond of the video and always be able to show proper video preview when video is paused at the beginning
     const [sourceURL] = useState(() => VideoUtils.addSkipTimeTagToURL(url.includes('blob:') || url.includes('file:///') ? url : addEncryptedAuthTokenToURL(url), 0.001));
     const [isPopoverVisible, setIsPopoverVisible] = useState(false);
@@ -81,36 +87,7 @@ function BaseVideoPlayer({
         opacity: controlsOpacity.get(),
     }));
 
-    /* eslint-disable no-param-reassign */
-    const videoPlayerRef = useRef<VideoPlayer>(
-        useVideoPlayer(sourceURL, (player) => {
-            player.loop = isLooping;
-            player.muted = true;
-            player.timeUpdateEventInterval = 0.1;
-        }),
-    );
-    /* eslint-enable no-param-reassign */
-
-    const isPlaying = videoPlayerRef.current.playing;
-    const {currentTime, bufferedPosition} = useEvent(videoPlayerRef.current, 'timeUpdate', {currentTime: 0, bufferedPosition: 0} as TimeUpdateEventPayload);
-    const {status} = useEvent(videoPlayerRef.current, 'statusChange', {status: 'idle'} as StatusChangeEventPayload);
-
-    const [isSafariLoading, setIsSafariLoading] = useState(false);
-    const isLoading = useMemo(() => {
-        return status === 'loading' || isSafariLoading;
-    }, [isSafariLoading, status]);
-
-    const hasError = useMemo(() => {
-        // No need to set hasError while offline, since the offline indicator is already shown.
-        // Once the user reconnects, if the video is unsupported, the error will be triggered again.
-        return status === 'error' && !isOffline;
-    }, [isOffline, status]);
-
-    const isBuffering = useMemo(() => {
-        return bufferedPosition <= 0;
-    }, [bufferedPosition]);
-
-    const videoViewRef = useRef<VideoView | null>(null);
+    const videoPlayerRef = useRef<VideoWithOnFullScreenUpdate | null>(null);
     const videoPlayerElementParentRef = useRef<View | HTMLDivElement | null>(null);
     const videoPlayerElementRef = useRef<View | HTMLDivElement | null>(null);
     const sharedVideoPlayerParentRef = useRef<View | HTMLDivElement | null>(null);
@@ -118,47 +95,35 @@ function BaseVideoPlayer({
     const canUseTouchScreen = canUseTouchScreenLib();
     const isCurrentlyURLSet = currentlyPlayingURL === url;
     const isUploading = CONST.ATTACHMENT_LOCAL_URL_PREFIX.some((prefix) => url.startsWith(prefix));
-    const shouldShowLoadingIndicator = useMemo(() => {
-        return !isPlaying && !isOffline && !hasError && isLoading;
-    }, [hasError, isLoading, isOffline, isPlaying]);
+    const videoStateRef = useRef<AVPlaybackStatus | null>(null);
     const {updateVolume, lastNonZeroVolume} = useVolumeContext();
     useHandleNativeVideoControls({
-        videoViewRef,
+        videoPlayerRef,
         isOffline,
         isLocalFile: isUploading,
     });
-    const {updateVideoPopoverMenuPlayerRef, updatePlaybackSpeed, updateSource: updatePopoverMenuSource} = useVideoPopoverMenuContext();
+    const {videoPopoverMenuPlayerRef, currentPlaybackSpeed, setCurrentPlaybackSpeed, setSource: setPopoverMenuSource} = useVideoPopoverMenuContext();
+    const {source} = videoPopoverMenuPlayerRef.current?.props ?? {};
+    const shouldUseNewRate = typeof source === 'number' || !source || source.uri !== sourceURL;
 
     const togglePlayCurrentVideo = useCallback(() => {
+        setIsEnded(false);
+        videoResumeTryNumberRef.current = 0;
         if (!isCurrentlyURLSet) {
             updateCurrentURLAndReportID(url, reportID);
-            return;
-        }
-
-        const player = videoPlayerRef.current;
-        if (isLoading || !player) {
-            return;
-        }
-
-        if (player.playing) {
+        } else if (isPlaying) {
             pauseVideo();
-            return;
-        }
-
-        if (isEnded) {
-            replayVideo();
-            return;
+        } else {
+            playVideo();
         }
-
-        playVideo();
-    }, [isCurrentlyURLSet, isLoading, updateCurrentURLAndReportID, url, reportID, pauseVideo, isEnded, playVideo, replayVideo]);
+    }, [isCurrentlyURLSet, isPlaying, pauseVideo, playVideo, reportID, updateCurrentURLAndReportID, url, videoResumeTryNumberRef]);
 
     const hideControl = useCallback(() => {
         if (isEnded) {
             return;
         }
 
-        controlsOpacity.set(withTiming(0, {duration: 500}, () => scheduleOnRN(setControlStatusState, CONST.VIDEO_PLAYER.CONTROLS_STATUS.HIDE)));
+        controlsOpacity.set(withTiming(0, {duration: 500}, () => runOnJS(setControlStatusState)(CONST.VIDEO_PLAYER.CONTROLS_STATUS.HIDE)));
     }, [controlsOpacity, isEnded]);
     const debouncedHideControl = useMemo(() => debounce(hideControl, 1500), [hideControl]);
 
@@ -199,73 +164,150 @@ function BaseVideoPlayer({
     }, [controlStatusState, controlsOpacity, hideControl]);
 
     const showPopoverMenu = (event?: GestureResponderEvent | KeyboardEvent) => {
-        updateVideoPopoverMenuPlayerRef(videoPlayerRef.current);
-        if (!videoPlayerRef.current?.playbackRate) {
-            return;
-        }
-        updatePlaybackSpeed(videoPlayerRef.current.playbackRate as PlaybackSpeed);
-        setIsPopoverVisible(true);
-
-        updatePopoverMenuSource(url);
+        videoPopoverMenuPlayerRef.current = videoPlayerRef.current;
+        videoPlayerRef.current?.getStatusAsync().then((status) => {
+            if (!('rate' in status && status.rate)) {
+                return;
+            }
+            if (shouldUseNewRate) {
+                setCurrentPlaybackSpeed(status.rate as PlaybackSpeed);
+            }
+            setIsPopoverVisible(true);
+        });
+        setPopoverMenuSource(url);
         if (!event || !('nativeEvent' in event)) {
             return;
         }
         setPopoverAnchorPosition({horizontal: event.nativeEvent.pageX, vertical: event.nativeEvent.pageY});
     };
 
-    useEventListener(videoPlayerRef.current, 'mutedChange', (payload: MutedChangeEventPayload) => {
-        if (payload.muted || !payload.oldMuted) {
-            return;
-        }
-        updateVolume(lastNonZeroVolume.get());
-    });
+    const hidePopoverMenu = () => {
+        setIsPopoverVisible(false);
+    };
 
-    useEventListener(videoPlayerRef.current, 'playingChange', (payload: PlayingChangeEventPayload) => {
-        const isVideoPlaying = payload.isPlaying;
-        if (isVideoPlaying && isEnded) {
-            setIsEnded(false);
-        }
-    });
+    // fix for iOS mWeb: preventing iOS native player default behavior from pausing the video when exiting fullscreen
+    const preventPausingWhenExitingFullscreen = useCallback(
+        (isVideoPlaying: boolean) => {
+            if (videoResumeTryNumberRef.current === 0 || isVideoPlaying) {
+                return;
+            }
+            if (videoResumeTryNumberRef.current === 1) {
+                playVideo();
+            }
+            // eslint-disable-next-line react-compiler/react-compiler
+            videoResumeTryNumberRef.current -= 1;
+        },
+        [playVideo, videoResumeTryNumberRef],
+    );
+    const prevIsMuted = useSharedValue(true);
+    const prevVolume = useSharedValue(0);
+
+    const handlePlaybackStatusUpdate = useCallback(
+        (status: AVPlaybackStatus) => {
+            if (!status.isLoaded) {
+                preventPausingWhenExitingFullscreen(false);
+                setIsPlaying(false);
+                setIsLoading(true); // when video is ready to display duration is not NaN
+                setIsBuffering(false);
+                setDuration(videoDuration * 1000);
+                setPosition(0);
+                onPlaybackStatusUpdate?.(status);
+                return;
+            }
+            if (status.didJustFinish) {
+                setIsEnded(status.didJustFinish && !status.isLooping);
+                setControlStatusState(CONST.VIDEO_PLAYER.CONTROLS_STATUS.SHOW);
+                controlsOpacity.set(1);
+            } else if (status.isPlaying && isEnded) {
+                setIsEnded(false);
+            }
 
-    useEventListener(videoPlayerRef.current, 'statusChange', (payload: StatusChangeEventPayload) => {
-        if (isSafariLoading) {
-            setIsSafariLoading(false);
-        }
-        if (payload.status !== 'readyToPlay') {
-            return;
-        }
-        isReadyForDisplayRef.current = true;
-        if (videoPlayerRef.current === currentVideoPlayerRef.current && isFirstLoad) {
-            playVideo();
-            setIsFirstLoad(false);
-        }
-    });
+            // These two conditions are essential for the mute and unmute functionality to work properly during
+            // fullscreen playback on the web
+            if (prevIsMuted.get() && prevVolume.get() === 0 && !status.isMuted && status.volume === 0) {
+                updateVolume(lastNonZeroVolume.get());
+            }
 
-    useEventListener(videoPlayerRef.current, 'playToEnd', () => {
-        setIsEnded(true);
-        setControlStatusState(CONST.VIDEO_PLAYER.CONTROLS_STATUS.SHOW);
-        controlsOpacity.set(1);
-    });
+            if (isFullScreenRef.current && prevVolume.get() !== 0 && status.volume === 0 && !status.isMuted) {
+                currentVideoPlayerRef.current?.setStatusAsync({isMuted: true});
+            }
+            prevIsMuted.set(status.isMuted);
+            prevVolume.set(status.volume);
 
-    useEventListener(videoPlayerRef.current, 'sourceLoad', (event) => {
-        onSourceLoaded?.(event);
-    });
+            const isVideoPlaying = status.isPlaying;
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+            const currentDuration = status.durationMillis || videoDuration * 1000;
+            const currentPosition = status.positionMillis || 0;
 
-    useEffect(() => {
-        if (!videoPlayerRef.current.duration) {
+            if (shouldReplayVideo(status, isVideoPlaying, currentDuration, currentPosition) && !isEnded) {
+                videoPlayerRef.current?.setStatusAsync({positionMillis: 0, shouldPlay: true});
+            }
+
+            preventPausingWhenExitingFullscreen(isVideoPlaying);
+            setIsPlaying(isVideoPlaying);
+            setIsLoading(Number.isNaN(status.durationMillis)); // when video is ready to display duration is not NaN
+            setIsBuffering(status.isBuffering);
+            setDuration(currentDuration);
+            setPosition(currentPosition);
+
+            videoStateRef.current = status;
+            onPlaybackStatusUpdate?.(status);
+        },
+        // eslint-disable-next-line react-compiler/react-compiler, react-hooks/exhaustive-deps -- we don't want to trigger this when isPlaying changes because isPlaying is only used inside shouldReplayVideo
+        [onPlaybackStatusUpdate, preventPausingWhenExitingFullscreen, videoDuration, isEnded],
+    );
+
+    const handleFullscreenUpdate = useCallback(
+        (event: VideoFullscreenUpdateEvent) => {
+            onFullscreenUpdate?.(event);
+
+            if (event.fullscreenUpdate === VideoFullscreenUpdate.PLAYER_DID_PRESENT) {
+                // When the video is in fullscreen, we don't want the scroll to be captured by the InvertedFlatList of report screen.
+                // This will also allow the user to scroll the video playback speed.
+                if (videoPlayerElementParentRef.current && 'addEventListener' in videoPlayerElementParentRef.current) {
+                    videoPlayerElementParentRef.current.addEventListener('wheel', stopWheelPropagation);
+                }
+            }
+
+            if (event.fullscreenUpdate === VideoFullscreenUpdate.PLAYER_DID_DISMISS) {
+                if (videoPlayerElementParentRef.current && 'removeEventListener' in videoPlayerElementParentRef.current) {
+                    videoPlayerElementParentRef.current.removeEventListener('wheel', stopWheelPropagation);
+                }
+                isFullScreenRef.current = false;
+
+                // Sync volume updates in full screen mode after leaving it
+                currentVideoPlayerRef.current?.getStatusAsync?.().then((status) => {
+                    if (!('isMuted' in status)) {
+                        return;
+                    }
+                    updateVolume(status.isMuted ? 0 : status.volume || 1);
+                });
+
+                // we need to use video state ref to check if video is playing, to catch proper state after exiting fullscreen
+                // and also fix a bug with fullscreen mode dismissing when handleFullscreenUpdate function changes
+                if (videoStateRef.current && (!('isPlaying' in videoStateRef.current) || videoStateRef.current.isPlaying)) {
+                    pauseVideo();
+                    playVideo();
+                    videoResumeTryNumberRef.current = 3;
+                }
+            }
+        },
+        [isFullScreenRef, onFullscreenUpdate, pauseVideo, playVideo, videoResumeTryNumberRef, updateVolume, currentVideoPlayerRef, stopWheelPropagation],
+    );
+
+    const bindFunctions = useCallback(() => {
+        const currentVideoPlayer = currentVideoPlayerRef.current;
+        if (!currentVideoPlayer) {
             return;
         }
-        setDuration(videoPlayerRef.current.duration);
-    }, [videoPlayerRef.current.duration]);
+        currentVideoPlayer._onPlaybackStatusUpdate = handlePlaybackStatusUpdate;
+        currentVideoPlayer._onFullscreenUpdate = handleFullscreenUpdate;
 
-    useEffect(() => {
-        mountedVideoPlayersRef.current.push(url);
-        return () => {
-            const mountedVideoPlayersCurrentRef = mountedVideoPlayersRef;
-            const urlIndex = mountedVideoPlayersCurrentRef.current.indexOf(url);
-            mountedVideoPlayersCurrentRef.current.splice(urlIndex, 1);
-        };
-    }, [mountedVideoPlayersRef, url]);
+        // update states after binding
+        currentVideoPlayer.getStatusAsync().then((status) => {
+            handlePlaybackStatusUpdate(status);
+        });
+    }, [currentVideoPlayerRef, handleFullscreenUpdate, handlePlaybackStatusUpdate]);
 
     // use `useLayoutEffect` instead of `useEffect` because ref is null when unmount in `useEffect` hook
     // ref url: https://reactjs.org/blog/2020/08/10/react-v17-rc.html#effect-cleanup-timing
@@ -274,14 +316,11 @@ function BaseVideoPlayer({
             if (shouldUseSharedVideoElement || videoPlayerRef.current !== currentVideoPlayerRef.current) {
                 return;
             }
-            if (currentVideoPlayerRef.current) {
-                currentVideoPlayerRef.current.pause();
-                // eslint-disable-next-line react-compiler/react-compiler
-                currentVideoPlayerRef.current.currentTime = 0;
+            currentVideoPlayerRef.current?.setStatusAsync?.({shouldPlay: false, positionMillis: 0}).then(() => {
                 currentVideoPlayerRef.current = null;
-            }
+            });
         },
-        [currentVideoPlayerRef, mountedVideoPlayersRef, shouldUseSharedVideoElement, url],
+        [currentVideoPlayerRef, shouldUseSharedVideoElement],
     );
 
     useEffect(() => {
@@ -295,8 +334,7 @@ function BaseVideoPlayer({
         }
 
         currentVideoPlayerRef.current = videoPlayerRef.current;
-        currentVideoViewRef.current = videoViewRef.current;
-    }, [url, currentVideoPlayerRef, isUploading, pauseVideo, currentVideoViewRef]);
+    }, [url, currentVideoPlayerRef, isUploading, pauseVideo]);
 
     const isCurrentlyURLSetRef = useRef<boolean | undefined>(undefined);
     isCurrentlyURLSetRef.current = isCurrentlyURLSet;
@@ -317,16 +355,28 @@ function BaseVideoPlayer({
         // On mobile safari, we need to auto-play when sharing video element here
         shareVideoPlayerElements(
             videoPlayerRef.current,
-            videoViewRef.current,
             videoPlayerElementParentRef.current,
             videoPlayerElementRef.current,
-            isUploading || isFullScreenRef.current || !isReadyForDisplayRef.current || hasError,
+            isUploading || isFullScreenRef.current || (!isReadyForDisplayRef.current && !isMobileSafari()),
             {shouldUseSharedVideoElement, url, reportID},
         );
-    }, [currentlyPlayingURL, shouldUseSharedVideoElement, shareVideoPlayerElements, url, isUploading, reportID, videoPlayerRef, isFullScreenRef, hasError]);
+    }, [currentlyPlayingURL, shouldUseSharedVideoElement, shareVideoPlayerElements, url, isUploading, isFullScreenRef, reportID]);
+
+    // Call bindFunctions() through the refs to avoid adding it to the dependency array of the DOM mutation effect, as doing so would change the DOM when the functions update.
+    const bindFunctionsRef = useRef<(() => void) | null>(null);
+    const shouldBindFunctionsRef = useRef(false);
+
+    useEffect(() => {
+        bindFunctionsRef.current = bindFunctions;
+        if (shouldBindFunctionsRef.current) {
+            bindFunctions();
+        }
+    }, [bindFunctions]);
 
     // append shared video element to new parent (used for example in attachment modal)
     useEffect(() => {
+        shouldBindFunctionsRef.current = false;
+
         if (url !== currentlyPlayingURL || !sharedElement || isFullScreenRef.current) {
             return;
         }
@@ -339,16 +389,12 @@ function BaseVideoPlayer({
             }
             return;
         }
-        if (currentVideoPlayerRef.current) {
-            videoPlayerRef.current = currentVideoPlayerRef.current;
-            videoViewRef.current = currentVideoViewRef.current;
-        }
+
+        videoPlayerRef.current = currentVideoPlayerRef.current;
         if (currentlyPlayingURL === url && newParentRef && 'appendChild' in newParentRef) {
-            if (newParentRef.hasChildNodes()) {
-                newParentRef.firstElementChild?.replaceWith(sharedElement as HTMLDivElement);
-            } else {
-                newParentRef.appendChild(sharedElement as HTMLDivElement);
-            }
+            newParentRef.appendChild(sharedElement as HTMLDivElement);
+            bindFunctionsRef.current?.();
+            shouldBindFunctionsRef.current = true;
         }
         return () => {
             if (!originalParent || !('appendChild' in originalParent)) {
@@ -359,13 +405,9 @@ function BaseVideoPlayer({
             if (!newParentRef || !('childNodes' in newParentRef)) {
                 return;
             }
-            const mountedVideoPlayersCurrentRef = mountedVideoPlayersRef;
-            if (mountedVideoPlayersCurrentRef.current.filter((u) => u === url).length > 0) {
-                return;
-            }
             newParentRef.childNodes[0]?.remove();
         };
-    }, [currentVideoPlayerRef, currentVideoViewRef, currentlyPlayingURL, isFullScreenRef, mountedVideoPlayersRef, originalParent, reportID, sharedElement, shouldUseSharedVideoElement, url]);
+    }, [currentVideoPlayerRef, currentlyPlayingURL, isFullScreenRef, originalParent, reportID, sharedElement, shouldUseSharedVideoElement, url]);
 
     useEffect(() => {
         if (!shouldPlay) {
@@ -374,15 +416,9 @@ function BaseVideoPlayer({
         updateCurrentURLAndReportID(url, reportID);
     }, [reportID, shouldPlay, updateCurrentURLAndReportID, url]);
 
-    // ensure that video loads after page refresh on iOS Safari
     useEffect(() => {
-        const videoElement = videoViewRef.current?.nativeRef?.current as HTMLVideoElement;
-        if (!videoElement || hasError || !isSafari() || sharedElement) {
-            return;
-        }
-        videoElement.load();
-        setIsSafariLoading(true);
-    }, [hasError, sharedElement]);
+        videoPlayerRef.current?.setStatusAsync({isMuted: true});
+    }, []);
 
     return (
         <>
@@ -436,73 +472,78 @@ function BaseVideoPlayer({
                                             videoPlayerElementParentRef.current = el;
                                         }}
                                     >
-                                        <VideoView
-                                            allowsFullscreen
-                                            player={videoPlayerRef.current}
+                                        <Video
+                                            ref={videoPlayerRef}
                                             style={[styles.w100, styles.h100, videoPlayerStyle]}
-                                            nativeControls={isFullScreenRef.current}
-                                            playsInline
-                                            testID={CONST.VIDEO_PLAYER_TEST_ID}
-                                            ref={videoViewRef}
-                                            contentFit="contain"
-                                            onFullscreenEnter={() => {
-                                                isFullScreenRef.current = true;
-
-                                                if (!(videoPlayerElementParentRef.current && 'addEventListener' in videoPlayerElementParentRef.current)) {
+                                            videoStyle={[styles.w100, styles.h100, videoStyle]}
+                                            source={{
+                                                // if video is loading and is offline, we want to change uri to "" to
+                                                // reset the video player after connection is back
+                                                uri: !isLoading || (isLoading && !isOffline) ? sourceURL : '',
+                                            }}
+                                            shouldPlay={shouldPlay}
+                                            useNativeControls={false}
+                                            resizeMode={resizeMode as ResizeMode}
+                                            isLooping={isLooping}
+                                            onReadyForDisplay={(e) => {
+                                                isReadyForDisplayRef.current = true;
+                                                onVideoLoaded?.(e);
+                                                if (shouldUseNewRate) {
                                                     return;
                                                 }
-                                                // When the video is in fullscreen, we don't want the scroll to be captured by the InvertedFlatList of report screen.
-                                                // This will also allow the user to scroll the video playback speed.
-                                                videoPlayerElementParentRef.current.addEventListener('wheel', stopWheelPropagation);
+                                                videoPlayerRef.current?.setStatusAsync?.({rate: currentPlaybackSpeed});
                                             }}
-                                            onFullscreenExit={() => {
-                                                isFullScreenRef.current = false;
-
-                                                if (videoPlayerElementParentRef.current && 'removeEventListener' in videoPlayerElementParentRef.current) {
-                                                    videoPlayerElementParentRef.current.removeEventListener('wheel', stopWheelPropagation);
+                                            onLoad={() => {
+                                                if (hasError) {
+                                                    setHasError(false);
                                                 }
-
-                                                // Sync volume updates in full screen mode after leaving it
-                                                updateVolume(videoPlayerRef.current.muted ? 0 : videoPlayerRef.current.volume || 1);
+                                                if (!isCurrentlyURLSet || isUploading) {
+                                                    return;
+                                                }
+                                                playVideo();
                                             }}
+                                            onPlaybackStatusUpdate={handlePlaybackStatusUpdate}
+                                            onFullscreenUpdate={handleFullscreenUpdate}
+                                            onError={() => {
+                                                // No need to set hasError while offline, since the offline indicator is already shown.
+                                                // Once the user reconnects, if the video is unsupported, the error will be triggered again.
+                                                if (isOffline) {
+                                                    return;
+                                                }
+                                                setHasError(true);
+                                            }}
+                                            testID={CONST.VIDEO_PLAYER_TEST_ID}
                                         />
                                     </View>
                                 )}
                             </PressableWithoutFeedback>
-                            {hasError && !isOffline && <VideoErrorIndicator isPreview={isPreview} />}
-                            {shouldShowLoadingIndicator && (
-                                <FullScreenLoadingIndicator
-                                    style={[styles.opacity1, styles.bgTransparent]}
-                                    shouldUseGoBackButton={false}
+                            {hasError && !isBuffering && !isOffline && <VideoErrorIndicator isPreview={isPreview} />}
+                            {((isLoading && !isOffline && !hasError) || (isBuffering && !isPlaying && !hasError)) && (
+                                <FullScreenLoadingIndicator style={[styles.opacity1, styles.bgTransparent]} />
+                            )}
+                            {isLoading && (isOffline || !isBuffering) && <AttachmentOfflineIndicator isPreview={isPreview} />}
+                            {controlStatusState !== CONST.VIDEO_PLAYER.CONTROLS_STATUS.HIDE && !isLoading && (isPopoverVisible || isHovered || canUseTouchScreen || isEnded) && (
+                                <VideoPlayerControls
+                                    duration={duration}
+                                    position={position}
+                                    url={url}
+                                    videoPlayerRef={videoPlayerRef}
+                                    isPlaying={isPlaying}
+                                    small={shouldUseSmallVideoControls}
+                                    style={[videoControlsStyle, controlsAnimatedStyle]}
+                                    togglePlayCurrentVideo={togglePlayCurrentVideo}
+                                    controlsStatus={controlStatusState}
+                                    showPopoverMenu={showPopoverMenu}
+                                    reportID={reportID}
                                 />
                             )}
-                            {!isLoading && (isOffline || !isBuffering) && <AttachmentOfflineIndicator isPreview={isPreview} />}
-                            {controlStatusState !== CONST.VIDEO_PLAYER.CONTROLS_STATUS.HIDE &&
-                                !shouldShowLoadingIndicator &&
-                                !(hasError && !isOffline) &&
-                                (isPopoverVisible || isHovered || canUseTouchScreen || isEnded) && (
-                                    <VideoPlayerControls
-                                        duration={duration ?? 0}
-                                        position={currentTime ?? 0}
-                                        url={url}
-                                        videoPlayerRef={videoPlayerRef}
-                                        videoViewRef={videoViewRef}
-                                        isPlaying={isPlaying}
-                                        small={shouldUseSmallVideoControls}
-                                        style={[videoControlsStyle, controlsAnimatedStyle]}
-                                        togglePlayCurrentVideo={togglePlayCurrentVideo}
-                                        controlsStatus={controlStatusState}
-                                        showPopoverMenu={showPopoverMenu}
-                                        reportID={reportID}
-                                    />
-                                )}
                         </View>
                     )}
                 </Hoverable>
             </PressableWithoutFeedback>
             <VideoPopoverMenu
                 isPopoverVisible={isPopoverVisible}
-                hidePopover={() => setIsPopoverVisible(false)}
+                hidePopover={hidePopoverMenu}
                 anchorPosition={popoverAnchorPosition}
             />
         </>
diff --git a/src/components/VideoPlayer/VideoPlayerControls/index.tsx b/src/components/VideoPlayer/VideoPlayerControls/index.tsx
index 66c9517ae330..9ea5931729fa 100644
--- a/src/components/VideoPlayer/VideoPlayerControls/index.tsx
+++ b/src/components/VideoPlayer/VideoPlayerControls/index.tsx
@@ -1,5 +1,5 @@
-import type {VideoPlayer, VideoView} from 'expo-video';
-import type {RefObject} from 'react';
+import type {Video} from 'expo-av';
+import type {MutableRefObject} from 'react';
 import React, {useCallback, useMemo, useState} from 'react';
 import type {GestureResponderEvent, LayoutChangeEvent, StyleProp, ViewStyle} from 'react-native';
 import {View} from 'react-native';
@@ -8,7 +8,8 @@ import type {ValueOf} from 'type-fest';
 import * as Expensicons from '@components/Icon/Expensicons';
 import Text from '@components/Text';
 import IconButton from '@components/VideoPlayer/IconButton';
-import {convertSecondsToTime} from '@components/VideoPlayer/utils';
+import {convertMillisecondsToTime} from '@components/VideoPlayer/utils';
+import {useFullScreenContext} from '@components/VideoPlayerContexts/FullScreenContext';
 import {usePlaybackContext} from '@components/VideoPlayerContexts/PlaybackContext';
 import useLocalize from '@hooks/useLocalize';
 import useThemeStyles from '@hooks/useThemeStyles';
@@ -27,10 +28,7 @@ type VideoPlayerControlsProps = {
     url: string;
 
     /** Ref for video player. */
-    videoPlayerRef: RefObject<VideoPlayer | null>;
-
-    /** Ref for video view component. */
-    videoViewRef: RefObject<VideoView | null>;
+    videoPlayerRef: MutableRefObject<Video | null>;
 
     /** Is video playing. */
     isPlaying: boolean;
@@ -57,7 +55,6 @@ function VideoPlayerControls({
     position,
     url,
     videoPlayerRef,
-    videoViewRef,
     isPlaying,
     small = false,
     style,
@@ -69,6 +66,7 @@ function VideoPlayerControls({
     const styles = useThemeStyles();
     const {translate} = useLocalize();
     const {updateCurrentURLAndReportID} = usePlaybackContext();
+    const {isFullScreenRef} = useFullScreenContext();
     const [shouldShowTime, setShouldShowTime] = useState(false);
     const iconSpacing = small ? styles.mr3 : styles.mr4;
 
@@ -77,22 +75,20 @@ function VideoPlayerControls({
     };
 
     const enterFullScreenMode = useCallback(() => {
+        // eslint-disable-next-line react-compiler/react-compiler
+        isFullScreenRef.current = true;
         updateCurrentURLAndReportID(url, reportID);
-        videoViewRef.current?.enterFullscreen();
-    }, [reportID, updateCurrentURLAndReportID, url, videoViewRef]);
+        videoPlayerRef.current?.presentFullscreenPlayer();
+    }, [isFullScreenRef, reportID, updateCurrentURLAndReportID, url, videoPlayerRef]);
 
     const seekPosition = useCallback(
         (newPosition: number) => {
-            if (!videoPlayerRef.current) {
-                return;
-            }
-            // eslint-disable-next-line no-param-reassign, react-compiler/react-compiler
-            videoPlayerRef.current.currentTime = newPosition;
+            videoPlayerRef.current?.setStatusAsync({positionMillis: newPosition});
         },
         [videoPlayerRef],
     );
 
-    const durationFormatted = useMemo(() => convertSecondsToTime(duration), [duration]);
+    const durationFormatted = useMemo(() => convertMillisecondsToTime(duration), [duration]);
 
     return (
         <Animated.View
@@ -116,7 +112,7 @@ function VideoPlayerControls({
                         />
                         {shouldShowTime && (
                             <View style={[styles.videoPlayerControlsRow]}>
-                                <Text style={[styles.videoPlayerText, styles.videoPlayerTimeComponentWidth]}>{convertSecondsToTime(position)}</Text>
+                                <Text style={[styles.videoPlayerText, styles.videoPlayerTimeComponentWidth]}>{convertMillisecondsToTime(position)}</Text>
                                 <Text style={[styles.videoPlayerText]}>/</Text>
                                 <Text style={[styles.videoPlayerText, styles.videoPlayerTimeComponentWidth]}>{durationFormatted}</Text>
                             </View>
diff --git a/src/components/VideoPlayer/index.native.tsx b/src/components/VideoPlayer/index.native.tsx
index 8f3cc3def455..22c757391443 100644
--- a/src/components/VideoPlayer/index.native.tsx
+++ b/src/components/VideoPlayer/index.native.tsx
@@ -2,7 +2,7 @@ import React from 'react';
 import uniqueIDForVideoWithoutReport from '@components/VideoPlayerContexts/PlaybackContext/uniqueID';
 import CONST from '@src/CONST';
 import BaseVideoPlayer from './BaseVideoPlayer';
-import type VideoPlayerProps from './types';
+import type {VideoPlayerProps} from './types';
 
 function VideoPlayer({videoControlsStyle, shouldUseControlsBottomMargin = true, ...props}: VideoPlayerProps) {
     const {fakeReportID} = uniqueIDForVideoWithoutReport();
diff --git a/src/components/VideoPlayer/index.tsx b/src/components/VideoPlayer/index.tsx
index e96c6015a0a4..6c83712f8a73 100644
--- a/src/components/VideoPlayer/index.tsx
+++ b/src/components/VideoPlayer/index.tsx
@@ -1,7 +1,7 @@
 import React from 'react';
 import uniqueIDForVideoWithoutReport from '@components/VideoPlayerContexts/PlaybackContext/uniqueID';
 import BaseVideoPlayer from './BaseVideoPlayer';
-import type VideoPlayerProps from './types';
+import type {VideoPlayerProps} from './types';
 
 function VideoPlayer(props: VideoPlayerProps) {
     const {fakeReportID} = uniqueIDForVideoWithoutReport();
diff --git a/src/components/VideoPlayer/shouldReplayVideo.android.ts b/src/components/VideoPlayer/shouldReplayVideo.android.ts
new file mode 100644
index 000000000000..2fae779deae2
--- /dev/null
+++ b/src/components/VideoPlayer/shouldReplayVideo.android.ts
@@ -0,0 +1,13 @@
+import type {AVPlaybackStatusSuccess} from 'expo-av';
+
+/**
+ * Whether to replay the video when users press play button
+ */
+export default function shouldReplayVideo(e: AVPlaybackStatusSuccess, isPlaying: boolean, duration: number, position: number): boolean {
+    // When we upload an attachment on Android, didJustFinish is false and the duration is 0
+    // so we should return false if the duration is 0 to prevent auto-playing video when the video is uploading
+    if (!isPlaying && !e.didJustFinish && duration === position && duration !== 0) {
+        return true;
+    }
+    return false;
+}
diff --git a/src/components/VideoPlayer/shouldReplayVideo.ios.ts b/src/components/VideoPlayer/shouldReplayVideo.ios.ts
new file mode 100644
index 000000000000..0a923d430699
--- /dev/null
+++ b/src/components/VideoPlayer/shouldReplayVideo.ios.ts
@@ -0,0 +1,11 @@
+import type {AVPlaybackStatusSuccess} from 'expo-av';
+
+/**
+ * Whether to replay the video when users press play button
+ */
+export default function shouldReplayVideo(e: AVPlaybackStatusSuccess, isPlaying: boolean, duration: number, position: number): boolean {
+    if (!isPlaying && e.isPlaying && duration === position) {
+        return true;
+    }
+    return false;
+}
diff --git a/src/components/VideoPlayer/shouldReplayVideo.ts b/src/components/VideoPlayer/shouldReplayVideo.ts
new file mode 100644
index 000000000000..3a55562d4bd2
--- /dev/null
+++ b/src/components/VideoPlayer/shouldReplayVideo.ts
@@ -0,0 +1,9 @@
+import type {AVPlaybackStatusSuccess} from 'expo-av';
+
+/**
+ * Whether to replay the video when users press play button
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export default function shouldReplayVideo(e: AVPlaybackStatusSuccess, isPlaying: boolean, duration: number, position: number): boolean {
+    return false;
+}
diff --git a/src/components/VideoPlayer/types.ts b/src/components/VideoPlayer/types.ts
index 1a5392585108..f5aac9106675 100644
--- a/src/components/VideoPlayer/types.ts
+++ b/src/components/VideoPlayer/types.ts
@@ -1,84 +1,36 @@
-import type {SourceLoadEventPayload} from 'expo-video';
+import type {Video} from 'expo-av';
+import type {AVPlaybackStatus} from 'expo-av/build/AV';
+import type {VideoFullscreenUpdateEvent, VideoReadyForDisplayEvent} from 'expo-av/build/Video.types';
 import type {StyleProp, ViewStyle} from 'react-native';
 import type {ValueOf} from 'type-fest';
 import type CONST from '@src/CONST';
 
+type VideoWithOnFullScreenUpdate = Video & {_onFullscreenUpdate: (event: VideoFullscreenUpdateEvent) => void};
+
 type VideoPlayerProps = {
-    /**
-     * Video source used to initialize the player.
-     */
     url: string;
-
-    /**
-     * Callback fired when the sourceLoad event is triggered.
-     * @param event Data containing information about the video source that finished loading.
-     */
-    onSourceLoaded?: (event: SourceLoadEventPayload) => void;
-
-    /**
-     * Whether the video should automatically replay after it ends.
-     */
+    onVideoLoaded?: (event: VideoReadyForDisplayEvent) => void;
+    resizeMode?: string;
     isLooping?: boolean;
-
-    /**
-     * Style applied to the entire VideoPlayer component.
-     */
+    // style for the whole video player component
     style?: StyleProp<ViewStyle>;
-
-    /**
-     * Style applied to the VideoView inside the VideoPlayer component.
-     */
+    // style for the video player inside the component
     videoPlayerStyle?: StyleProp<ViewStyle>;
-
-    /**
-     * Style applied to the video player controls.
-     */
+    // style for the video element inside the video player
+    videoStyle?: StyleProp<ViewStyle>;
     videoControlsStyle?: StyleProp<ViewStyle>;
-
-    /**
-     * Duration of the video resource, in milliseconds.
-     */
     videoDuration?: number;
-
-    /**
-     * Whether the VideoPlayer should use a shared video element.
-     */
     shouldUseSharedVideoElement?: boolean;
-
-    /**
-     * Whether the video controls should be displayed in a compact layout.
-     */
     shouldUseSmallVideoControls?: boolean;
-
-    /**
-     * Whether the VideoPlayer is currently hovered.
-     */
+    shouldShowVideoControls?: boolean;
     isVideoHovered?: boolean;
-
-    /**
-     * Whether the videoControlsStyle should include additional bottom margin.
-     */
+    onFullscreenUpdate?: (event: VideoFullscreenUpdateEvent) => void;
+    onPlaybackStatusUpdate?: (status: AVPlaybackStatus) => void;
     shouldUseControlsBottomMargin?: boolean;
-
-    /**
-     * Current status of the video controls.
-     */
     controlsStatus?: ValueOf<typeof CONST.VIDEO_PLAYER.CONTROLS_STATUS>;
-
-    /**
-     * Whether the video should play automatically after loading.
-     */
     shouldPlay?: boolean;
-
-    /**
-     * Whether the VideoPlayer is displayed inside a message preview.
-     */
     isPreview?: boolean;
-
-    /**
-     * Report ID of the video resource.
-     */
     reportID?: string;
 };
 
-export default VideoPlayerProps;
+export type {VideoPlayerProps, VideoWithOnFullScreenUpdate};
diff --git a/src/components/VideoPlayer/useHandleNativeVideoControls/index.ts b/src/components/VideoPlayer/useHandleNativeVideoControls/index.ts
index 846cfee0e0dc..1c682ef73f71 100644
--- a/src/components/VideoPlayer/useHandleNativeVideoControls/index.ts
+++ b/src/components/VideoPlayer/useHandleNativeVideoControls/index.ts
@@ -6,9 +6,11 @@ import type UseHandleNativeVideoControl from './types';
  * This hook hides the download button on the native video player in full-screen mode
  * when playing a local or offline video.
  */
-const useHandleNativeVideoControls: UseHandleNativeVideoControl = ({videoViewRef, isLocalFile, isOffline}) => {
+const useHandleNativeVideoControls: UseHandleNativeVideoControl = ({videoPlayerRef, isLocalFile, isOffline}) => {
     useEffect(() => {
-        const videoElement = videoViewRef?.current?.nativeRef.current as HTMLVideoElement;
+        // @ts-expect-error Property '_video' does not exist on type VideoWithOnFullScreenUpdate
+        // eslint-disable-next-line no-underscore-dangle
+        const videoElement = videoPlayerRef?.current?._nativeRef?.current?._video as HTMLVideoElement;
         if (!videoElement) {
             return;
         }
diff --git a/src/components/VideoPlayer/useHandleNativeVideoControls/types.ts b/src/components/VideoPlayer/useHandleNativeVideoControls/types.ts
index d1f22933c02b..ea6bfd4b9a19 100644
--- a/src/components/VideoPlayer/useHandleNativeVideoControls/types.ts
+++ b/src/components/VideoPlayer/useHandleNativeVideoControls/types.ts
@@ -1,20 +1,9 @@
-import type {VideoView} from 'expo-video';
-import type {RefObject} from 'react';
+import type {MutableRefObject} from 'react';
+import type {VideoWithOnFullScreenUpdate} from '@components/VideoPlayer/types';
 
 type UseHandleNativeVideoControlParams = {
-    /**
-     * Reference to the VideoView component being handled.
-     */
-    videoViewRef: RefObject<VideoView | null>;
-
-    /**
-     * Whether the video source is a local file.
-     */
+    videoPlayerRef: MutableRefObject<VideoWithOnFullScreenUpdate | null>;
     isLocalFile: boolean;
-
-    /**
-     * Whether the user is currently in offline mode.
-     */
     isOffline: boolean;
 };
 type UseHandleNativeVideoControl = (params: UseHandleNativeVideoControlParams) => void;
diff --git a/src/components/VideoPlayer/utils.ts b/src/components/VideoPlayer/utils.ts
index 20322c385849..b366d2fd4868 100644
--- a/src/components/VideoPlayer/utils.ts
+++ b/src/components/VideoPlayer/utils.ts
@@ -1,12 +1,12 @@
-import {isMobileWebKit} from '@libs/Browser';
+import * as Browser from '@libs/Browser';
 
 /**
- * Converts seconds to '[hours:]minutes:seconds' format
+ * Converts milliseconds to '[hours:]minutes:seconds' format
  */
-function convertSecondsToTime(secondsTotal: number) {
-    const hours = Math.floor(secondsTotal / 3600);
-    const minutes = Math.floor((secondsTotal / 60) % 60);
-    const seconds = Math.floor(secondsTotal % 60)
+function convertMillisecondsToTime(milliseconds: number) {
+    const hours = Math.floor(milliseconds / 3600000);
+    const minutes = Math.floor((milliseconds / 60000) % 60);
+    const seconds = Math.floor((milliseconds / 1000) % 60)
         .toFixed(0)
         .padStart(2, '0');
     return hours > 0 ? `${hours}:${String(minutes).padStart(2, '0')}:${seconds}` : `${minutes}:${seconds}`;
@@ -18,10 +18,10 @@ function convertSecondsToTime(secondsTotal: number) {
 function addSkipTimeTagToURL(url: string, seconds: number) {
     // On iOS: mWeb (WebKit-based browser engines), we don't add the time fragment
     // because it's not supported and will throw (WebKitBlobResource error 1).
-    if (isMobileWebKit() || url.includes('#t=')) {
+    if (Browser.isMobileWebKit() || url.includes('#t=')) {
         return url;
     }
     return `${url}#t=${seconds}`;
 }
 
-export {convertSecondsToTime, addSkipTimeTagToURL};
+export {convertMillisecondsToTime, addSkipTimeTagToURL};
diff --git a/src/components/VideoPlayerContexts/PlaybackContext/index.tsx b/src/components/VideoPlayerContexts/PlaybackContext/index.tsx
index 4102fcf6175b..0ce29dda869e 100644
--- a/src/components/VideoPlayerContexts/PlaybackContext/index.tsx
+++ b/src/components/VideoPlayerContexts/PlaybackContext/index.tsx
@@ -1,6 +1,6 @@
-import type {VideoPlayer, VideoView} from 'expo-video';
-import React, {useCallback, useContext, useEffect, useMemo, useRef, useState} from 'react';
+import React, {useCallback, useContext, useEffect, useMemo, useState} from 'react';
 import type {View} from 'react-native';
+import type {VideoWithOnFullScreenUpdate} from '@components/VideoPlayer/types';
 import {getReportOrDraftReport, isChatThread} from '@libs/ReportUtils';
 import Navigation from '@navigation/Navigation';
 import type ChildrenProps from '@src/types/utils/ChildrenProps';
@@ -16,8 +16,6 @@ function PlaybackContextProvider({children}: ChildrenProps) {
     const [sharedElement, setSharedElement] = useState<PlaybackContextValues['sharedElement']>(null);
     const [originalParent, setOriginalParent] = useState<OriginalParent>(null);
     const [currentRouteReportID, setCurrentRouteReportID] = useState<ProtectedCurrentRouteReportID>(NO_REPORT_ID);
-    const mountedVideoPlayersRef = useRef([]);
-
     const resetContextProperties = () => {
         setSharedElement(null);
         setOriginalParent(null);
@@ -33,17 +31,17 @@ function PlaybackContextProvider({children}: ChildrenProps) {
                 return;
             }
 
-            if (currentlyPlayingURL && url !== currentlyPlayingURL) {
-                video.pause();
-            }
-
-            // If there's no URL (image case), pause the player by setting currentlyPlayingURL
-            // without triggering the resetPlayerData in useEffect below
             if (!url) {
-                setCurrentlyPlayingURL(reportID);
+                if (currentlyPlayingURL) {
+                    video.pause();
+                }
                 return;
             }
 
+            if (currentlyPlayingURL && url !== currentlyPlayingURL) {
+                video.pause();
+            }
+
             const report = getReportOrDraftReport(reportID);
             const isReportAChatThread = isChatThread(report);
             let reportIDtoSet;
@@ -66,8 +64,7 @@ function PlaybackContextProvider({children}: ChildrenProps) {
 
     const shareVideoPlayerElements: PlaybackContextValues['shareVideoPlayerElements'] = useCallback(
         (
-            videoPlayerRef: VideoPlayer | null,
-            videoViewRef: VideoView | null,
+            ref: VideoWithOnFullScreenUpdate | null,
             parent: View | HTMLDivElement | null,
             child: View | HTMLDivElement | null,
             shouldNotAutoPlay: boolean,
@@ -77,7 +74,7 @@ function PlaybackContextProvider({children}: ChildrenProps) {
                 return;
             }
 
-            video.updateRefs(videoPlayerRef, videoViewRef);
+            video.updateRef(ref);
             setOriginalParent(parent);
             setSharedElement(child);
             // Prevents autoplay when uploading the attachment
@@ -121,15 +118,13 @@ function PlaybackContextProvider({children}: ChildrenProps) {
             sharedElement,
             shareVideoPlayerElements,
             setCurrentlyPlayingURL,
-            currentVideoPlayerRef: video.playerRef,
-            currentVideoViewRef: video.viewRef,
+            currentVideoPlayerRef: video.ref,
             playVideo: video.play,
             pauseVideo: video.pause,
-            replayVideo: video.replay,
             stopVideo: video.stop,
             checkIfVideoIsPlaying: video.isPlaying,
+            videoResumeTryNumberRef: video.resumeTryNumberRef,
             resetVideoPlayerData: video.resetPlayerData,
-            mountedVideoPlayersRef,
         }),
         [updateCurrentURLAndReportID, currentlyPlayingURL, currentRouteReportID, originalParent, sharedElement, video, shareVideoPlayerElements],
     );
diff --git a/src/components/VideoPlayerContexts/PlaybackContext/types.ts b/src/components/VideoPlayerContexts/PlaybackContext/types.ts
index 889c1983b627..2e69aa3c4b65 100644
--- a/src/components/VideoPlayerContexts/PlaybackContext/types.ts
+++ b/src/components/VideoPlayerContexts/PlaybackContext/types.ts
@@ -1,165 +1,55 @@
-import type {VideoPlayer, VideoView} from 'expo-video';
+import type {AVPlaybackStatus} from 'expo-av';
 import type {RefObject} from 'react';
 import type {View} from 'react-native';
+import type {VideoWithOnFullScreenUpdate} from '@components/VideoPlayer/types';
 
-/**
- * Callback type for reporting the current playback status.
- * @param isPlaying Whether the video is currently playing.
- */
 type StatusCallback = (isPlaying: boolean) => void;
-
-/**
- * Function type for stopping video playback.
- */
-type StopVideo = () => void;
-
-/**
- * Represents the original parent container of the video element.
- * Can be a React Native View, an HTML div, or null if not set.
- */
 type OriginalParent = View | HTMLDivElement | null;
+type UnloadVideo = () => void;
+type StopVideo = () => void;
+type PlayVideoPromiseRef = RefObject<Promise<AVPlaybackStatus> | undefined>;
 
-/**
- * Metadata describing a video element instance.
- */
 type VideoElementData = {
-    /**
-     * Whether the video player should use a shared video element.
-     */
     shouldUseSharedVideoElement: boolean;
-
-    /**
-     * The video source URL.
-     */
     url: string;
-
-    /**
-     * The report ID associated with the video, if available.
-     */
     reportID: string | undefined;
 };
 
-/**
- * Playback-related context values available throughout the app.
- */
 type PlaybackContextValues = {
-    /**
-     * Updates the currently tracked video URL and associated report ID.
-     * @param url The new video URL.
-     * @param reportID The new report ID.
-     */
     updateCurrentURLAndReportID: (url: string | undefined, reportID: string | undefined) => void;
-
-    /**
-     * The URL of the video currently being played, or null if none.
-     */
     currentlyPlayingURL: string | null;
-
-    /**
-     * The report ID associated with the current navigation route.
-     */
     currentRouteReportID: string | undefined;
-
-    /**
-     * The original parent container of the shared video element.
-     */
     originalParent: View | HTMLDivElement | null;
-
-    /**
-     * The shared video element container, if one exists.
-     */
     sharedElement: View | HTMLDivElement | null;
-
-    /**
-     * Updates shared video player elements across different parts of the UI.
-     * @param playerRef Reference to the VideoPlayer instance.
-     * @param viewRef Reference to the VideoView instance.
-     * @param parent Parent container for the shared video element.
-     * @param child Child container for the shared video element.
-     * @param isUploading Whether the video is currently uploading.
-     * @param videoElementData Metadata describing the video element.
-     */
     shareVideoPlayerElements: (
-        playerRef: VideoPlayer | null,
-        viewRef: VideoView | null,
+        ref: VideoWithOnFullScreenUpdate | null,
         parent: View | HTMLDivElement | null,
         child: View | HTMLDivElement | null,
         isUploading: boolean,
         videoElementData: VideoElementData,
     ) => void;
-
-    /**
-     * Sets the URL of the currently playing video.
-     */
     setCurrentlyPlayingURL: React.Dispatch<React.SetStateAction<string | null>>;
 };
 
-/**
- * References and helper methods for managing video playback.
- */
 type PlaybackContextVideoRefs = {
-    /**
-     * Resets the player data in the context.
-     */
     resetPlayerData: () => void;
-
-    /**
-     * Starts video playback.
-     */
     play: () => void;
-
-    /**
-     * Pauses video playback.
-     */
     pause: () => void;
-
-    /**
-     * Restarts video playback from the beginning.
-     */
-    replay: () => void;
-
-    /**
-     * Stops video playback and resets progress.
-     */
     stop: () => void;
-
-    /**
-     * Checks whether the video is currently playing.
-     * @param statusCallback Callback receiving the playback status.
-     */
     isPlaying: (statusCallback: StatusCallback) => void;
-
-    /**
-     * Reference to the current VideoPlayer instance.
-     */
-    playerRef: RefObject<VideoPlayer | null>;
-
-    /**
-     * Reference to the current VideoView instance.
-     */
-    viewRef: RefObject<VideoView | null>;
-
-    /**
-     * Updates the current player and view references.
-     * @param playerRef Reference to the VideoPlayer.
-     * @param viewRef Reference to the VideoView.
-     */
-    updateRefs: (playerRef: VideoPlayer | null, viewRef: VideoView | null) => void;
+    resumeTryNumberRef: RefObject<number>;
+    ref: RefObject<VideoWithOnFullScreenUpdate | null>;
+    updateRef: (ref: VideoWithOnFullScreenUpdate | null) => void;
 };
 
-/**
- * Combined playback context with values and video control helpers.
- */
 type PlaybackContext = PlaybackContextValues & {
     resetVideoPlayerData: PlaybackContextVideoRefs['resetPlayerData'];
     playVideo: PlaybackContextVideoRefs['play'];
     pauseVideo: PlaybackContextVideoRefs['pause'];
-    replayVideo: PlaybackContextVideoRefs['replay'];
     stopVideo: PlaybackContextVideoRefs['stop'];
     checkIfVideoIsPlaying: PlaybackContextVideoRefs['isPlaying'];
-    currentVideoPlayerRef: PlaybackContextVideoRefs['playerRef'];
-    currentVideoViewRef: PlaybackContextVideoRefs['viewRef'];
-    mountedVideoPlayersRef: RefObject<string[]>;
+    videoResumeTryNumberRef: PlaybackContextVideoRefs['resumeTryNumberRef'];
+    currentVideoPlayerRef: PlaybackContextVideoRefs['ref'];
 };
 
-export type {PlaybackContextVideoRefs, StopVideo, PlaybackContextValues, PlaybackContext, OriginalParent};
+export type {StatusCallback, PlaybackContextValues, OriginalParent, UnloadVideo, StopVideo, PlayVideoPromiseRef, PlaybackContextVideoRefs, PlaybackContext};
diff --git a/src/components/VideoPlayerContexts/PlaybackContext/usePlaybackContextVideoRefs.ts b/src/components/VideoPlayerContexts/PlaybackContext/usePlaybackContextVideoRefs.ts
index 7893e0c62a0d..e66a4911bc5b 100644
--- a/src/components/VideoPlayerContexts/PlaybackContext/usePlaybackContextVideoRefs.ts
+++ b/src/components/VideoPlayerContexts/PlaybackContext/usePlaybackContextVideoRefs.ts
@@ -1,60 +1,88 @@
-import {useCallback, useMemo, useRef} from 'react';
-import type {PlaybackContextVideoRefs, StopVideo} from './types';
+import type {AVPlaybackStatus, AVPlaybackStatusToSet} from 'expo-av';
+import {useCallback, useEffect, useMemo, useRef} from 'react';
+import Visibility from '@libs/Visibility';
+import type {PlaybackContextVideoRefs, PlayVideoPromiseRef, StopVideo, UnloadVideo} from './types';
 
 function usePlaybackContextVideoRefs(resetCallback: () => void) {
-    const currentVideoPlayerRef: PlaybackContextVideoRefs['playerRef'] = useRef(null);
-    const currentVideoViewRef: PlaybackContextVideoRefs['viewRef'] = useRef(null);
-
-    const playVideo: PlaybackContextVideoRefs['play'] = useCallback(() => {
-        currentVideoPlayerRef.current?.play();
-    }, []);
+    const currentVideoPlayerRef: PlaybackContextVideoRefs['ref'] = useRef(null);
+    const videoResumeTryNumberRef: PlaybackContextVideoRefs['resumeTryNumberRef'] = useRef(0);
+    const playVideoPromiseRef: PlayVideoPromiseRef = useRef(undefined);
+    const isPlayPendingRef = useRef(false);
 
     const pauseVideo: PlaybackContextVideoRefs['pause'] = useCallback(() => {
-        currentVideoPlayerRef.current?.pause();
-    }, []);
-
-    const replayVideo: PlaybackContextVideoRefs['replay'] = useCallback(() => {
-        currentVideoPlayerRef.current?.replay();
-    }, []);
+        currentVideoPlayerRef.current?.setStatusAsync?.({shouldPlay: false});
+    }, [currentVideoPlayerRef]);
 
     const stopVideo: StopVideo = useCallback(() => {
-        if (!currentVideoPlayerRef.current) {
+        currentVideoPlayerRef.current?.setStatusAsync?.({shouldPlay: false, positionMillis: 0});
+    }, [currentVideoPlayerRef]);
+
+    const playVideo: PlaybackContextVideoRefs['play'] = useCallback(() => {
+        if (!Visibility.isVisible()) {
+            isPlayPendingRef.current = true;
             return;
         }
-        currentVideoPlayerRef.current.pause();
-        currentVideoPlayerRef.current.currentTime = 0;
+        currentVideoPlayerRef.current?.getStatusAsync?.().then((status) => {
+            const newStatus: AVPlaybackStatusToSet = {shouldPlay: true};
+            if ('durationMillis' in status && status.durationMillis === status.positionMillis) {
+                newStatus.positionMillis = 0;
+            }
+            playVideoPromiseRef.current = currentVideoPlayerRef.current?.setStatusAsync(newStatus).catch((error: AVPlaybackStatus) => {
+                return error;
+            });
+        });
+    }, [currentVideoPlayerRef]);
+
+    const unloadVideo: UnloadVideo = useCallback(() => {
+        currentVideoPlayerRef.current?.unloadAsync?.();
     }, [currentVideoPlayerRef]);
 
     const checkIfVideoIsPlaying: PlaybackContextVideoRefs['isPlaying'] = useCallback(
-        (statusCallback) => statusCallback(currentVideoPlayerRef.current?.playing ?? false),
+        (statusCallback) => {
+            currentVideoPlayerRef.current?.getStatusAsync?.().then((status) => {
+                statusCallback('isPlaying' in status && status.isPlaying);
+            });
+        },
         [currentVideoPlayerRef],
     );
 
     const resetVideoPlayerData: PlaybackContextVideoRefs['resetPlayerData'] = useCallback(() => {
-        stopVideo();
-        currentVideoPlayerRef.current = null;
-        currentVideoViewRef.current = null;
-        resetCallback();
-    }, [resetCallback, stopVideo]);
-
-    const updateCurrentVideoPlayerRefs: PlaybackContextVideoRefs['updateRefs'] = (playerRef, viewRef) => {
-        currentVideoPlayerRef.current = playerRef;
-        currentVideoViewRef.current = viewRef;
+        // Play video is an async operation and if we call stop video before the promise is completed,
+        // it will throw a console error. So, we'll wait until the promise is resolved before stopping the video.
+        (playVideoPromiseRef.current ?? Promise.resolve()).then(stopVideo).finally(() => {
+            videoResumeTryNumberRef.current = 0;
+            resetCallback();
+            unloadVideo();
+            currentVideoPlayerRef.current = null;
+        });
+    }, [resetCallback, stopVideo, unloadVideo]);
+
+    useEffect(() => {
+        return Visibility.onVisibilityChange(() => {
+            if (!Visibility.isVisible() || !isPlayPendingRef.current) {
+                return;
+            }
+            playVideo();
+            isPlayPendingRef.current = false;
+        });
+    }, [playVideo]);
+
+    const updateCurrentVideoPlayerRef: PlaybackContextVideoRefs['updateRef'] = (ref) => {
+        currentVideoPlayerRef.current = ref;
     };
 
     return useMemo(
         (): PlaybackContextVideoRefs => ({
-            playerRef: currentVideoPlayerRef,
-            viewRef: currentVideoViewRef,
-            play: playVideo,
+            resetPlayerData: resetVideoPlayerData,
+            isPlaying: checkIfVideoIsPlaying,
             pause: pauseVideo,
-            replay: replayVideo,
             stop: stopVideo,
-            isPlaying: checkIfVideoIsPlaying,
-            resetPlayerData: resetVideoPlayerData,
-            updateRefs: updateCurrentVideoPlayerRefs,
+            play: playVideo,
+            ref: currentVideoPlayerRef,
+            resumeTryNumberRef: videoResumeTryNumberRef,
+            updateRef: updateCurrentVideoPlayerRef,
         }),
-        [checkIfVideoIsPlaying, pauseVideo, playVideo, replayVideo, resetVideoPlayerData, stopVideo],
+        [checkIfVideoIsPlaying, pauseVideo, playVideo, resetVideoPlayerData, stopVideo],
     );
 }
 
diff --git a/src/components/VideoPlayerContexts/VideoPopoverMenuContext.tsx b/src/components/VideoPlayerContexts/VideoPopoverMenuContext.tsx
index 7bf16ea1d55b..ff4a349f898e 100644
--- a/src/components/VideoPlayerContexts/VideoPopoverMenuContext.tsx
+++ b/src/components/VideoPlayerContexts/VideoPopoverMenuContext.tsx
@@ -1,7 +1,7 @@
-import type {VideoPlayer} from 'expo-video';
 import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
 import * as Expensicons from '@components/Icon/Expensicons';
 import type {PopoverMenuItem} from '@components/PopoverMenu';
+import type {VideoWithOnFullScreenUpdate} from '@components/VideoPlayer/types';
 import useLocalize from '@hooks/useLocalize';
 import useNetwork from '@hooks/useNetwork';
 import addEncryptedAuthTokenToURL from '@libs/addEncryptedAuthTokenToURL';
@@ -18,23 +18,16 @@ function VideoPopoverMenuContextProvider({children}: ChildrenProps) {
     const [currentPlaybackSpeed, setCurrentPlaybackSpeed] = useState<PlaybackSpeed>(CONST.VIDEO_PLAYER.PLAYBACK_SPEEDS[3]);
     const {isOffline} = useNetwork();
     const isLocalFile = source && CONST.ATTACHMENT_LOCAL_URL_PREFIX.some((prefix) => source.startsWith(prefix));
-    const videoPopoverMenuPlayerRef = useRef<VideoPlayer>(null);
+    const videoPopoverMenuPlayerRef = useRef<VideoWithOnFullScreenUpdate | null>(null);
 
     const updatePlaybackSpeed = useCallback(
         (speed: PlaybackSpeed) => {
             setCurrentPlaybackSpeed(speed);
-            if (!videoPopoverMenuPlayerRef.current) {
-                return;
-            }
-            videoPopoverMenuPlayerRef.current.playbackRate = speed;
+            videoPopoverMenuPlayerRef.current?.setStatusAsync?.({rate: speed});
         },
         [videoPopoverMenuPlayerRef],
     );
 
-    const updateVideoPopoverMenuPlayerRef = (videoPlayer: VideoPlayer | null) => {
-        videoPopoverMenuPlayerRef.current = videoPlayer;
-    };
-
     const downloadAttachment = useCallback(() => {
         if (typeof source === 'number' || !source) {
             return;
@@ -72,7 +65,10 @@ function VideoPopoverMenuContextProvider({children}: ChildrenProps) {
         return items;
     }, [currentPlaybackSpeed, downloadAttachment, translate, updatePlaybackSpeed, isOffline, isLocalFile]);
 
-    const contextValue = useMemo(() => ({menuItems, updateVideoPopoverMenuPlayerRef, updatePlaybackSpeed, updateSource: setSource}), [menuItems, updatePlaybackSpeed, setSource]);
+    const contextValue = useMemo(
+        () => ({menuItems, videoPopoverMenuPlayerRef, currentPlaybackSpeed, updatePlaybackSpeed, setCurrentPlaybackSpeed, setSource}),
+        [menuItems, videoPopoverMenuPlayerRef, currentPlaybackSpeed, updatePlaybackSpeed, setCurrentPlaybackSpeed, setSource],
+    );
     return <Context.Provider value={contextValue}>{children}</Context.Provider>;
 }
 
diff --git a/src/components/VideoPlayerContexts/VolumeContext.tsx b/src/components/VideoPlayerContexts/VolumeContext.tsx
index 942822aea1d1..ec42c1fa7877 100644
--- a/src/components/VideoPlayerContexts/VolumeContext.tsx
+++ b/src/components/VideoPlayerContexts/VolumeContext.tsx
@@ -17,9 +17,7 @@ function VolumeContextProvider({children}: ChildrenProps) {
             if (!currentVideoPlayerRef.current) {
                 return;
             }
-            // eslint-disable-next-line react-compiler/react-compiler
-            currentVideoPlayerRef.current.volume = newVolume;
-            currentVideoPlayerRef.current.muted = newVolume === 0;
+            currentVideoPlayerRef.current.setStatusAsync({volume: newVolume, isMuted: newVolume === 0});
 
             volume.set(newVolume);
         },
diff --git a/src/components/VideoPlayerContexts/types.ts b/src/components/VideoPlayerContexts/types.ts
index e5d095d849b0..c46ecd534d5c 100644
--- a/src/components/VideoPlayerContexts/types.ts
+++ b/src/components/VideoPlayerContexts/types.ts
@@ -1,81 +1,31 @@
-import type {VideoPlayer} from 'expo-video';
-import type {RefObject} from 'react';
+import type {MutableRefObject} from 'react';
 import type {SharedValue} from 'react-native-reanimated';
 import type {TupleToUnion} from 'type-fest';
 import type {PopoverMenuItem} from '@components/PopoverMenu';
+import type {VideoWithOnFullScreenUpdate} from '@components/VideoPlayer/types';
 import type CONST from '@src/CONST';
 import type {ResponsiveLayoutProperties} from './FullScreenContext';
 
 type VolumeContext = {
-    /**
-     * Updates the current volume.
-     * @param newVolume The new volume value to set.
-     */
     updateVolume: (newVolume: number) => void;
-
-    /**
-     * The current volume value.
-     */
     volume: SharedValue<number>;
-
-    /**
-     * The last non-zero volume value before mute.
-     * This value is restored after unmuting.
-     */
     lastNonZeroVolume: SharedValue<number>;
-
-    /**
-     * Toggles the mute state.
-     */
     toggleMute: () => void;
 };
 
 type VideoPopoverMenuContext = {
-    /**
-     * The items displayed in the video popover menu.
-     */
     menuItems: PopoverMenuItem[];
-
-    /**
-     * Updates the video player reference used by the popover menu.
-     * @param ref The video player ref.
-     */
-    updateVideoPopoverMenuPlayerRef: (videoPlayer: VideoPlayer | null) => void;
-
-    /**
-     * Updates the playback speed inside VideoPopoverMenuContext.
-     * @param speed The new playback speed value.
-     */
+    videoPopoverMenuPlayerRef: MutableRefObject<VideoWithOnFullScreenUpdate | null>;
+    currentPlaybackSpeed: PlaybackSpeed;
     updatePlaybackSpeed: (speed: PlaybackSpeed) => void;
-
-    /**
-     * Updates the video source URL inside VideoPopoverMenuContext.
-     * @param source The new source URL.
-     */
-    updateSource: (source: string) => void;
+    setCurrentPlaybackSpeed: (speed: PlaybackSpeed) => void;
+    setSource: (source: string) => void;
 };
 
 type FullScreenContext = {
-    /**
-     * Whether the application is currently in fullscreen mode.
-     */
-    isFullScreenRef: RefObject<boolean>;
-
-    /**
-     * Window dimensions saved before entering fullscreen mode.
-     * Used to preserve UI state without triggering excessive re-renders.
-     */
-    lockedWindowDimensionsRef: RefObject<ResponsiveLayoutProperties | null>;
-
-    /**
-     * Sets the locked window dimensions.
-     * @param newResponsiveLayoutResult The window dimensions to lock.
-     */
+    isFullScreenRef: MutableRefObject<boolean>;
+    lockedWindowDimensionsRef: MutableRefObject<ResponsiveLayoutProperties | null>;
     lockWindowDimensions: (newResponsiveLayoutResult: ResponsiveLayoutProperties) => void;
-
-    /**
-     * Clears the locked window dimensions.
-     */
     unlockWindowDimensions: () => void;
 };
 
diff --git a/src/components/VideoPlayerPreview/index.tsx b/src/components/VideoPlayerPreview/index.tsx
index 9b435ba4cf66..54c24f95e801 100644
--- a/src/components/VideoPlayerPreview/index.tsx
+++ b/src/components/VideoPlayerPreview/index.tsx
@@ -1,5 +1,5 @@
 import {useNavigation} from '@react-navigation/native';
-import type {SourceLoadEventPayload} from 'expo-video';
+import type {VideoReadyForDisplayEvent} from 'expo-av';
 import React, {useEffect, useState} from 'react';
 import type {GestureResponderEvent} from 'react-native';
 import {View} from 'react-native';
@@ -92,16 +92,10 @@ function VideoPlayerPreview({videoUrl, thumbnailUrl, reportID, fileName, videoDi
     // We want to play the video only when the user is on the page where it was initially rendered
     const doesUserRemainOnFirstRenderRoute = useCheckIfRouteHasRemainedUnchanged(videoUrl);
 
-    // `onSourceLoaded` is passed to VideoPlayerPreview's `Video` element which is displayed only on web.
+    // `onVideoLoaded` is passed to VideoPlayerPreview's `Video` element which is displayed only on web.
     // VideoReadyForDisplayEvent type is lacking srcElement, that's why it's added here
-    const onSourceLoaded = (event: SourceLoadEventPayload) => {
-        const track = event.availableVideoTracks.at(0);
-
-        if (!track) {
-            return;
-        }
-
-        setMeasuredDimensions({width: track.size.width, height: track.size.height});
+    const onVideoLoaded = (event: VideoReadyForDisplayEvent & {srcElement: HTMLVideoElement}) => {
+        setMeasuredDimensions({width: event.srcElement.videoWidth, height: event.srcElement.videoHeight});
     };
 
     const handleOnPress = () => {
@@ -136,7 +130,7 @@ function VideoPlayerPreview({videoUrl, thumbnailUrl, reportID, fileName, videoDi
                 <View style={styles.flex1}>
                     <VideoPlayer
                         url={videoUrl}
-                        onSourceLoaded={onSourceLoaded}
+                        onVideoLoaded={onVideoLoaded as (event: VideoReadyForDisplayEvent) => void}
                         videoDuration={videoDuration}
                         shouldUseSmallVideoControls
                         style={[styles.w100, styles.h100]}