diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8b15ee6b05..ea5e43a69b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,39 @@
 
 
+## [6.6.2](https://github.com/TheWidlarzGroup/react-native-video/compare/v6.6.1...v6.6.2) (2024-09-20)
+
+
+### Features
+
+* **iOS:** rewrite DRM Module ([#4136](https://github.com/TheWidlarzGroup/react-native-video/issues/4136)) ([0e4c95d](https://github.com/TheWidlarzGroup/react-native-video/commit/0e4c95def968a4091fdd18d07215ba592eec99cb))
+
+## [6.6.1](https://github.com/TheWidlarzGroup/react-native-video/compare/v6.6.0...v6.6.1) (2024-09-18)
+
+
+### Bug Fixes
+
+* **ios:** fix side loaded text track management ([#4180](https://github.com/TheWidlarzGroup/react-native-video/issues/4180)) ([7d43d5d](https://github.com/TheWidlarzGroup/react-native-video/commit/7d43d5d3da72495e94468756be21442f96cc7a89))
+
+# [6.6.0](https://github.com/TheWidlarzGroup/react-native-video/compare/v6.5.0...v6.6.0) (2024-09-18)
+
+
+### Bug Fixes
+
+* **android:** ensure maxbitrate & selectedVideoTrack interact correctly ([#4155](https://github.com/TheWidlarzGroup/react-native-video/issues/4155)) ([7f6b500](https://github.com/TheWidlarzGroup/react-native-video/commit/7f6b500c82122325c326b6dcacaf7af8039b2b33))
+* **android:** ensure pause is well tken in account after onEnd ([#4147](https://github.com/TheWidlarzGroup/react-native-video/issues/4147)) ([b2fd8d6](https://github.com/TheWidlarzGroup/react-native-video/commit/b2fd8d62a10ee64e6208b43120ca9231008309c2))
+* **expo-plugin:** add check for existing service in AndroidManifest for notification controls  ([#4172](https://github.com/TheWidlarzGroup/react-native-video/issues/4172)) ([0538b3b](https://github.com/TheWidlarzGroup/react-native-video/commit/0538b3b46801a535c76cf52db28cee76f2aeb0c5))
+* **ios:** ensure onBandwidthUpdate is reported only when value change ([#4149](https://github.com/TheWidlarzGroup/react-native-video/issues/4149)) ([809a730](https://github.com/TheWidlarzGroup/react-native-video/commit/809a73019836f95385891c2bba5c72b0610ffcb1))
+* **ios:** losing subtitle selection on foreground ([#3707](https://github.com/TheWidlarzGroup/react-native-video/issues/3707)) ([bee4123](https://github.com/TheWidlarzGroup/react-native-video/commit/bee4123402f4bc08dd2eb19ab0011ffdc795d0e3))
+* **JS:** improve loader api to allow function call instead of component ([#4171](https://github.com/TheWidlarzGroup/react-native-video/issues/4171)) ([835186a](https://github.com/TheWidlarzGroup/react-native-video/commit/835186a321e1940932a045a59e26e43a040fa334))
+* refactor side loaded text tracks management ([#4158](https://github.com/TheWidlarzGroup/react-native-video/issues/4158)) ([84a27f3](https://github.com/TheWidlarzGroup/react-native-video/commit/84a27f3d9f90624af3c5c3cbff50d754bab9baa4))
+* **sample:** remove warning on ios with NavigationBar ([#4148](https://github.com/TheWidlarzGroup/react-native-video/issues/4148)) ([e18769a](https://github.com/TheWidlarzGroup/react-native-video/commit/e18769ab3a6a7f4ebc459ab550f105f4d18f8201))
+* **visionOS:** remove unsupported apis ([#4154](https://github.com/TheWidlarzGroup/react-native-video/issues/4154)) ([2c1fc96](https://github.com/TheWidlarzGroup/react-native-video/commit/2c1fc964bf2cb97624c8cc37ff8138465619fc61))
+
+
+### Features
+
+* **android:** upgrade dependencies / media3 1.4.1 / androidxCore to 1.13.1 / androidxActivity 1.8.2 ([#4173](https://github.com/TheWidlarzGroup/react-native-video/issues/4173)) ([e57c7bd](https://github.com/TheWidlarzGroup/react-native-video/commit/e57c7bda5df7d624d90b20620859b8a4eb3f76b7))
+
 # [6.5.0](https://github.com/TheWidlarzGroup/react-native-video/compare/v6.4.5...v6.5.0) (2024-09-04)
 
 
diff --git a/android/build.gradle b/android/build.gradle
index 5492c667f8..d153c93661 100644
--- a/android/build.gradle
+++ b/android/build.gradle
@@ -216,7 +216,7 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"
 
-    implementation "androidx.core:core:$androidxCore_version"
+    implementation "androidx.core:core-ktx:$androidxCore_version"
     implementation "androidx.activity:activity-ktx:$androidxActivity_version"
 
     // For media playback using ExoPlayer
diff --git a/android/gradle.properties b/android/gradle.properties
index 46daceb29b..b474349ba7 100644
--- a/android/gradle.properties
+++ b/android/gradle.properties
@@ -4,12 +4,12 @@ RNVideo_targetSdkVersion=34
 RNVideo_compileSdkVersion=34
 RNVideo_ndkversion=26.1.10909125
 RNVideo_buildToolsVersion=34.0.0
-RNVideo_media3Version=1.3.1
+RNVideo_media3Version=1.4.1
 RNVideo_useExoplayerIMA=false
 RNVideo_useExoplayerRtsp=false
 RNVideo_useExoplayerSmoothStreaming=true
 RNVideo_useExoplayerDash=true
 RNVideo_useExoplayerHls=true
-RNVideo_androidxCoreVersion=1.9.0
-RNVideo_androidxActivityVersion=1.7.0
+RNVideo_androidxCoreVersion=1.13.1
+RNVideo_androidxActivityVersion=1.8.2
 RNVideo_buildFromMedia3Source=false
diff --git a/android/src/main/java/com/brentvatne/common/api/SideLoadedTextTrackList.kt b/android/src/main/java/com/brentvatne/common/api/SideLoadedTextTrackList.kt
index e3d519c408..494facdc0b 100644
--- a/android/src/main/java/com/brentvatne/common/api/SideLoadedTextTrackList.kt
+++ b/android/src/main/java/com/brentvatne/common/api/SideLoadedTextTrackList.kt
@@ -11,12 +11,18 @@ import com.facebook.react.bridge.ReadableMap
 class SideLoadedTextTrackList {
     var tracks = ArrayList<SideLoadedTextTrack>()
 
+    /** return true if this and src are equals  */
+    override fun equals(other: Any?): Boolean {
+        if (other == null || other !is SideLoadedTextTrackList) return false
+        return tracks == other.tracks
+    }
+
     companion object {
         fun parse(src: ReadableArray?): SideLoadedTextTrackList? {
             if (src == null) {
                 return null
             }
-            var sideLoadedTextTrackList = SideLoadedTextTrackList()
+            val sideLoadedTextTrackList = SideLoadedTextTrackList()
             for (i in 0 until src.size()) {
                 val textTrack: ReadableMap = src.getMap(i)
                 sideLoadedTextTrackList.tracks.add(SideLoadedTextTrack.parse(textTrack))
diff --git a/android/src/main/java/com/brentvatne/common/api/Source.kt b/android/src/main/java/com/brentvatne/common/api/Source.kt
index b9ea8bf762..1e0240224b 100644
--- a/android/src/main/java/com/brentvatne/common/api/Source.kt
+++ b/android/src/main/java/com/brentvatne/common/api/Source.kt
@@ -38,6 +38,9 @@ class Source {
     /** Will crop content end at specified position */
     var cropEndMs: Int = -1
 
+    /** Will virtually consider that content before contentStartTime is a preroll ad */
+    var contentStartTime: Int = -1
+
     /** Allow to force stream content, necessary when uri doesn't contain content type (.mlp4, .m3u, ...) */
     var extension: String? = null
 
@@ -62,6 +65,11 @@ class Source {
      */
     var cmcdProps: CMCDProps? = null
 
+    /**
+     * The list of sideLoaded text tracks
+     */
+    var sideLoadedTextTracks: SideLoadedTextTrackList? = null
+
     override fun hashCode(): Int = Objects.hash(uriString, uri, startPositionMs, cropStartMs, cropEndMs, extension, metadata, headers)
 
     /** return true if this and src are equals  */
@@ -74,7 +82,9 @@ class Source {
                 startPositionMs == other.startPositionMs &&
                 extension == other.extension &&
                 drmProps == other.drmProps &&
-                cmcdProps == other.cmcdProps
+                contentStartTime == other.contentStartTime &&
+                cmcdProps == other.cmcdProps &&
+                sideLoadedTextTracks == other.sideLoadedTextTracks
             )
     }
 
@@ -133,12 +143,14 @@ class Source {
         private const val PROP_SRC_START_POSITION = "startPosition"
         private const val PROP_SRC_CROP_START = "cropStart"
         private const val PROP_SRC_CROP_END = "cropEnd"
+        private const val PROP_SRC_CONTENT_START_TIME = "contentStartTime"
         private const val PROP_SRC_TYPE = "type"
         private const val PROP_SRC_METADATA = "metadata"
         private const val PROP_SRC_HEADERS = "requestHeaders"
         private const val PROP_SRC_DRM = "drm"
         private const val PROP_SRC_CMCD = "cmcd"
         private const val PROP_SRC_TEXT_TRACKS_ALLOW_CHUNKLESS_PREPARATION = "textTracksAllowChunklessPreparation"
+        private const val PROP_SRC_TEXT_TRACKS = "textTracks"
 
         @SuppressLint("DiscouragedApi")
         private fun getUriFromAssetId(context: Context, uriString: String): Uri? {
@@ -194,10 +206,12 @@ class Source {
                 source.startPositionMs = safeGetInt(src, PROP_SRC_START_POSITION, -1)
                 source.cropStartMs = safeGetInt(src, PROP_SRC_CROP_START, -1)
                 source.cropEndMs = safeGetInt(src, PROP_SRC_CROP_END, -1)
+                source.contentStartTime = safeGetInt(src, PROP_SRC_CONTENT_START_TIME, -1)
                 source.extension = safeGetString(src, PROP_SRC_TYPE, null)
                 source.drmProps = parse(safeGetMap(src, PROP_SRC_DRM))
                 source.cmcdProps = CMCDProps.parse(safeGetMap(src, PROP_SRC_CMCD))
                 source.textTracksAllowChunklessPreparation = safeGetBool(src, PROP_SRC_TEXT_TRACKS_ALLOW_CHUNKLESS_PREPARATION, true)
+                source.sideLoadedTextTracks = SideLoadedTextTrackList.parse(safeGetArray(src, PROP_SRC_TEXT_TRACKS))
 
                 val propSrcHeadersArray = safeGetArray(src, PROP_SRC_HEADERS)
                 if (propSrcHeadersArray != null) {
diff --git a/android/src/main/java/com/brentvatne/common/react/VideoEventEmitter.kt b/android/src/main/java/com/brentvatne/common/react/VideoEventEmitter.kt
index 3ccdfb7425..026b19ab79 100644
--- a/android/src/main/java/com/brentvatne/common/react/VideoEventEmitter.kt
+++ b/android/src/main/java/com/brentvatne/common/react/VideoEventEmitter.kt
@@ -64,11 +64,11 @@ class VideoEventEmitter {
         audioTracks: ArrayList<Track>,
         textTracks: ArrayList<Track>,
         videoTracks: ArrayList<VideoTrack>,
-        trackId: String
+        trackId: String?
     ) -> Unit
     lateinit var onVideoError: (errorString: String, exception: Exception, errorCode: String) -> Unit
     lateinit var onVideoProgress: (currentPosition: Long, bufferedDuration: Long, seekableDuration: Long, currentPlaybackTime: Double) -> Unit
-    lateinit var onVideoBandwidthUpdate: (bitRateEstimate: Long, height: Int, width: Int, trackId: String) -> Unit
+    lateinit var onVideoBandwidthUpdate: (bitRateEstimate: Long, height: Int, width: Int, trackId: String?) -> Unit
     lateinit var onVideoPlaybackStateChanged: (isPlaying: Boolean, isSeeking: Boolean) -> Unit
     lateinit var onVideoSeek: (currentPosition: Long, seekTime: Long) -> Unit
     lateinit var onVideoEnd: () -> Unit
@@ -108,7 +108,7 @@ class VideoEventEmitter {
 
                     val naturalSize: WritableMap = aspectRatioToNaturalSize(videoWidth, videoHeight)
                     putMap("naturalSize", naturalSize)
-                    putString("trackId", trackId)
+                    trackId?.let { putString("trackId", it) }
                     putArray("videoTracks", videoTracksToArray(videoTracks))
                     putArray("audioTracks", audioTracksToArray(audioTracks))
                     putArray("textTracks", textTracksToArray(textTracks))
@@ -153,9 +153,13 @@ class VideoEventEmitter {
             onVideoBandwidthUpdate = { bitRateEstimate, height, width, trackId ->
                 event.dispatch(EventTypes.EVENT_BANDWIDTH) {
                     putDouble("bitrate", bitRateEstimate.toDouble())
-                    putInt("width", width)
-                    putInt("height", height)
-                    putString("trackId", trackId)
+                    if (width > 0) {
+                        putInt("width", width)
+                    }
+                    if (height > 0) {
+                        putInt("height", height)
+                    }
+                    trackId?.let { putString("trackId", it) }
                 }
             }
             onVideoPlaybackStateChanged = { isPlaying, isSeeking ->
@@ -344,15 +348,19 @@ class VideoEventEmitter {
 
     private fun aspectRatioToNaturalSize(videoWidth: Int, videoHeight: Int): WritableMap =
         Arguments.createMap().apply {
-            putInt("width", videoWidth)
-            putInt("height", videoHeight)
-            val orientation = if (videoWidth > videoHeight) {
-                "landscape"
-            } else if (videoWidth < videoHeight) {
-                "portrait"
-            } else {
-                "square"
+            if (videoWidth > 0) {
+                putInt("width", videoWidth)
+            }
+            if (videoHeight > 0) {
+                putInt("height", videoHeight)
             }
+
+            val orientation = when {
+                videoWidth > videoHeight -> "landscape"
+                videoWidth < videoHeight -> "portrait"
+                else -> "square"
+            }
+
             putString("orientation", orientation)
         }
 }
diff --git a/android/src/main/java/com/brentvatne/common/toolbox/ReactBridgeUtils.kt b/android/src/main/java/com/brentvatne/common/toolbox/ReactBridgeUtils.kt
index 10f4752aee..b4cce42612 100644
--- a/android/src/main/java/com/brentvatne/common/toolbox/ReactBridgeUtils.kt
+++ b/android/src/main/java/com/brentvatne/common/toolbox/ReactBridgeUtils.kt
@@ -3,7 +3,6 @@ package com.brentvatne.common.toolbox
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
-import java.util.HashMap
 
 /*
 * Toolbox to safe parsing of <Video props
@@ -54,6 +53,17 @@ object ReactBridgeUtils {
 
     @JvmStatic fun safeGetFloat(map: ReadableMap?, key: String?): Float = safeGetFloat(map, key, 0.0f)
 
+    @JvmStatic fun safeParseInt(value: String?, default: Int): Int {
+        if (value == null) {
+            return default
+        }
+        return try {
+            value.toInt()
+        } catch (e: java.lang.Exception) {
+            default
+        }
+    }
+
     /**
      * toStringMap converts a [ReadableMap] into a HashMap.
      *
diff --git a/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerView.java b/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerView.java
index 65f980d9a9..a19e979792 100644
--- a/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerView.java
+++ b/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerView.java
@@ -108,7 +108,6 @@
 import com.brentvatne.common.api.DRMProps;
 import com.brentvatne.common.api.ResizeMode;
 import com.brentvatne.common.api.SideLoadedTextTrack;
-import com.brentvatne.common.api.SideLoadedTextTrackList;
 import com.brentvatne.common.api.Source;
 import com.brentvatne.common.api.SubtitleStyle;
 import com.brentvatne.common.api.TimedMetadata;
@@ -116,6 +115,7 @@
 import com.brentvatne.common.api.VideoTrack;
 import com.brentvatne.common.react.VideoEventEmitter;
 import com.brentvatne.common.toolbox.DebugLog;
+import com.brentvatne.common.toolbox.ReactBridgeUtils;
 import com.brentvatne.react.BuildConfig;
 import com.brentvatne.react.R;
 import com.brentvatne.react.ReactNativeVideoManager;
@@ -139,7 +139,6 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Objects;
 import java.util.UUID;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
@@ -230,13 +229,11 @@ public class ReactExoplayerView extends FrameLayout implements
     private String audioTrackValue;
     private String videoTrackType;
     private String videoTrackValue;
-    private String textTrackType;
+    private String textTrackType = "disabled";
     private String textTrackValue;
-    private SideLoadedTextTrackList textTracks;
     private boolean disableFocus;
     private boolean focusable = true;
     private BufferingStrategy.BufferingStrategyEnum bufferingStrategy;
-    private long contentStartTime = -1L;
     private boolean disableDisconnectError;
     private boolean preventsDisplaySleepDuringVideoPlayback = true;
     private float mProgressUpdateInterval = 250.0f;
@@ -387,12 +384,13 @@ public void cleanUpResources() {
     public void onBandwidthSample(int elapsedMs, long bytes, long bitrate) {
         if (mReportBandwidth) {
             if (player == null) {
-                eventEmitter.onVideoBandwidthUpdate.invoke(bitrate, 0, 0, "-1");
+                eventEmitter.onVideoBandwidthUpdate.invoke(bitrate, 0, 0, null);
             } else {
                 Format videoFormat = player.getVideoFormat();
-                int width = videoFormat != null ? videoFormat.width : 0;
-                int height = videoFormat != null ? videoFormat.height : 0;
-                String trackId = videoFormat != null ? videoFormat.id : "-1";
+                boolean isRotatedContent = videoFormat != null && (videoFormat.rotationDegrees == 90 || videoFormat.rotationDegrees == 270);
+                int width = videoFormat != null ? (isRotatedContent ? videoFormat.height : videoFormat.width) : 0;
+                int height = videoFormat != null ? (isRotatedContent ? videoFormat.width : videoFormat.height) : 0;
+                String trackId = videoFormat != null ? videoFormat.id : null;
                 eventEmitter.onVideoBandwidthUpdate.invoke(bitrate, height, width, trackId);
             }
         }
@@ -567,6 +565,11 @@ private void reLayoutControls() {
         reLayout(playerControlView);
     }
 
+    /// returns true is adaptive bitrate shall be used
+    public boolean isUsingVideoABR() {
+        return videoTrackType == null || "auto".equals(videoTrackType);
+    }
+
     public void setDebug(boolean enableDebug) {
         this.enableDebug = enableDebug;
         refreshDebugState();
@@ -900,17 +903,25 @@ public void onServiceConnected(ComponentName name, IBinder service) {
                 playbackServiceBinder = (PlaybackServiceBinder) service;
 
                 try {
-                    playbackServiceBinder.getService().registerPlayer(player,
-                            Objects.requireNonNull((Class<Activity>) (themedReactContext.getCurrentActivity()).getClass()));
+                    Activity currentActivity = themedReactContext.getCurrentActivity();
+                    if (currentActivity != null) {
+                        playbackServiceBinder.getService().registerPlayer(player,
+                                (Class<Activity>) currentActivity.getClass());
+                    } else {
+                        // Handle the case where currentActivity is null
+                        DebugLog.w(TAG, "Could not register ExoPlayer: currentActivity is null");
+                    }
                 } catch (Exception e) {
-                    DebugLog.e(TAG, "Cloud not register ExoPlayer");
+                    DebugLog.e(TAG, "Could not register ExoPlayer: " + e.getMessage());
                 }
             }
 
             @Override
             public void onServiceDisconnected(ComponentName name) {
                 try {
-                    playbackServiceBinder.getService().unregisterPlayer(player);
+                    if (playbackServiceBinder != null) {
+                        playbackServiceBinder.getService().unregisterPlayer(player);
+                    }
                 } catch (Exception ignored) {}
 
                 playbackServiceBinder = null;
@@ -918,7 +929,7 @@ public void onServiceDisconnected(ComponentName name) {
 
             @Override
             public void onNullBinding(ComponentName name) {
-                DebugLog.e(TAG, "Cloud not register ExoPlayer");
+                DebugLog.e(TAG, "Could not register ExoPlayer");
             }
         };
 
@@ -1126,11 +1137,11 @@ private MediaSource buildMediaSource(Uri uri, String overrideExtension, DrmSessi
 
     private ArrayList<MediaSource> buildTextSources() {
         ArrayList<MediaSource> textSources = new ArrayList<>();
-        if (textTracks == null) {
+        if (source.getSideLoadedTextTracks() == null) {
             return textSources;
         }
 
-        for (SideLoadedTextTrack track : textTracks.getTracks()) {
+        for (SideLoadedTextTrack track : source.getSideLoadedTextTracks().getTracks()) {
             MediaSource textSource = buildTextSource(track.getTitle(),
                     track.getUri(),
                     track.getType(),
@@ -1261,10 +1272,7 @@ private void setPlayWhenReady(boolean playWhenReady) {
                 player.setPlayWhenReady(true);
             }
         } else {
-            // ensure playback is not ENDED, else it will trigger another ended event
-            if (player.getPlaybackState() != Player.STATE_ENDED) {
-                player.setPlayWhenReady(false);
-            }
+            player.setPlayWhenReady(false);
         }
     }
 
@@ -1424,7 +1432,7 @@ private void videoLoaded() {
             boolean isRotatedContent = videoFormat != null && (videoFormat.rotationDegrees == 90 || videoFormat.rotationDegrees == 270);
             int width = videoFormat != null ? (isRotatedContent ? videoFormat.height : videoFormat.width) : 0;
             int height = videoFormat != null ? (isRotatedContent ? videoFormat.width : videoFormat.height) : 0;
-            String trackId = videoFormat != null ? videoFormat.id : "-1";
+            String trackId = videoFormat != null ? videoFormat.id : null;
 
             // Properties that must be accessed on the main thread
             long duration = player.getDuration();
@@ -1432,7 +1440,7 @@ private void videoLoaded() {
             ArrayList<Track> audioTracks = getAudioTrackInfo();
             ArrayList<Track> textTracks  = getTextTrackInfo();
 
-            if (this.contentStartTime != -1L) {
+            if (source.getContentStartTime() != -1) {
                 ExecutorService es = Executors.newSingleThreadExecutor();
                 es.execute(() -> {
                     // To prevent ANRs caused by getVideoTrackInfo we run this on a different thread and notify the player only when we're done
@@ -1542,7 +1550,7 @@ private ArrayList<VideoTrack> getVideoTrackInfoFromManifest(int retryCount) {
         ExecutorService es = Executors.newSingleThreadExecutor();
         final DataSource dataSource = this.mediaDataSourceFactory.createDataSource();
         final Uri sourceUri = source.getUri();
-        final long startTime = this.contentStartTime * 1000 - 100; // s -> ms with 100ms offset
+        final long startTime = source.getContentStartTime() * 1000 - 100; // s -> ms with 100ms offset
 
         Future<ArrayList<VideoTrack>> result = es.submit(new Callable() {
             final DataSource ds = dataSource;
@@ -1855,11 +1863,6 @@ public void setAdLanguage(final String language) {
         adLanguage = language;
     }
 
-    public void setTextTracks(SideLoadedTextTrackList textTracks) {
-        this.textTracks = textTracks;
-        reloadSource(); // FIXME Shall be moved inside source
-    }
-
     private void reloadSource() {
         playerNeedsSource = true;
         initializePlayer();
@@ -1939,64 +1942,67 @@ public void setSelectedTrack(int trackType, String type, String value) {
                 }
             }
         } else if ("index".equals(type)) {
-            int iValue = Integer.parseInt(value);
-
-            if (trackType == C.TRACK_TYPE_VIDEO && groups.length == 1) {
-                groupIndex = 0;
-                if (iValue < groups.get(groupIndex).length) {
-                    tracks.set(0, iValue);
+            int iValue = ReactBridgeUtils.safeParseInt(value, -1);
+            if (iValue != -1) {
+                if (trackType == C.TRACK_TYPE_VIDEO && groups.length == 1) {
+                    groupIndex = 0;
+                    if (iValue < groups.get(groupIndex).length) {
+                        tracks.set(0, iValue);
+                    }
+                } else if (iValue < groups.length) {
+                    groupIndex = iValue;
                 }
-            } else if (iValue < groups.length) {
-                groupIndex = iValue;
             }
         } else if ("resolution".equals(type)) {
-            int height = Integer.parseInt(value);
-            for (int i = 0; i < groups.length; ++i) { // Search for the exact height
-                TrackGroup group = groups.get(i);
-                Format closestFormat = null;
-                int closestTrackIndex = -1;
-                boolean usingExactMatch = false;
-                for (int j = 0; j < group.length; j++) {
-                    Format format = group.getFormat(j);
-                    if (format.height == height) {
-                        groupIndex = i;
-                        tracks.set(0, j);
-                        closestFormat = null;
-                        closestTrackIndex = -1;
-                        usingExactMatch = true;
-                        break;
-                    } else if (isUsingContentResolution) {
-                        // When using content resolution rather than ads, we need to try and find the closest match if there is no exact match
-                        if (closestFormat != null) {
-                            if ((format.bitrate > closestFormat.bitrate || format.height > closestFormat.height) && format.height < height) {
-                                // Higher quality match
+            int height = ReactBridgeUtils.safeParseInt(value, -1);
+            if (height != -1) {
+                for (int i = 0; i < groups.length; ++i) { // Search for the exact height
+                    TrackGroup group = groups.get(i);
+                    Format closestFormat = null;
+                    int closestTrackIndex = -1;
+                    boolean usingExactMatch = false;
+                    for (int j = 0; j < group.length; j++) {
+                        Format format = group.getFormat(j);
+                        if (format.height == height) {
+                            groupIndex = i;
+                            tracks.set(0, j);
+                            closestFormat = null;
+                            closestTrackIndex = -1;
+                            usingExactMatch = true;
+                            break;
+                        } else if (isUsingContentResolution) {
+                            // When using content resolution rather than ads, we need to try and find the closest match if there is no exact match
+                            if (closestFormat != null) {
+                                if ((format.bitrate > closestFormat.bitrate || format.height > closestFormat.height) && format.height < height) {
+                                    // Higher quality match
+                                    closestFormat = format;
+                                    closestTrackIndex = j;
+                                }
+                            } else if (format.height < height) {
                                 closestFormat = format;
                                 closestTrackIndex = j;
                             }
-                        } else if(format.height < height) {
-                            closestFormat = format;
-                            closestTrackIndex = j;
                         }
                     }
-                }
-                // This is a fallback if the new period contains only higher resolutions than the user has selected
-                if (closestFormat == null && isUsingContentResolution && !usingExactMatch) {
-                    // No close match found - so we pick the lowest quality
-                    int minHeight = Integer.MAX_VALUE;
-                    for (int j = 0; j < group.length; j++) {
-                        Format format = group.getFormat(j);
-                        if (format.height < minHeight) {
-                            minHeight = format.height;
-                            groupIndex = i;
-                            tracks.set(0, j);
+                    // This is a fallback if the new period contains only higher resolutions than the user has selected
+                    if (closestFormat == null && isUsingContentResolution && !usingExactMatch) {
+                        // No close match found - so we pick the lowest quality
+                        int minHeight = Integer.MAX_VALUE;
+                        for (int j = 0; j < group.length; j++) {
+                            Format format = group.getFormat(j);
+                            if (format.height < minHeight) {
+                                minHeight = format.height;
+                                groupIndex = i;
+                                tracks.set(0, j);
+                            }
                         }
                     }
-                }
-                // Selecting the closest match found
-                if (closestFormat != null && closestTrackIndex != -1) {
-                    // We found the closest match instead of an exact one
-                    groupIndex = i;
-                    tracks.set(0, closestTrackIndex);
+                    // Selecting the closest match found
+                    if (closestFormat != null && closestTrackIndex != -1) {
+                        // We found the closest match instead of an exact one
+                        groupIndex = i;
+                        tracks.set(0, closestTrackIndex);
+                    }
                 }
             }
         } else if (trackType == C.TRACK_TYPE_TEXT && Util.SDK_INT > 18) { // Text default
@@ -2048,16 +2054,21 @@ public void setSelectedTrack(int trackType, String type, String value) {
 
         TrackSelectionOverride selectionOverride = new TrackSelectionOverride(groups.get(groupIndex), tracks);
 
-        DefaultTrackSelector.Parameters selectionParameters = trackSelector.getParameters()
+        DefaultTrackSelector.Parameters.Builder selectionParameters = trackSelector.getParameters()
                 .buildUpon()
                 .setExceedAudioConstraintsIfNecessary(true)
                 .setExceedRendererCapabilitiesIfNecessary(true)
                 .setExceedVideoConstraintsIfNecessary(true)
                 .setRendererDisabled(rendererIndex, false)
-                .clearOverridesOfType(selectionOverride.getType())
-                .addOverride(selectionOverride)
-                .build();
-        trackSelector.setParameters(selectionParameters);
+                .clearOverridesOfType(selectionOverride.getType());
+
+        if (trackType == C.TRACK_TYPE_VIDEO && isUsingVideoABR()) {
+            selectionParameters.setMaxVideoBitrate(maxBitRate == 0 ? Integer.MAX_VALUE : maxBitRate);
+        } else {
+            selectionParameters.addOverride(selectionOverride);
+        }
+
+        trackSelector.setParameters(selectionParameters.build());
     }
 
     private boolean isFormatSupported(Format format) {
@@ -2188,7 +2199,8 @@ public void setRateModifier(float newRate) {
 
     public void setMaxBitRateModifier(int newMaxBitRate) {
         maxBitRate = newMaxBitRate;
-        if (player != null) {
+        if (player != null && isUsingVideoABR()) {
+            // do not apply yet if not auto
             trackSelector.setParameters(trackSelector.buildUponParameters()
                     .setMaxVideoBitrate(maxBitRate == 0 ? Integer.MAX_VALUE : maxBitRate));
         }
@@ -2213,10 +2225,6 @@ public void setFocusable(boolean focusable) {
         exoPlayerView.setFocusable(this.focusable);
     }
 
-    public void setContentStartTime(int contentStartTime) {
-        this.contentStartTime = contentStartTime;
-    }
-
     public void setShowNotificationControls(boolean showNotificationControls) {
         this.showNotificationControls = showNotificationControls;
 
diff --git a/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerViewManager.kt b/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerViewManager.kt
index bb607671b1..a21b29a325 100644
--- a/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerViewManager.kt
+++ b/android/src/main/java/com/brentvatne/exoplayer/ReactExoplayerViewManager.kt
@@ -8,7 +8,6 @@ import com.brentvatne.common.api.BufferConfig
 import com.brentvatne.common.api.BufferingStrategy
 import com.brentvatne.common.api.ControlsConfig
 import com.brentvatne.common.api.ResizeMode
-import com.brentvatne.common.api.SideLoadedTextTrackList
 import com.brentvatne.common.api.Source
 import com.brentvatne.common.api.SubtitleStyle
 import com.brentvatne.common.api.ViewType
@@ -16,7 +15,6 @@ import com.brentvatne.common.react.EventTypes
 import com.brentvatne.common.toolbox.DebugLog
 import com.brentvatne.common.toolbox.ReactBridgeUtils
 import com.brentvatne.react.ReactNativeVideoManager
-import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
@@ -38,7 +36,6 @@ class ReactExoplayerViewManager(private val config: ReactExoplayerConfig) : View
         private const val PROP_SELECTED_TEXT_TRACK = "selectedTextTrack"
         private const val PROP_SELECTED_TEXT_TRACK_TYPE = "type"
         private const val PROP_SELECTED_TEXT_TRACK_VALUE = "value"
-        private const val PROP_TEXT_TRACKS = "textTracks"
         private const val PROP_PAUSED = "paused"
         private const val PROP_MUTED = "muted"
         private const val PROP_AUDIO_OUTPUT = "audioOutput"
@@ -52,7 +49,6 @@ class ReactExoplayerViewManager(private val config: ReactExoplayerConfig) : View
         private const val PROP_MIN_LOAD_RETRY_COUNT = "minLoadRetryCount"
         private const val PROP_MAXIMUM_BIT_RATE = "maxBitRate"
         private const val PROP_PLAY_IN_BACKGROUND = "playInBackground"
-        private const val PROP_CONTENT_START_TIME = "contentStartTime"
         private const val PROP_DISABLE_FOCUS = "disableFocus"
         private const val PROP_BUFFERING_STRATEGY = "bufferingStrategy"
         private const val PROP_DISABLE_DISCONNECT_ERROR = "disableDisconnectError"
@@ -180,12 +176,6 @@ class ReactExoplayerViewManager(private val config: ReactExoplayerConfig) : View
         videoView.setSelectedTextTrack(typeString, value)
     }
 
-    @ReactProp(name = PROP_TEXT_TRACKS)
-    fun setTextTracks(videoView: ReactExoplayerView, textTracks: ReadableArray?) {
-        val sideLoadedTextTracks = SideLoadedTextTrackList.parse(textTracks)
-        videoView.setTextTracks(sideLoadedTextTracks)
-    }
-
     @ReactProp(name = PROP_PAUSED, defaultBoolean = false)
     fun setPaused(videoView: ReactExoplayerView, paused: Boolean) {
         videoView.setPausedModifier(paused)
@@ -246,11 +236,6 @@ class ReactExoplayerViewManager(private val config: ReactExoplayerConfig) : View
         videoView.setFocusable(focusable)
     }
 
-    @ReactProp(name = PROP_CONTENT_START_TIME, defaultInt = -1)
-    fun setContentStartTime(videoView: ReactExoplayerView, contentStartTime: Int) {
-        videoView.setContentStartTime(contentStartTime)
-    }
-
     @ReactProp(name = PROP_BUFFERING_STRATEGY)
     fun setBufferingStrategy(videoView: ReactExoplayerView, bufferingStrategy: String) {
         val strategy = BufferingStrategy.parse(bufferingStrategy)
diff --git a/android/src/main/java/com/brentvatne/exoplayer/VideoPlaybackService.kt b/android/src/main/java/com/brentvatne/exoplayer/VideoPlaybackService.kt
index 6cf6f7d2c2..084099a22a 100644
--- a/android/src/main/java/com/brentvatne/exoplayer/VideoPlaybackService.kt
+++ b/android/src/main/java/com/brentvatne/exoplayer/VideoPlaybackService.kt
@@ -121,7 +121,7 @@ class VideoPlaybackService : MediaSessionService() {
     }
 
     private fun buildNotification(session: MediaSession): Notification {
-        val returnToPlayer = Intent(this, sourceActivity).apply {
+        val returnToPlayer = Intent(this, sourceActivity ?: this.javaClass).apply {
             flags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP
         }
 
@@ -179,17 +179,17 @@ class VideoPlaybackService : MediaSessionService() {
                 .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
                 .setSmallIcon(androidx.media3.session.R.drawable.media3_icon_circular_play)
                 // Add media control buttons that invoke intents in your media service
-                .addAction(androidx.media3.session.R.drawable.media3_notification_seek_back, "Seek Backward", seekBackwardPendingIntent) // #0
+                .addAction(androidx.media3.session.R.drawable.media3_icon_rewind, "Seek Backward", seekBackwardPendingIntent) // #0
                 .addAction(
                     if (session.player.isPlaying) {
-                        androidx.media3.session.R.drawable.media3_notification_pause
+                        androidx.media3.session.R.drawable.media3_icon_pause
                     } else {
-                        androidx.media3.session.R.drawable.media3_notification_play
+                        androidx.media3.session.R.drawable.media3_icon_play
                     },
                     "Toggle Play",
                     togglePlayPendingIntent
                 ) // #1
-                .addAction(androidx.media3.session.R.drawable.media3_notification_seek_forward, "Seek Forward", seekForwardPendingIntent) // #2
+                .addAction(androidx.media3.session.R.drawable.media3_icon_fast_forward, "Seek Forward", seekForwardPendingIntent) // #2
                 // Apply the media style template
                 .setStyle(MediaStyleNotificationHelper.MediaStyle(session).setShowActionsInCompactView(0, 1, 2))
                 .setContentTitle(session.player.mediaMetadata.title)
diff --git a/docs/pages/component/drm.mdx b/docs/pages/component/drm.mdx
index 6e7fa0aaf3..da9074d5ea 100644
--- a/docs/pages/component/drm.mdx
+++ b/docs/pages/component/drm.mdx
@@ -137,6 +137,20 @@ You can specify the DRM type, either by string or using the exported DRMType enu
 Valid values are, for Android: DRMType.WIDEVINE / DRMType.PLAYREADY / DRMType.CLEARKEY.
 for iOS: DRMType.FAIRPLAY
 
+### `localSourceEncryptionKeyScheme`
+
+<PlatformsList types={['iOS']} />
+
+Set the url scheme for stream encryption key for local assets
+
+Type: String
+
+Example:
+
+```
+localSourceEncryptionKeyScheme="my-offline-key"
+```
+
 ## Common Usage Scenarios
 
 ### Send cookies to license server
diff --git a/docs/pages/component/events.mdx b/docs/pages/component/events.mdx
index 3552d4b403..2c2f0a1d79 100644
--- a/docs/pages/component/events.mdx
+++ b/docs/pages/component/events.mdx
@@ -222,13 +222,14 @@ Callback function that is called when the media is loaded and ready to play.
 Payload:
 
 | Property    | Type   | Description                                                                                                                                                                                                                                                                                                                                                        |
-| ----------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+|-------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | currentTime | number | Time in seconds where the media will start                                                                                                                                                                                                                                                                                                                         |
 | duration    | number | Length of the media in seconds                                                                                                                                                                                                                                                                                                                                     |
 | naturalSize | object | Properties:<br/> _ width - Width in pixels that the video was encoded at<br/> _ height - Height in pixels that the video was encoded at<br/> \* orientation - "portrait", "landscape" or "square"                                                                                                                                                                  |
 | audioTracks | array  | An array of audio track info objects with the following properties:<br/> _ index - Index number<br/> _ title - Description of the track<br/> _ language - 2 letter [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) or 3 letter [ISO639-2](https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes) language code<br/> _ type - Mime type of track |
 | textTracks  | array  | An array of text track info objects with the following properties:<br/> _ index - Index number<br/> _ title - Description of the track<br/> _ language - 2 letter [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) or 3 letter [ISO 639-2](https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes) language code<br/> _ type - Mime type of track |
 | videoTracks | array  | An array of video track info objects with the following properties:<br/> _ trackId - ID for the track<br/> _ bitrate - Bit rate in bits per second<br/> _ codecs - Comma separated list of codecs<br/> _ height - Height of the video<br/> \* width - Width of the video                                                                                           |
+| trackId     | string | Provide key information about the video track, typically including: `Resolution`, `Bitrate`.                                                                                                                                                                                                                                                                                                                                                |
 
 Example:
 
@@ -260,7 +261,8 @@ Example:
     { index: 0, bitrate: 3987904, codecs: "avc1.640028", height: 720, trackId: "f1-v1-x3", width: 1280 },
     { index: 1, bitrate: 7981888, codecs: "avc1.640028", height: 1080, trackId: "f2-v1-x3", width: 1920 },
     { index: 2, bitrate: 1994979, codecs: "avc1.4d401f", height: 480, trackId: "f3-v1-x3", width: 848 }
-  ]
+  ],
+  trackId: "720p 2400kbps"
 }
 ```
 
diff --git a/docs/pages/component/props.mdx b/docs/pages/component/props.mdx
index 655161cde5..f976dfbc99 100644
--- a/docs/pages/component/props.mdx
+++ b/docs/pages/component/props.mdx
@@ -166,9 +166,13 @@ controlsStyles={{
 
 ### `contentStartTime`
 
+> [!WARNING]
+> Deprecated, use source.contentStartTime instead
+
 <PlatformsList types={['Android']} />
 
 The start time in ms for SSAI content. This determines at what time to load the video info like resolutions. Use this only when you have SSAI stream where ads resolution is not the same as content resolution.
+Note: This feature only works on DASH streams
 
 ### `debug`
 
@@ -335,19 +339,6 @@ Controls the iOS silent switch behavior
 - **"ignore"** - Play audio even if the silent switch is set
 - **"obey"** - Don't play audio if the silent switch is set
 
-### `localSourceEncryptionKeyScheme`
-
-<PlatformsList types={['iOS']} />
-
-Set the url scheme for stream encryption key for local assets
-
-Type: String
-
-Example:
-
-```
-localSourceEncryptionKeyScheme="my-offline-key"
-```
 
 ### `maxBitRate`
 
@@ -357,6 +348,9 @@ Sets the desired limit, in bits per second, of network bandwidth consumption whe
 
 Default: 0. Don't limit the maxBitRate.
 
+Note: This property can interact with selectedVideoTrack.
+To use `maxBitrate`, selectedVideoTrack shall be undefined or `{type: SelectedVideoTrackType.AUTO}`.
+
 Example:
 
 ```javascript
@@ -511,14 +505,29 @@ Speed at which the media should play.
 
 <PlatformsList types={['All']} />
 
-Allows you to create custom components to display while the video is loading. If `renderLoader` is provided, `poster` and `posterResizeMode` will be ignored.
+Allows you to create custom components to display while the video is loading.
+If `renderLoader` is provided, `poster` and `posterResizeMode` will be ignored.
+renderLoader is either a component or a function returning a component.
+It is recommended to use the function for optimization matter.
+
+`renderLoader` function be called with parameters of type `ReactVideoRenderLoaderProps` to be able to adapt loader 
+
+```typescript
+interface ReactVideoRenderLoaderProps {
+  source?: ReactVideoSource;                /// source of the video
+  style?: StyleProp<ImageStyle>;            /// style to apply
+  resizeMode?: EnumValues<VideoResizeMode>; /// resizeMode provided to the video component
+}
+````
+
+Sample:
 
 ```javascript
 <Video>
-  renderLoader={
+  renderLoader={() => (
     <View>
       <Text>Custom Loader</Text>
-    </View>
+    </View>)
   }
 </Video>
 ````
@@ -767,7 +776,7 @@ The following other types are supported on some platforms, but aren't fully docu
 
 #### Using DRM content
 
-<PlatformsList types={['Android', 'iOS']} />
+<PlatformsList types={['Android', 'iOS', 'visionOS', 'tvOS']} />
 
 To setup DRM please follow [this guide](/component/drm)
 
@@ -785,8 +794,6 @@ Example:
     },
 ```
 
-> ⚠️ DRM is not supported on visionOS yet
-
 
 #### Start playback at a specific point in time
 
@@ -833,6 +840,13 @@ source={{
   }}
 ```
 
+#### `contentStartTime`
+
+<PlatformsList types={['Android']} />
+
+The start time in ms for SSAI content. This determines at what time to load the video info like resolutions. Use this only when you have SSAI stream where ads resolution is not the same as content resolution.
+Note: This feature only works on DASH streams
+
 #### `textTracksAllowChunklessPreparation`
 <PlatformsList types={['Android']} />
 
@@ -848,6 +862,46 @@ source={{
   }}
 ```
 
+#### `textTracks`
+
+<PlatformsList types={['Android', 'iOS', 'visionOS']} />
+
+Load one or more "sidecar" text tracks. This takes an array of objects representing each track. Each object should have the format:
+
+> ⚠️ This feature does not work with HLS playlists (e.g m3u8) on iOS
+
+| Property | Description                                                                                                                                                                      |
+| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| title    | Descriptive name for the track                                                                                                                                                   |
+| language | 2 letter [ISO 639-1 code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) representing the language                                                                       |
+| type     | Mime type of the track _ TextTrackType.SRT - SubRip (.srt) _ TextTrackType.TTML - TTML (.ttml) \* TextTrackType.VTT - WebVTT (.vtt)iOS only supports VTT, Android supports all 3 |
+| uri      | URL for the text track. Currently, only tracks hosted on a webserver are supported                                                                                               |
+
+On iOS, sidecar text tracks are only supported for individual files, not HLS playlists. For HLS, you should include the text tracks as part of the playlist.
+
+Note: Due to iOS limitations, sidecar text tracks are not compatible with Airplay. If textTracks are specified, AirPlay support will be automatically disabled.
+
+Example:
+
+```javascript
+import { TextTrackType }, Video from 'react-native-video';
+
+textTracks={[
+  {
+    title: "English CC",
+    language: "en",
+    type: TextTrackType.VTT, // "text/vtt"
+    uri: "https://bitdash-a.akamaihd.net/content/sintel/subtitles/subtitles_en.vtt"
+  },
+  {
+    title: "Spanish Subtitles",
+    language: "es",
+    type: TextTrackType.SRT, // "application/x-subrip"
+    uri: "https://durian.blender.org/wp-content/content/subtitles/sintel_es.srt"
+  }
+]}
+```
+
 ### `subtitleStyle`
 
 <PlatformsList types={['Android', 'iOS']} />
@@ -892,6 +946,9 @@ This prop can be changed on runtime.
 
 ### `textTracks`
 
+> [!WARNING]
+> deprecated, use source.textTracks instead. changing text tracks will restart playback
+
 <PlatformsList types={['Android', 'iOS', 'visionOS']} />
 
 Load one or more "sidecar" text tracks. This takes an array of objects representing each track. Each object should have the format:
diff --git a/examples/basic/ios/Podfile.lock b/examples/basic/ios/Podfile.lock
index 5d670dfb15..cf2fba3817 100644
--- a/examples/basic/ios/Podfile.lock
+++ b/examples/basic/ios/Podfile.lock
@@ -46,9 +46,9 @@ PODS:
   - FBLazyVector (0.74.5)
   - fmt (9.1.0)
   - glog (0.3.5)
-  - hermes-engine (0.74.3):
-    - hermes-engine/Pre-built (= 0.74.3)
-  - hermes-engine/Pre-built (0.74.3)
+  - hermes-engine (0.74.5):
+    - hermes-engine/Pre-built (= 0.74.5)
+  - hermes-engine/Pre-built (0.74.5)
   - libavif/core (0.11.1)
   - libavif/libdav1d (0.11.1):
     - libavif/core
@@ -994,7 +994,7 @@ PODS:
   - React-Mapbuffer (0.74.5):
     - glog
     - React-debug
-  - react-native-video (6.4.5):
+  - react-native-video (6.6.1):
     - DoubleConversion
     - glog
     - hermes-engine
@@ -1008,7 +1008,7 @@ PODS:
     - React-featureflags
     - React-graphics
     - React-ImageManager
-    - react-native-video/Video (= 6.4.5)
+    - react-native-video/Video (= 6.6.1)
     - React-NativeModulesApple
     - React-RCTFabric
     - React-rendererdebug
@@ -1038,7 +1038,7 @@ PODS:
     - ReactCommon/turbomodule/bridging
     - ReactCommon/turbomodule/core
     - Yoga
-  - react-native-video/Video (6.4.5):
+  - react-native-video/Video (6.6.1):
     - DoubleConversion
     - glog
     - hermes-engine
@@ -1290,9 +1290,9 @@ PODS:
     - React-utils (= 0.74.5)
   - RNCPicker (2.7.5):
     - React-Core
-  - SDWebImage (5.19.2):
-    - SDWebImage/Core (= 5.19.2)
-  - SDWebImage/Core (5.19.2)
+  - SDWebImage (5.19.7):
+    - SDWebImage/Core (= 5.19.7)
+  - SDWebImage/Core (5.19.7)
   - SDWebImageAVIFCoder (0.11.0):
     - libavif/core (>= 0.11.0)
     - SDWebImage (~> 5.10)
@@ -1531,7 +1531,7 @@ SPEC CHECKSUMS:
   FBLazyVector: ac12dc084d1c8ec4cc4d7b3cf1b0ebda6dab85af
   fmt: 4c2741a687cc09f0634a2e2c72a838b99f1ff120
   glog: fdfdfe5479092de0c4bdbebedd9056951f092c4f
-  hermes-engine: 1f547997900dd0752dc0cc0ae6dd16173c49e09b
+  hermes-engine: 8c1577f3fdb849cbe7729c2e7b5abc4b845e88f8
   libavif: 84bbb62fb232c3018d6f1bab79beea87e35de7b7
   libdav1d: 23581a4d8ec811ff171ed5e2e05cd27bad64c39f
   libwebp: 1786c9f4ff8a279e4dac1e8f385004d5fc253009
@@ -1559,7 +1559,7 @@ SPEC CHECKSUMS:
   React-jsitracing: c83efb63c8e9e1dff72a3c56e88ae1c530a87795
   React-logger: 257858bd55f3a4e1bc0cf07ddc8fb9faba6f8c7c
   React-Mapbuffer: dce508662b995ffefd29e278a16b78217039d43d
-  react-native-video: c5cd8b71116762c5a4ceee7f7961587d99aae8e3
+  react-native-video: 8c6d22c8eedf4359fca199e217e4f53581f7b4ab
   react-native-video-plugin-sample: d3a93b7ad777cad7fa2c30473de75a2635ce5feb
   React-nativeconfig: f326487bc61eba3f0e328da6efb2711533dcac46
   React-NativeModulesApple: d89733f5baed8b9249ca5a8e497d63c550097312
@@ -1585,7 +1585,7 @@ SPEC CHECKSUMS:
   React-utils: 3f1fcffc14893afb9a7e5b7c736353873cc5fc95
   ReactCommon: f79ae672224dc1e6c2d932062176883c98eebd57
   RNCPicker: 3e2c37a8328f368ce14da050cdc8231deb5fc9f9
-  SDWebImage: dfe95b2466a9823cf9f0c6d01217c06550d7b29a
+  SDWebImage: 8a6b7b160b4d710e2a22b6900e25301075c34cb3
   SDWebImageAVIFCoder: 00310d246aab3232ce77f1d8f0076f8c4b021d90
   SDWebImageSVGCoder: 15a300a97ec1c8ac958f009c02220ac0402e936c
   SDWebImageWebPCoder: e38c0a70396191361d60c092933e22c20d5b1380
diff --git a/examples/basic/package.json b/examples/basic/package.json
index a0fcc35671..88a79a6600 100644
--- a/examples/basic/package.json
+++ b/examples/basic/package.json
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@react-native-picker/picker": "2.7.5",
-    "expo": "^51.0.31",
+    "expo": "^51.0.32",
     "expo-asset": "~10.0.10",
     "expo-image": "^1.12.15",
     "expo-navigation-bar": "~3.0.7",
diff --git a/examples/basic/src/VideoPlayer.tsx b/examples/basic/src/VideoPlayer.tsx
index 18d557ae33..569f93efeb 100644
--- a/examples/basic/src/VideoPlayer.tsx
+++ b/examples/basic/src/VideoPlayer.tsx
@@ -34,7 +34,13 @@ import Video, {
 } from 'react-native-video';
 import styles from './styles';
 import {type AdditionalSourceInfo} from './types';
-import {bufferConfig, isAndroid, srcList, textTracksSelectionBy} from './constants';
+import {
+  bufferConfig,
+  isAndroid,
+  srcList,
+  textTracksSelectionBy,
+  audioTracksSelectionBy,
+} from './constants';
 import {Overlay, toast, VideoLoader} from './components';
 import * as NavigationBar from 'expo-navigation-bar';
 
@@ -112,18 +118,23 @@ const VideoPlayer: FC<Props> = ({}) => {
   }, []);
 
   const onAudioTracks = (data: OnAudioTracksData) => {
+    console.log('onAudioTracks', data);
     const selectedTrack = data.audioTracks?.find((x: AudioTrack) => {
       return x.selected;
     });
-    if (selectedTrack?.index) {
-      setAudioTracks(data.audioTracks);
-      setSelectedAudioTrack({
-        type: SelectedTrackType.INDEX,
-        value: selectedTrack.index,
-      });
-    } else {
-      setAudioTracks(data.audioTracks);
+    let value;
+    if (audioTracksSelectionBy === SelectedTrackType.INDEX) {
+      value = selectedTrack?.index;
+    } else if (audioTracksSelectionBy === SelectedTrackType.LANGUAGE) {
+      value = selectedTrack?.language;
+    } else if (audioTracksSelectionBy === SelectedTrackType.TITLE) {
+      value = selectedTrack?.title;
     }
+    setAudioTracks(data.audioTracks);
+    setSelectedAudioTrack({
+      type: audioTracksSelectionBy,
+      value: value,
+    });
   };
 
   const onVideoTracks = (data: OnVideoTracksData) => {
@@ -136,23 +147,19 @@ const VideoPlayer: FC<Props> = ({}) => {
       return x?.selected;
     });
 
-    if (selectedTrack?.language) {
-      setTextTracks(data.textTracks);
-      let value;
-      if (textTracksSelectionBy === SelectedTrackType.INDEX) {
-        value = selectedTrack?.index;
-      } else if (textTracksSelectionBy === SelectedTrackType.LANGUAGE) {
-        value = selectedTrack?.language;
-      } else if (textTracksSelectionBy === SelectedTrackType.TITLE) {
-        value = selectedTrack?.title;
-      }
-      setSelectedTextTrack({
-        type: textTracksSelectionBy,
-        value: value,
-      });
-    } else {
-      setTextTracks(data.textTracks);
+    setTextTracks(data.textTracks);
+    let value;
+    if (textTracksSelectionBy === SelectedTrackType.INDEX) {
+      value = selectedTrack?.index;
+    } else if (textTracksSelectionBy === SelectedTrackType.LANGUAGE) {
+      value = selectedTrack?.language;
+    } else if (textTracksSelectionBy === SelectedTrackType.TITLE) {
+      value = selectedTrack?.title;
     }
+    setSelectedTextTrack({
+      type: textTracksSelectionBy,
+      value: value,
+    });
   };
 
   const onLoad = (data: OnLoadData) => {
@@ -224,13 +231,25 @@ const VideoPlayer: FC<Props> = ({}) => {
 
   const onVideoBandwidthUpdate = (data: OnBandwidthUpdateData) => {
     console.log('onVideoBandwidthUpdate', data);
-  }
+  };
 
   const onFullScreenExit = () => {
     // iOS pauses video on exit from full screen
     Platform.OS === 'ios' && setPaused(true);
   };
 
+  const _renderLoader = showPoster ? () => <VideoLoader /> : undefined;
+
+  const _subtitleStyle = {subtitlesFollowVideo: true};
+  const _controlsStyles = {
+    hideNavigationBarOnFullScreenMode: true,
+    hideNotificationBarOnFullScreenMode: true,
+  };
+  const _bufferConfig = {
+    ...bufferConfig,
+    cacheSizeMB: useCache ? 200 : 0,
+  };
+
   return (
     <View style={styles.container}>
       <StatusBar animated={true} backgroundColor="black" hidden={false} />
@@ -241,7 +260,6 @@ const VideoPlayer: FC<Props> = ({}) => {
             showNotificationControls={showNotificationControls}
             ref={videoRef}
             source={currentSrc as ReactVideoSource}
-            textTracks={additional?.textTracks}
             adTagUrl={additional?.adTagUrl}
             drm={additional?.drm}
             style={viewStyle}
@@ -274,18 +292,15 @@ const VideoPlayer: FC<Props> = ({}) => {
             selectedAudioTrack={selectedAudioTrack}
             selectedVideoTrack={selectedVideoTrack}
             playInBackground={false}
-            bufferConfig={{
-              ...bufferConfig,
-              cacheSizeMB: useCache ? 200 : 0,
-            }}
+            bufferConfig={_bufferConfig}
             preventsDisplaySleepDuringVideoPlayback={true}
-            renderLoader={showPoster ? <VideoLoader /> : undefined}
+            renderLoader={_renderLoader}
             onPlaybackRateChange={onPlaybackRateChange}
             onPlaybackStateChanged={onPlaybackStateChanged}
             bufferingStrategy={BufferingStrategyType.DEFAULT}
             debug={{enable: true, thread: true}}
-            subtitleStyle={{subtitlesFollowVideo: true}}
-            controlsStyles={{hideNavigationBarOnFullScreenMode: true, hideNotificationBarOnFullScreenMode: true}}
+            subtitleStyle={_subtitleStyle}
+            controlsStyles={_controlsStyles}
           />
         </TouchableOpacity>
       )}
diff --git a/examples/basic/src/components/AudioTracksSelector.tsx b/examples/basic/src/components/AudioTracksSelector.tsx
index 02b72f54fa..d0e1005909 100644
--- a/examples/basic/src/components/AudioTracksSelector.tsx
+++ b/examples/basic/src/components/AudioTracksSelector.tsx
@@ -1,19 +1,25 @@
 import {Picker} from '@react-native-picker/picker';
 import {Text} from 'react-native';
-import type {AudioTrack, SelectedTrack} from 'react-native-video';
+import {
+  SelectedTrackType,
+  type AudioTrack,
+  type SelectedTrack,
+} from 'react-native-video';
 import styles from '../styles';
 import React from 'react';
 
 export interface AudioTrackSelectorType {
   audioTracks: Array<AudioTrack>;
   selectedAudioTrack: SelectedTrack | undefined;
-  onValueChange: (arg0: string) => void;
+  onValueChange: (arg0: string | number) => void;
+  audioTracksSelectionBy: SelectedTrackType;
 }
 
 export const AudioTrackSelector = ({
   audioTracks,
   selectedAudioTrack,
   onValueChange,
+  audioTracksSelectionBy,
 }: AudioTrackSelectorType) => {
   return (
     <>
@@ -25,7 +31,7 @@ export const AudioTrackSelector = ({
         onValueChange={itemValue => {
           if (itemValue !== 'empty') {
             console.log('on audio value change ' + itemValue);
-            onValueChange(`${itemValue}`);
+            onValueChange(itemValue);
           }
         }}>
         {audioTracks?.length <= 0 ? (
@@ -37,11 +43,19 @@ export const AudioTrackSelector = ({
           if (!track) {
             return;
           }
+          let value;
+          if (audioTracksSelectionBy === SelectedTrackType.INDEX) {
+            value = track.index;
+          } else if (audioTracksSelectionBy === SelectedTrackType.LANGUAGE) {
+            value = track.language;
+          } else if (audioTracksSelectionBy === SelectedTrackType.TITLE) {
+            value = track.title;
+          }
           return (
             <Picker.Item
-              label={`${track.language} - ${track.title} - ${track.selected}`}
-              value={`${track.index}`}
-              key={`${track.index}`}
+              label={`${value} - ${track.selected}`}
+              value={`${value}`}
+              key={`${value}`}
             />
           );
         })}
diff --git a/examples/basic/src/components/Overlay.tsx b/examples/basic/src/components/Overlay.tsx
index 3c9c487b31..8af4d7a762 100644
--- a/examples/basic/src/components/Overlay.tsx
+++ b/examples/basic/src/components/Overlay.tsx
@@ -7,7 +7,12 @@ import React, {
 } from 'react';
 import {View} from 'react-native';
 import styles from '../styles.tsx';
-import {isAndroid, isIos, textTracksSelectionBy} from '../constants';
+import {
+  isAndroid,
+  isIos,
+  textTracksSelectionBy,
+  audioTracksSelectionBy,
+} from '../constants';
 import {
   ResizeMode,
   VideoRef,
@@ -148,17 +153,14 @@ const _Overlay = forwardRef<VideoRef, Props>((props, ref) => {
     setShowNotificationControls(prev => !prev);
   };
 
-  const onSelectedAudioTrackChange = (itemValue: string) => {
+  const onSelectedAudioTrackChange = (itemValue: string | number) => {
     console.log('on audio value change ' + itemValue);
     if (itemValue === 'none') {
       setSelectedAudioTrack({
         type: SelectedTrackType.DISABLED,
       });
     } else {
-      setSelectedAudioTrack({
-        type: SelectedTrackType.INDEX,
-        value: itemValue,
-      });
+      setSelectedAudioTrack({type: audioTracksSelectionBy, value: itemValue});
     }
   };
 
@@ -324,6 +326,7 @@ const _Overlay = forwardRef<VideoRef, Props>((props, ref) => {
                 audioTracks={audioTracks}
                 selectedAudioTrack={selectedAudioTrack}
                 onValueChange={onSelectedAudioTrackChange}
+                audioTracksSelectionBy={audioTracksSelectionBy}
               />
               <TextTrackSelector
                 textTracks={textTracks}
diff --git a/examples/basic/src/constants/general.ts b/examples/basic/src/constants/general.ts
index 6325877d23..f215fa0b4f 100644
--- a/examples/basic/src/constants/general.ts
+++ b/examples/basic/src/constants/general.ts
@@ -9,11 +9,12 @@ import {SampleVideoSource} from '../types';
 import {localeVideo} from '../assets';
 import {Platform} from 'react-native';
 
-// This constant allows to change how the sample behaves regarding to texts selection.
+// This constant allows to change how the sample behaves regarding to audio and texts selection.
 // You can change it to change how selector will use tracks information.
 // by default, index will be displayed and index will be applied to selected tracks.
-// You can also use LANGUAGE or TITLE 
+// You can also use LANGUAGE or TITLE
 export const textTracksSelectionBy = SelectedTrackType.INDEX;
+export const audioTracksSelectionBy = SelectedTrackType.INDEX;
 
 export const isIos = Platform.OS === 'ios';
 
diff --git a/examples/basic/yarn.lock b/examples/basic/yarn.lock
index 53ab63b8ef..3444c75903 100644
--- a/examples/basic/yarn.lock
+++ b/examples/basic/yarn.lock
@@ -4856,10 +4856,10 @@ expo-file-system@~17.0.1:
   resolved "https://registry.yarnpkg.com/expo-file-system/-/expo-file-system-17.0.1.tgz#b9f8af8c1c06ec71d96fd7a0d2567fa9e1c88f15"
   integrity sha512-dYpnZJqTGj6HCYJyXAgpFkQWsiCH3HY1ek2cFZVHFoEc5tLz9gmdEgTF6nFHurvmvfmXqxi7a5CXyVm0aFYJBw==
 
-expo-font@~12.0.9:
-  version "12.0.9"
-  resolved "https://registry.yarnpkg.com/expo-font/-/expo-font-12.0.9.tgz#096860a6b8b5dd54152262eafd318593ec2db48c"
-  integrity sha512-seTCyf0tbgkAnp3ZI9ZfK9QVtURQUgFnuj+GuJ5TSnN0XsOtVe1s2RxTvmMgkfuvfkzcjJ69gyRpsZS1cC8hjw==
+expo-font@~12.0.10:
+  version "12.0.10"
+  resolved "https://registry.yarnpkg.com/expo-font/-/expo-font-12.0.10.tgz#62deaf1f46159d7839f01305f44079268781b1db"
+  integrity sha512-Q1i2NuYri3jy32zdnBaHHCya1wH1yMAsI+3CCmj9zlQzlhsS9Bdwcj2W3c5eU5FvH2hsNQy4O+O1NnM6o/pDaQ==
   dependencies:
     fontfaceobserver "^2.1.0"
 
@@ -4886,10 +4886,10 @@ expo-modules-autolinking@1.11.2:
     require-from-string "^2.0.2"
     resolve-from "^5.0.0"
 
-expo-modules-core@1.12.23:
-  version "1.12.23"
-  resolved "https://registry.yarnpkg.com/expo-modules-core/-/expo-modules-core-1.12.23.tgz#ea1c0c876aa52db2cb9d25cb59404c334f92446f"
-  integrity sha512-NYp/rWhKW6zlqNdC8/r+FckzlAGWX0IJEjOxwYHuYeRUn/vnKksb43G4E3jcaQEZgmWlKxK4LpxL3gr7m0RJFA==
+expo-modules-core@1.12.24:
+  version "1.12.24"
+  resolved "https://registry.yarnpkg.com/expo-modules-core/-/expo-modules-core-1.12.24.tgz#8c35a16ed6ecb8997f6bd527fc95a8c22f343602"
+  integrity sha512-3geIe2ecizlp7l26iY8Nmc59z2d1RUC5nQZtI9iJoi5uHEUV/zut8e4zRLFVnZb8KOcMcEDsrvaBL5DPnqdfpg==
   dependencies:
     invariant "^2.2.4"
 
@@ -4901,10 +4901,10 @@ expo-navigation-bar@~3.0.7:
     "@react-native/normalize-colors" "0.74.85"
     debug "^4.3.2"
 
-expo@^51.0.31:
-  version "51.0.31"
-  resolved "https://registry.yarnpkg.com/expo/-/expo-51.0.31.tgz#edd623e718705d88681406e72869076dfeb485ff"
-  integrity sha512-YiUNcxzSkQ0jlKW+e8F81KnZfAhCugEZI9VYmuIsFONHivtiYIADHdcFvUWnexUEdgPQDkgWw85XBnIbzIZ39Q==
+expo@^51.0.32:
+  version "51.0.32"
+  resolved "https://registry.yarnpkg.com/expo/-/expo-51.0.32.tgz#2e6068f33cb6a361a3aa35e03bf6d5ce21a4ee2d"
+  integrity sha512-6GEhYvHRnyS/6BytQagGkClsaqbuwAtlN3A6oDfnNMRKLmz6NE/r+Rjg9zbQgUO6zigqb60Yj5lAX32DmixRDw==
   dependencies:
     "@babel/runtime" "^7.20.0"
     "@expo/cli" "0.18.29"
@@ -4915,10 +4915,10 @@ expo@^51.0.31:
     babel-preset-expo "~11.0.14"
     expo-asset "~10.0.10"
     expo-file-system "~17.0.1"
-    expo-font "~12.0.9"
+    expo-font "~12.0.10"
     expo-keep-awake "~13.0.2"
     expo-modules-autolinking "1.11.2"
-    expo-modules-core "1.12.23"
+    expo-modules-core "1.12.24"
     fbemitter "^3.0.0"
     whatwg-url-without-unicode "8.0.0-3"
 
diff --git a/examples/react-native-video-plugin-sample/ios/VideoPluginSample.swift b/examples/react-native-video-plugin-sample/ios/VideoPluginSample.swift
index 87ade70d2a..082f307e69 100644
--- a/examples/react-native-video-plugin-sample/ios/VideoPluginSample.swift
+++ b/examples/react-native-video-plugin-sample/ios/VideoPluginSample.swift
@@ -48,7 +48,7 @@ class VideoPluginSample: NSObject, RNVPlugin {
      * custom functions to be able to track AVPlayer state change
      */
     func handlePlaybackRateChange(player: AVPlayer, change: NSKeyValueObservedChange<Float>) {
-        NSLog("plugin: handlePlaybackRateChange \(change.oldValue)")
+        NSLog("plugin: handlePlaybackRateChange \(String(describing: change.oldValue))")
     }
 
     func handlePlayerItemStatusChange(playerItem: AVPlayerItem, change _: NSKeyValueObservedChange<AVPlayerItem.Status>) {
@@ -56,7 +56,7 @@ class VideoPluginSample: NSObject, RNVPlugin {
     }
 
     func handleCurrentItemChange(player: AVPlayer, change: NSKeyValueObservedChange<AVPlayerItem?>) {
-        NSLog("plugin: handleCurrentItemChange \(player.currentItem)")
+        NSLog("plugin: handleCurrentItemChange \(String(describing: player.currentItem))")
         guard let playerItem = player.currentItem else {
             _playerItemStatusObserver?.invalidate()
             return
diff --git a/ios/Video/DataStructures/DRMParams.swift b/ios/Video/DataStructures/DRMParams.swift
index ce91d4dc34..bf8a4d2a49 100644
--- a/ios/Video/DataStructures/DRMParams.swift
+++ b/ios/Video/DataStructures/DRMParams.swift
@@ -5,6 +5,7 @@ struct DRMParams {
     let contentId: String?
     let certificateUrl: String?
     let base64Certificate: Bool?
+    let localSourceEncryptionKeyScheme: String?
 
     let json: NSDictionary?
 
@@ -17,6 +18,7 @@ struct DRMParams {
             self.certificateUrl = nil
             self.base64Certificate = nil
             self.headers = nil
+            self.localSourceEncryptionKeyScheme = nil
             return
         }
         self.json = json
@@ -36,5 +38,6 @@ struct DRMParams {
         } else {
             self.headers = nil
         }
+        localSourceEncryptionKeyScheme = json["localSourceEncryptionKeyScheme"] as? String
     }
 }
diff --git a/ios/Video/DataStructures/SelectedTrackCriteria.swift b/ios/Video/DataStructures/SelectedTrackCriteria.swift
index b4217817af..2c0ddef7ab 100644
--- a/ios/Video/DataStructures/SelectedTrackCriteria.swift
+++ b/ios/Video/DataStructures/SelectedTrackCriteria.swift
@@ -15,4 +15,8 @@ struct SelectedTrackCriteria {
         self.type = json["type"] as? String ?? ""
         self.value = json["value"] as? String
     }
+
+    static func none() -> SelectedTrackCriteria {
+        return SelectedTrackCriteria(["type": "none", "value": ""])
+    }
 }
diff --git a/ios/Video/DataStructures/VideoSource.swift b/ios/Video/DataStructures/VideoSource.swift
index b23d8ede49..45e5b2d300 100644
--- a/ios/Video/DataStructures/VideoSource.swift
+++ b/ios/Video/DataStructures/VideoSource.swift
@@ -10,7 +10,8 @@ struct VideoSource {
     let cropEnd: Int64?
     let customMetadata: CustomMetadata?
     /* DRM */
-    let drm: DRMParams?
+    let drm: DRMParams
+    var textTracks: [TextTrack] = []
 
     let json: NSDictionary?
 
@@ -27,7 +28,7 @@ struct VideoSource {
             self.cropStart = nil
             self.cropEnd = nil
             self.customMetadata = nil
-            self.drm = nil
+            self.drm = DRMParams(nil)
             return
         }
         self.json = json
@@ -52,5 +53,8 @@ struct VideoSource {
         self.cropEnd = (json["cropEnd"] as? Float64).flatMap { Int64(round($0)) }
         self.customMetadata = CustomMetadata(json["metadata"] as? NSDictionary)
         self.drm = DRMParams(json["drm"] as? NSDictionary)
+        self.textTracks = (json["textTracks"] as? NSArray)?.map { trackDict in
+            return TextTrack(trackDict as? NSDictionary)
+        } ?? []
     }
 }
diff --git a/ios/Video/Features/DRMManager+AVContentKeySessionDelegate.swift b/ios/Video/Features/DRMManager+AVContentKeySessionDelegate.swift
new file mode 100644
index 0000000000..f8d31fd017
--- /dev/null
+++ b/ios/Video/Features/DRMManager+AVContentKeySessionDelegate.swift
@@ -0,0 +1,41 @@
+//
+//  DRMManager+AVContentKeySessionDelegate.swift
+//  react-native-video
+//
+//  Created by Krzysztof Moch on 14/08/2024.
+//
+
+import AVFoundation
+
+extension DRMManager: AVContentKeySessionDelegate {
+    func contentKeySession(_: AVContentKeySession, didProvide keyRequest: AVContentKeyRequest) {
+        handleContentKeyRequest(keyRequest: keyRequest)
+    }
+
+    func contentKeySession(_: AVContentKeySession, didProvideRenewingContentKeyRequest keyRequest: AVContentKeyRequest) {
+        handleContentKeyRequest(keyRequest: keyRequest)
+    }
+
+    func contentKeySession(_: AVContentKeySession, shouldRetry _: AVContentKeyRequest, reason retryReason: AVContentKeyRequest.RetryReason) -> Bool {
+        let retryReasons: [AVContentKeyRequest.RetryReason] = [
+            .timedOut,
+            .receivedResponseWithExpiredLease,
+            .receivedObsoleteContentKey,
+        ]
+        return retryReasons.contains(retryReason)
+    }
+
+    func contentKeySession(_: AVContentKeySession, didProvide keyRequest: AVPersistableContentKeyRequest) {
+        Task {
+            do {
+                try await handlePersistableKeyRequest(keyRequest: keyRequest)
+            } catch {
+                handleError(error, for: keyRequest)
+            }
+        }
+    }
+
+    func contentKeySession(_: AVContentKeySession, contentKeyRequest _: AVContentKeyRequest, didFailWithError error: Error) {
+        DebugLog(String(describing: error))
+    }
+}
diff --git a/ios/Video/Features/DRMManager+OnGetLicense.swift b/ios/Video/Features/DRMManager+OnGetLicense.swift
new file mode 100644
index 0000000000..90b1c38cb1
--- /dev/null
+++ b/ios/Video/Features/DRMManager+OnGetLicense.swift
@@ -0,0 +1,68 @@
+//
+//  DRMManager+OnGetLicense.swift
+//  react-native-video
+//
+//  Created by Krzysztof Moch on 14/08/2024.
+//
+
+import AVFoundation
+
+extension DRMManager {
+    func requestLicenseFromJS(spcData: Data, assetId: String, keyRequest: AVContentKeyRequest) async throws {
+        guard let onGetLicense else {
+            throw RCTVideoError.noDataFromLicenseRequest
+        }
+
+        guard let licenseServerUrl = drmParams?.licenseServer, !licenseServerUrl.isEmpty else {
+            throw RCTVideoError.noLicenseServerURL
+        }
+
+        guard let loadedLicenseUrl = keyRequest.identifier as? String else {
+            throw RCTVideoError.invalidContentId
+        }
+
+        pendingLicenses[loadedLicenseUrl] = keyRequest
+
+        DispatchQueue.main.async { [weak self] in
+            onGetLicense([
+                "licenseUrl": licenseServerUrl,
+                "loadedLicenseUrl": loadedLicenseUrl,
+                "contentId": assetId,
+                "spcBase64": spcData.base64EncodedString(),
+                "target": self?.reactTag as Any,
+            ])
+        }
+    }
+
+    func setJSLicenseResult(license: String, licenseUrl: String) {
+        guard let keyContentRequest = pendingLicenses[licenseUrl] else {
+            setJSLicenseError(error: "Loading request for licenseUrl \(licenseUrl) not found", licenseUrl: licenseUrl)
+            return
+        }
+
+        guard let responseData = Data(base64Encoded: license) else {
+            setJSLicenseError(error: "Invalid license data", licenseUrl: licenseUrl)
+            return
+        }
+
+        do {
+            try finishProcessingContentKeyRequest(keyRequest: keyContentRequest, license: responseData)
+            pendingLicenses.removeValue(forKey: licenseUrl)
+        } catch {
+            handleError(error, for: keyContentRequest)
+        }
+    }
+
+    func setJSLicenseError(error: String, licenseUrl: String) {
+        let rctError = RCTVideoError.fromJSPart(error)
+
+        DispatchQueue.main.async { [weak self] in
+            self?.onVideoError?([
+                "error": RCTVideoErrorHandler.createError(from: rctError),
+                "target": self?.reactTag as Any,
+            ])
+        }
+
+        pendingLicenses.removeValue(forKey: licenseUrl)
+    }
+}
diff --git a/ios/Video/Features/DRMManager+Persitable.swift b/ios/Video/Features/DRMManager+Persitable.swift
new file mode 100644
index 0000000000..022743d8a1
--- /dev/null
+++ b/ios/Video/Features/DRMManager+Persitable.swift
@@ -0,0 +1,34 @@
+//
+//  DRMManager+Persitable.swift
+//  react-native-video
+//
+//  Created by Krzysztof Moch on 19/08/2024.
+//
+
+import AVFoundation
+
+extension DRMManager {
+    func handlePersistableKeyRequest(keyRequest: AVPersistableContentKeyRequest) async throws {
+        if let localSourceEncryptionKeyScheme = drmParams?.localSourceEncryptionKeyScheme {
+            try handleEmbeddedKey(keyRequest: keyRequest, scheme: localSourceEncryptionKeyScheme)
+        } else {
+            // Offline DRM is not supported yet - if you need it please check out the following issue:
+            // https://github.com/TheWidlarzGroup/react-native-video/issues/3539
+            throw RCTVideoError.offlineDRMNotSupported
+        }
+    }
+
+    private func handleEmbeddedKey(keyRequest: AVPersistableContentKeyRequest, scheme: String) throws {
+        guard let uri = keyRequest.identifier as? String,
+              let url = URL(string: uri) else {
+            throw RCTVideoError.invalidContentId
+        }
+
+        guard let persistentKeyData = RCTVideoUtils.extractDataFromCustomSchemeUrl(from: url, scheme: scheme) else {
+            throw RCTVideoError.embeddedKeyExtractionFailed
+        }
+
+        let persistentKey = try keyRequest.persistableContentKey(fromKeyVendorResponse: persistentKeyData)
+        try finishProcessingContentKeyRequest(keyRequest: keyRequest, license: persistentKey)
+    }
+}
diff --git a/ios/Video/Features/DRMManager.swift b/ios/Video/Features/DRMManager.swift
new file mode 100644
index 0000000000..d62df8b364
--- /dev/null
+++ b/ios/Video/Features/DRMManager.swift
@@ -0,0 +1,213 @@
+//
+//  DRMManager.swift
+//  react-native-video
+//
+//  Created by Krzysztof Moch on 13/08/2024.
+//
+
+import AVFoundation
+
+class DRMManager: NSObject {
+    static let queue = DispatchQueue(label: "RNVideoContentKeyDelegateQueue")
+    let contentKeySession: AVContentKeySession?
+
+    var drmParams: DRMParams?
+    var reactTag: NSNumber?
+    var onVideoError: RCTDirectEventBlock?
+    var onGetLicense: RCTDirectEventBlock?
+
+    // Licenses handled by onGetLicense (from JS side)
+    var pendingLicenses: [String: AVContentKeyRequest] = [:]
+
+    override init() {
+        #if targetEnvironment(simulator)
+            contentKeySession = nil
+            super.init()
+        #else
+            contentKeySession = AVContentKeySession(keySystem: .fairPlayStreaming)
+            super.init()
+
+            contentKeySession?.setDelegate(self, queue: DRMManager.queue)
+        #endif
+    }
+
+    func createContentKeyRequest(
+        asset: AVContentKeyRecipient,
+        drmParams: DRMParams?,
+        reactTag: NSNumber?,
+        onVideoError: RCTDirectEventBlock?,
+        onGetLicense: RCTDirectEventBlock?
+    ) {
+        self.reactTag = reactTag
+        self.onVideoError = onVideoError
+        self.onGetLicense = onGetLicense
+        self.drmParams = drmParams
+
+        if drmParams?.type != "fairplay" {
+            self.onVideoError?([
+                "error": RCTVideoErrorHandler.createError(from: RCTVideoError.unsupportedDRMType),
+                "target": self.reactTag as Any,
+            ])
+            return
+        }
+
+        #if targetEnvironment(simulator)
+            DebugLog("Simulator is not supported for FairPlay DRM.")
+            self.onVideoError?([
+                "error": RCTVideoErrorHandler.createError(from: RCTVideoError.simulatorDRMNotSupported),
+                "target": self.reactTag as Any,
+            ])
+        #endif
+
+        contentKeySession?.addContentKeyRecipient(asset)
+    }
+
+    // MARK: - Internal
+
+    func handleContentKeyRequest(keyRequest: AVContentKeyRequest) {
+        Task {
+            do {
+                if drmParams?.localSourceEncryptionKeyScheme != nil {
+                    #if os(iOS)
+                        try keyRequest.respondByRequestingPersistableContentKeyRequestAndReturnError()
+                        return
+                    #else
+                        throw RCTVideoError.offlineDRMNotSuported
+                    #endif
+                }
+
+                try await processContentKeyRequest(keyRequest: keyRequest)
+            } catch {
+                handleError(error, for: keyRequest)
+            }
+        }
+    }
+
+    func finishProcessingContentKeyRequest(keyRequest: AVContentKeyRequest, license: Data) throws {
+        let keyResponse = AVContentKeyResponse(fairPlayStreamingKeyResponseData: license)
+        keyRequest.processContentKeyResponse(keyResponse)
+    }
+
+    func handleError(_ error: Error, for keyRequest: AVContentKeyRequest) {
+        let rctError: RCTVideoError
+        if let videoError = error as? RCTVideoError {
+            // handle RCTVideoError errors
+            rctError = videoError
+
+            DispatchQueue.main.async { [weak self] in
+                self?.onVideoError?([
+                    "error": RCTVideoErrorHandler.createError(from: rctError),
+                    "target": self?.reactTag as Any,
+                ])
+            }
+        } else {
+            let err = error as NSError
+
+            // handle Other errors
+            DispatchQueue.main.async { [weak self] in
+                self?.onVideoError?([
+                    "error": [
+                        "code": err.code,
+                        "localizedDescription": err.localizedDescription,
+                        "localizedFailureReason": err.localizedFailureReason ?? "",
+                        "localizedRecoverySuggestion": err.localizedRecoverySuggestion ?? "",
+                        "domain": err.domain,
+                    ],
+                    "target": self?.reactTag as Any,
+                ])
+            }
+        }
+
+        keyRequest.processContentKeyResponseError(error)
+        contentKeySession?.expire()
+    }
+
+    // MARK: - Private
+
+    private func processContentKeyRequest(keyRequest: AVContentKeyRequest) async throws {
+        guard let assetId = getAssetId(keyRequest: keyRequest),
+              let assetIdData = assetId.data(using: .utf8) else {
+            throw RCTVideoError.invalidContentId
+        }
+
+        let appCertificate = try await requestApplicationCertificate()
+        let spcData = try await keyRequest.makeStreamingContentKeyRequestData(forApp: appCertificate, contentIdentifier: assetIdData)
+
+        if onGetLicense != nil {
+            try await requestLicenseFromJS(spcData: spcData, assetId: assetId, keyRequest: keyRequest)
+        } else {
+            let license = try await requestLicense(spcData: spcData)
+            try finishProcessingContentKeyRequest(keyRequest: keyRequest, license: license)
+        }
+    }
+
+    private func requestApplicationCertificate() async throws -> Data {
+        guard let urlString = drmParams?.certificateUrl,
+              let url = URL(string: urlString) else {
+            throw RCTVideoError.noCertificateURL
+        }
+
+        let (data, response) = try await URLSession.shared.data(from: url)
+
+        guard let httpResponse = response as? HTTPURLResponse,
+              httpResponse.statusCode == 200 else {
+            throw RCTVideoError.noCertificateData
+        }
+
+        if drmParams?.base64Certificate == true {
+            guard let certData = Data(base64Encoded: data) else {
+                throw RCTVideoError.noCertificateData
+            }
+            return certData
+        }
+
+        return data
+    }
+
+    private func requestLicense(spcData: Data) async throws -> Data {
+        guard let licenseServerUrlString = drmParams?.licenseServer,
+              let licenseServerUrl = URL(string: licenseServerUrlString) else {
+            throw RCTVideoError.noLicenseServerURL
+        }
+
+        var request = URLRequest(url: licenseServerUrl)
+        request.httpMethod = "POST"
+        request.httpBody = spcData
+
+        if let headers = drmParams?.headers {
+            for (key, value) in headers {
+                if let stringValue = value as? String {
+                    request.setValue(stringValue, forHTTPHeaderField: key)
+                }
+            }
+        }
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw RCTVideoError.licenseRequestFailed(0)
+        }
+
+        guard httpResponse.statusCode == 200 else {
+            throw RCTVideoError.licenseRequestFailed(httpResponse.statusCode)
+        }
+
+        guard !data.isEmpty else {
+            throw RCTVideoError.noDataFromLicenseRequest
+        }
+
+        return data
+    }
+
+    private func getAssetId(keyRequest: AVContentKeyRequest) -> String? {
+        if let assetId = drmParams?.contentId {
+            return assetId
+        }
+
+        if let url = keyRequest.identifier as? String {
+            return url.replacingOccurrences(of: "skd://", with: "")
+        }
+
+        return nil
+    }
+}
diff --git a/ios/Video/Features/RCTPlayerObserver.swift b/ios/Video/Features/RCTPlayerObserver.swift
index 198a51f5c8..6f73cfb913 100644
--- a/ios/Video/Features/RCTPlayerObserver.swift
+++ b/ios/Video/Features/RCTPlayerObserver.swift
@@ -234,10 +234,9 @@ class RCTPlayerObserver: NSObject, AVPlayerItemMetadataOutputPushDelegate, AVPla
 
     /* Cancels the previously registered time observer. */
     func removePlayerTimeObserver() {
-        if _timeObserver != nil {
-            player?.removeTimeObserver(_timeObserver)
-            _timeObserver = nil
-        }
+        guard let timeObserver = _timeObserver else { return }
+        player?.removeTimeObserver(timeObserver)
+        _timeObserver = nil
     }
 
     func addTimeObserverIfNotSet() {
diff --git a/ios/Video/Features/RCTResourceLoaderDelegate.swift b/ios/Video/Features/RCTResourceLoaderDelegate.swift
deleted file mode 100644
index 3f3eab27dd..0000000000
--- a/ios/Video/Features/RCTResourceLoaderDelegate.swift
+++ /dev/null
@@ -1,186 +0,0 @@
-import AVFoundation
-
-class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSessionDelegate {
-    private var _loadingRequests: [String: AVAssetResourceLoadingRequest?] = [:]
-    private var _requestingCertificate = false
-    private var _requestingCertificateErrored = false
-    private var _drm: DRMParams?
-    private var _localSourceEncryptionKeyScheme: String?
-    private var _reactTag: NSNumber?
-    private var _onVideoError: RCTDirectEventBlock?
-    private var _onGetLicense: RCTDirectEventBlock?
-
-    init(
-        asset: AVURLAsset,
-        drm: DRMParams?,
-        localSourceEncryptionKeyScheme: String?,
-        onVideoError: RCTDirectEventBlock?,
-        onGetLicense: RCTDirectEventBlock?,
-        reactTag: NSNumber
-    ) {
-        super.init()
-        let queue = DispatchQueue(label: "assetQueue")
-        asset.resourceLoader.setDelegate(self, queue: queue)
-        _reactTag = reactTag
-        _onVideoError = onVideoError
-        _onGetLicense = onGetLicense
-        _drm = drm
-        _localSourceEncryptionKeyScheme = localSourceEncryptionKeyScheme
-    }
-
-    deinit {
-        for request in _loadingRequests.values {
-            request?.finishLoading()
-        }
-    }
-
-    func resourceLoader(_: AVAssetResourceLoader, shouldWaitForRenewalOfRequestedResource renewalRequest: AVAssetResourceRenewalRequest) -> Bool {
-        return loadingRequestHandling(renewalRequest)
-    }
-
-    func resourceLoader(_: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
-        return loadingRequestHandling(loadingRequest)
-    }
-
-    func resourceLoader(_: AVAssetResourceLoader, didCancel _: AVAssetResourceLoadingRequest) {
-        RCTLog("didCancelLoadingRequest")
-    }
-
-    func setLicenseResult(_ license: String!, _ licenseUrl: String!) {
-        // Check if the loading request exists in _loadingRequests based on licenseUrl
-        guard let loadingRequest = _loadingRequests[licenseUrl] else {
-            setLicenseResultError("Loading request for licenseUrl \(licenseUrl) not found", licenseUrl)
-            return
-        }
-
-        // Check if the license data is valid
-        guard let respondData = RCTVideoUtils.base64DataFromBase64String(base64String: license) else {
-            setLicenseResultError("No data from JS license response", licenseUrl)
-            return
-        }
-
-        let dataRequest: AVAssetResourceLoadingDataRequest! = loadingRequest?.dataRequest
-        dataRequest.respond(with: respondData)
-        loadingRequest!.finishLoading()
-        _loadingRequests.removeValue(forKey: licenseUrl)
-    }
-
-    func setLicenseResultError(_ error: String!, _ licenseUrl: String!) {
-        // Check if the loading request exists in _loadingRequests based on licenseUrl
-        guard let loadingRequest = _loadingRequests[licenseUrl] else {
-            print("Loading request for licenseUrl \(licenseUrl) not found. Error: \(error)")
-            return
-        }
-
-        self.finishLoadingWithError(error: RCTVideoErrorHandler.fromJSPart(error), licenseUrl: licenseUrl)
-    }
-
-    func finishLoadingWithError(error: Error!, licenseUrl: String!) -> Bool {
-        // Check if the loading request exists in _loadingRequests based on licenseUrl
-        guard let loadingRequest = _loadingRequests[licenseUrl], let error = error as NSError? else {
-            // Handle the case where the loading request is not found or error is nil
-            return false
-        }
-
-        loadingRequest!.finishLoading(with: error)
-        _loadingRequests.removeValue(forKey: licenseUrl)
-        _onVideoError?([
-            "error": [
-                "code": NSNumber(value: error.code),
-                "localizedDescription": error.localizedDescription ?? "",
-                "localizedFailureReason": error.localizedFailureReason ?? "",
-                "localizedRecoverySuggestion": error.localizedRecoverySuggestion ?? "",
-                "domain": error.domain,
-            ],
-            "target": _reactTag,
-        ])
-
-        return false
-    }
-
-    func loadingRequestHandling(_ loadingRequest: AVAssetResourceLoadingRequest!) -> Bool {
-        if handleEmbeddedKey(loadingRequest) {
-            return true
-        }
-
-        if _drm != nil {
-            return handleDrm(loadingRequest)
-        }
-
-        return false
-    }
-
-    func handleEmbeddedKey(_ loadingRequest: AVAssetResourceLoadingRequest!) -> Bool {
-        guard let url = loadingRequest.request.url,
-              let _localSourceEncryptionKeyScheme,
-              let persistentKeyData = RCTVideoUtils.extractDataFromCustomSchemeUrl(from: url, scheme: _localSourceEncryptionKeyScheme)
-        else {
-            return false
-        }
-
-        loadingRequest.contentInformationRequest?.contentType = AVStreamingKeyDeliveryPersistentContentKeyType
-        loadingRequest.contentInformationRequest?.isByteRangeAccessSupported = true
-        loadingRequest.contentInformationRequest?.contentLength = Int64(persistentKeyData.count)
-        loadingRequest.dataRequest?.respond(with: persistentKeyData)
-        loadingRequest.finishLoading()
-
-        return true
-    }
-
-    func handleDrm(_ loadingRequest: AVAssetResourceLoadingRequest!) -> Bool {
-        if _requestingCertificate {
-            return true
-        } else if _requestingCertificateErrored {
-            return false
-        }
-
-        let requestKey: String = loadingRequest.request.url?.absoluteString ?? ""
-
-        _loadingRequests[requestKey] = loadingRequest
-
-        guard let _drm, let drmType = _drm.type, drmType == "fairplay" else {
-            return finishLoadingWithError(error: RCTVideoErrorHandler.noDRMData, licenseUrl: requestKey)
-        }
-
-        Task {
-            do {
-                if _onGetLicense != nil {
-                    let contentId = _drm.contentId ?? loadingRequest.request.url?.host
-                    let spcData = try await RCTVideoDRM.handleWithOnGetLicense(
-                        loadingRequest: loadingRequest,
-                        contentId: contentId,
-                        certificateUrl: _drm.certificateUrl,
-                        base64Certificate: _drm.base64Certificate
-                    )
-
-                    self._requestingCertificate = true
-                    self._onGetLicense?(["licenseUrl": self._drm?.licenseServer ?? "",
-                                         "loadedLicenseUrl": loadingRequest.request.url?.absoluteString ?? "",
-                                         "contentId": contentId ?? "",
-                                         "spcBase64": spcData.base64EncodedString(options: []),
-                                         "target": self._reactTag])
-                } else {
-                    let data = try await RCTVideoDRM.handleInternalGetLicense(
-                        loadingRequest: loadingRequest,
-                        contentId: _drm.contentId,
-                        licenseServer: _drm.licenseServer,
-                        certificateUrl: _drm.certificateUrl,
-                        base64Certificate: _drm.base64Certificate,
-                        headers: _drm.headers
-                    )
-
-                    guard let dataRequest = loadingRequest.dataRequest else {
-                        throw RCTVideoErrorHandler.noCertificateData
-                    }
-                    dataRequest.respond(with: data)
-                    loadingRequest.finishLoading()
-                }
-            } catch {
-                self.finishLoadingWithError(error: error, licenseUrl: requestKey)
-                self._requestingCertificateErrored = true
-            }
-        }
-
-        return true
-    }
-}
diff --git a/ios/Video/Features/RCTVideoDRM.swift b/ios/Video/Features/RCTVideoDRM.swift
deleted file mode 100644
index bc73d48df3..0000000000
--- a/ios/Video/Features/RCTVideoDRM.swift
+++ /dev/null
@@ -1,161 +0,0 @@
-import AVFoundation
-
-enum RCTVideoDRM {
-    static func fetchLicense(
-        licenseServer: String,
-        spcData: Data?,
-        contentId: String,
-        headers: [String: Any]?
-    ) async throws -> Data {
-        let request = createLicenseRequest(licenseServer: licenseServer, spcData: spcData, contentId: contentId, headers: headers)
-
-        let (data, response) = try await URLSession.shared.data(from: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw RCTVideoErrorHandler.noDataFromLicenseRequest
-        }
-
-        if httpResponse.statusCode != 200 {
-            print("Error getting license from \(licenseServer), HTTP status code \(httpResponse.statusCode)")
-            throw RCTVideoErrorHandler.licenseRequestNotOk(httpResponse.statusCode)
-        }
-
-        guard let decodedData = Data(base64Encoded: data, options: []) else {
-            throw RCTVideoErrorHandler.noDataFromLicenseRequest
-        }
-
-        return decodedData
-    }
-
-    static func createLicenseRequest(
-        licenseServer: String,
-        spcData: Data?,
-        contentId: String,
-        headers: [String: Any]?
-    ) -> URLRequest {
-        var request = URLRequest(url: URL(string: licenseServer)!)
-        request.httpMethod = "POST"
-
-        if let headers {
-            for item in headers {
-                guard let key = item.key as? String, let value = item.value as? String else {
-                    continue
-                }
-                request.setValue(value, forHTTPHeaderField: key)
-            }
-        }
-
-        let spcEncoded = spcData?.base64EncodedString(options: [])
-        let spcUrlEncoded = CFURLCreateStringByAddingPercentEscapes(
-            kCFAllocatorDefault,
-            spcEncoded as? CFString? as! CFString,
-            nil,
-            "?=&+" as CFString,
-            CFStringBuiltInEncodings.UTF8.rawValue
-        ) as? String
-        let post = String(format: "spc=%@&%@", spcUrlEncoded as! CVarArg, contentId)
-        let postData = post.data(using: String.Encoding.utf8, allowLossyConversion: true)
-        request.httpBody = postData
-
-        return request
-    }
-
-    static func fetchSpcData(
-        loadingRequest: AVAssetResourceLoadingRequest,
-        certificateData: Data,
-        contentIdData: Data
-    ) throws -> Data {
-        #if os(visionOS)
-            // TODO: DRM is not supported yet on visionOS. See #3467
-            throw NSError(domain: "DRM is not supported yet on visionOS", code: 0, userInfo: nil)
-        #else
-            guard let spcData = try? loadingRequest.streamingContentKeyRequestData(
-                forApp: certificateData,
-                contentIdentifier: contentIdData as Data,
-                options: nil
-            ) else {
-                throw RCTVideoErrorHandler.noSPC
-            }
-
-            return spcData
-        #endif
-    }
-
-    static func createCertificateData(certificateStringUrl: String?, base64Certificate: Bool?) throws -> Data {
-        guard let certificateStringUrl,
-              let certificateURL = URL(string: certificateStringUrl.addingPercentEncoding(withAllowedCharacters: .urlFragmentAllowed) ?? "") else {
-            throw RCTVideoErrorHandler.noCertificateURL
-        }
-
-        var certificateData: Data?
-        do {
-            certificateData = try Data(contentsOf: certificateURL)
-            if base64Certificate != nil {
-                certificateData = Data(base64Encoded: certificateData! as Data, options: .ignoreUnknownCharacters)
-            }
-        } catch {}
-
-        guard let certificateData else {
-            throw RCTVideoErrorHandler.noCertificateData
-        }
-
-        return certificateData
-    }
-
-    static func handleWithOnGetLicense(loadingRequest: AVAssetResourceLoadingRequest, contentId: String?, certificateUrl: String?,
-                                       base64Certificate: Bool?) throws -> Data {
-        let contentIdData = contentId?.data(using: .utf8)
-
-        let certificateData = try? RCTVideoDRM.createCertificateData(certificateStringUrl: certificateUrl, base64Certificate: base64Certificate)
-
-        guard let contentIdData else {
-            throw RCTVideoError.invalidContentId as! Error
-        }
-
-        guard let certificateData else {
-            throw RCTVideoError.noCertificateData as! Error
-        }
-
-        return try RCTVideoDRM.fetchSpcData(
-            loadingRequest: loadingRequest,
-            certificateData: certificateData,
-            contentIdData: contentIdData
-        )
-    }
-
-    static func handleInternalGetLicense(
-        loadingRequest: AVAssetResourceLoadingRequest,
-        contentId: String?,
-        licenseServer: String?,
-        certificateUrl: String?,
-        base64Certificate: Bool?,
-        headers: [String: Any]?
-    ) async throws -> Data {
-        let url = loadingRequest.request.url
-
-        let parsedContentId = contentId != nil && !contentId!.isEmpty ? contentId : nil
-
-        guard let contentId = parsedContentId ?? url?.absoluteString.replacingOccurrences(of: "skd://", with: "") else {
-            throw RCTVideoError.invalidContentId as! Error
-        }
-
-        let contentIdData = NSData(bytes: contentId.cString(using: String.Encoding.utf8), length: contentId.lengthOfBytes(using: String.Encoding.utf8)) as Data
-        let certificateData = try RCTVideoDRM.createCertificateData(certificateStringUrl: certificateUrl, base64Certificate: base64Certificate)
-        let spcData = try RCTVideoDRM.fetchSpcData(
-            loadingRequest: loadingRequest,
-            certificateData: certificateData,
-            contentIdData: contentIdData
-        )
-
-        guard let licenseServer else {
-            throw RCTVideoError.noLicenseServerURL as! Error
-        }
-
-        return try await RCTVideoDRM.fetchLicense(
-            licenseServer: licenseServer,
-            spcData: spcData,
-            contentId: contentId,
-            headers: headers
-        )
-    }
-}
diff --git a/ios/Video/Features/RCTVideoErrorHandling.swift b/ios/Video/Features/RCTVideoErrorHandling.swift
index 7dc687839e..b06031cfee 100644
--- a/ios/Video/Features/RCTVideoErrorHandling.swift
+++ b/ios/Video/Features/RCTVideoErrorHandling.swift
@@ -1,114 +1,188 @@
+import Foundation
+
 // MARK: - RCTVideoError
 
-enum RCTVideoError: Int {
-    case fromJSPart
+enum RCTVideoError: Error, Hashable {
+    case fromJSPart(String)
     case noLicenseServerURL
-    case licenseRequestNotOk
+    case licenseRequestFailed(Int)
     case noDataFromLicenseRequest
     case noSPC
-    case noDataRequest
     case noCertificateData
     case noCertificateURL
-    case noFairplayDRM
     case noDRMData
     case invalidContentId
-}
-
-// MARK: - RCTVideoErrorHandler
-
-enum RCTVideoErrorHandler {
-    static let noDRMData = NSError(
-        domain: "RCTVideo",
-        code: RCTVideoError.noDRMData.rawValue,
-        userInfo: [
-            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
-            NSLocalizedFailureReasonErrorKey: "No drm object found.",
-            NSLocalizedRecoverySuggestionErrorKey: "Have you specified the 'drm' prop?",
-        ]
-    )
-
-    static let noCertificateURL = NSError(
-        domain: "RCTVideo",
-        code: RCTVideoError.noCertificateURL.rawValue,
-        userInfo: [
-            NSLocalizedDescriptionKey: "Error obtaining DRM License.",
-            NSLocalizedFailureReasonErrorKey: "No certificate URL has been found.",
-            NSLocalizedRecoverySuggestionErrorKey: "Did you specified the prop certificateUrl?",
-        ]
-    )
-
-    static let noCertificateData = NSError(
-        domain: "RCTVideo",
-        code: RCTVideoError.noCertificateData.rawValue,
-        userInfo: [
-            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
-            NSLocalizedFailureReasonErrorKey: "No certificate data obtained from the specificied url.",
-            NSLocalizedRecoverySuggestionErrorKey: "Have you specified a valid 'certificateUrl'?",
-        ]
-    )
+    case invalidAppCert
+    case keyRequestCreationFailed
+    case persistableKeyRequestFailed
+    case embeddedKeyExtractionFailed
+    case offlineDRMNotSupported
+    case unsupportedDRMType
+    case simulatorDRMNotSupported
 
-    static let noSPC = NSError(
-        domain: "RCTVideo",
-        code: RCTVideoError.noSPC.rawValue,
-        userInfo: [
-            NSLocalizedDescriptionKey: "Error obtaining license.",
-            NSLocalizedFailureReasonErrorKey: "No spc received.",
-            NSLocalizedRecoverySuggestionErrorKey: "Check your DRM config.",
-        ]
-    )
+    var errorCode: Int {
+        switch self {
+        case .fromJSPart:
+            return 1000
+        case .noLicenseServerURL:
+            return 1001
+        case .licenseRequestFailed:
+            return 1002
+        case .noDataFromLicenseRequest:
+            return 1003
+        case .noSPC:
+            return 1004
+        case .noCertificateData:
+            return 1005
+        case .noCertificateURL:
+            return 1006
+        case .noDRMData:
+            return 1007
+        case .invalidContentId:
+            return 1008
+        case .invalidAppCert:
+            return 1009
+        case .keyRequestCreationFailed:
+            return 1010
+        case .persistableKeyRequestFailed:
+            return 1011
+        case .embeddedKeyExtractionFailed:
+            return 1012
+        case .offlineDRMNotSupported:
+            return 1013
+        case .unsupportedDRMType:
+            return 1014
+        case .simulatorDRMNotSupported:
+            return 1015
+        }
+    }
+}
 
-    static let noLicenseServerURL = NSError(
-        domain: "RCTVideo",
-        code: RCTVideoError.noLicenseServerURL.rawValue,
-        userInfo: [
-            NSLocalizedDescriptionKey: "Error obtaining DRM License.",
-            NSLocalizedFailureReasonErrorKey: "No license server URL has been found.",
-            NSLocalizedRecoverySuggestionErrorKey: "Did you specified the prop licenseServer?",
-        ]
-    )
+// MARK: LocalizedError
 
-    static let noDataFromLicenseRequest = NSError(
-        domain: "RCTVideo",
-        code: RCTVideoError.noDataFromLicenseRequest.rawValue,
-        userInfo: [
-            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
-            NSLocalizedFailureReasonErrorKey: "No data received from the license server.",
-            NSLocalizedRecoverySuggestionErrorKey: "Is the licenseServer ok?",
-        ]
-    )
+extension RCTVideoError: LocalizedError {
+    var errorDescription: String? {
+        switch self {
+        case let .fromJSPart(error):
+            return NSLocalizedString("Error from JavaScript: \(error)", comment: "")
+        case .noLicenseServerURL:
+            return NSLocalizedString("No license server URL provided", comment: "")
+        case let .licenseRequestFailed(statusCode):
+            return NSLocalizedString("License request failed with status code: \(statusCode)", comment: "")
+        case .noDataFromLicenseRequest:
+            return NSLocalizedString("No data received from license server", comment: "")
+        case .noSPC:
+            return NSLocalizedString("Failed to create Server Playback Context (SPC)", comment: "")
+        case .noCertificateData:
+            return NSLocalizedString("No certificate data obtained", comment: "")
+        case .noCertificateURL:
+            return NSLocalizedString("No certificate URL provided", comment: "")
+        case .noDRMData:
+            return NSLocalizedString("No DRM data available", comment: "")
+        case .invalidContentId:
+            return NSLocalizedString("Invalid content ID", comment: "")
+        case .invalidAppCert:
+            return NSLocalizedString("Invalid application certificate", comment: "")
+        case .keyRequestCreationFailed:
+            return NSLocalizedString("Failed to create content key request", comment: "")
+        case .persistableKeyRequestFailed:
+            return NSLocalizedString("Failed to create persistable content key request", comment: "")
+        case .embeddedKeyExtractionFailed:
+            return NSLocalizedString("Failed to extract embedded key", comment: "")
+        case .offlineDRMNotSupported:
+            return NSLocalizedString("Offline DRM is not supported, see https://github.com/TheWidlarzGroup/react-native-video/issues/3539", comment: "")
+        case .unsupportedDRMType:
+            return NSLocalizedString("Unsupported DRM type", comment: "")
+        case .simulatorDRMNotSupported:
+            return NSLocalizedString("DRM on simulators is not supported", comment: "")
+        }
+    }
 
-    static func licenseRequestNotOk(_ statusCode: Int) -> NSError {
-        return NSError(
-            domain: "RCTVideo",
-            code: RCTVideoError.licenseRequestNotOk.rawValue,
-            userInfo: [
-                NSLocalizedDescriptionKey: "Error obtaining license.",
-                NSLocalizedFailureReasonErrorKey: String(
-                    format: "License server responded with status code %li",
-                    statusCode
-                ),
-                NSLocalizedRecoverySuggestionErrorKey: "Did you send the correct data to the license Server? Is the server ok?",
-            ]
-        )
+    var failureReason: String? {
+        switch self {
+        case .fromJSPart:
+            return NSLocalizedString("An error occurred in the JavaScript part of the application.", comment: "")
+        case .noLicenseServerURL:
+            return NSLocalizedString("The license server URL is missing in the DRM configuration.", comment: "")
+        case .licenseRequestFailed:
+            return NSLocalizedString("The license server responded with an error status code.", comment: "")
+        case .noDataFromLicenseRequest:
+            return NSLocalizedString("The license server did not return any data.", comment: "")
+        case .noSPC:
+            return NSLocalizedString("Failed to generate the Server Playback Context (SPC) for the content.", comment: "")
+        case .noCertificateData:
+            return NSLocalizedString("Unable to retrieve certificate data from the specified URL.", comment: "")
+        case .noCertificateURL:
+            return NSLocalizedString("The certificate URL is missing in the DRM configuration.", comment: "")
+        case .noDRMData:
+            return NSLocalizedString("The required DRM data is not available or is invalid.", comment: "")
+        case .invalidContentId:
+            return NSLocalizedString("The content ID provided is not valid or recognized.", comment: "")
+        case .invalidAppCert:
+            return NSLocalizedString("The application certificate is invalid or not recognized.", comment: "")
+        case .keyRequestCreationFailed:
+            return NSLocalizedString("Unable to create a content key request for DRM.", comment: "")
+        case .persistableKeyRequestFailed:
+            return NSLocalizedString("Failed to create a persistable content key request for offline playback.", comment: "")
+        case .embeddedKeyExtractionFailed:
+            return NSLocalizedString("Unable to extract the embedded key from the custom scheme URL.", comment: "")
+        case .offlineDRMNotSupported:
+            return NSLocalizedString("You tried to use Offline DRM but it is not supported yet", comment: "")
+        case .unsupportedDRMType:
+            return NSLocalizedString("You tried to use unsupported DRM type", comment: "")
+        case .simulatorDRMNotSupported:
+            return NSLocalizedString("You tried to DRM on a simulator", comment: "")
+        }
     }
 
-    static func fromJSPart(_ error: String) -> NSError {
-        return NSError(domain: "RCTVideo",
-                       code: RCTVideoError.fromJSPart.rawValue,
-                       userInfo: [
-                           NSLocalizedDescriptionKey: error,
-                           NSLocalizedFailureReasonErrorKey: error,
-                           NSLocalizedRecoverySuggestionErrorKey: error,
-                       ])
+    var recoverySuggestion: String? {
+        switch self {
+        case .fromJSPart:
+            return NSLocalizedString("Check the JavaScript logs for more details and fix any issues in the JS code.", comment: "")
+        case .noLicenseServerURL:
+            return NSLocalizedString("Ensure that you have specified the 'licenseServer' property in the DRM configuration.", comment: "")
+        case .licenseRequestFailed:
+            return NSLocalizedString("Verify that the license server is functioning correctly and that you're sending the correct data.", comment: "")
+        case .noDataFromLicenseRequest:
+            return NSLocalizedString("Check if the license server is operational and responding with the expected data.", comment: "")
+        case .noSPC:
+            return NSLocalizedString("Verify that the content key request is properly configured and that the DRM setup is correct.", comment: "")
+        case .noCertificateData:
+            return NSLocalizedString("Check if the certificate URL is correct and accessible, and that it returns valid certificate data.", comment: "")
+        case .noCertificateURL:
+            return NSLocalizedString("Make sure you have specified the 'certificateUrl' property in the DRM configuration.", comment: "")
+        case .noDRMData:
+            return NSLocalizedString("Ensure that you have provided all necessary DRM-related data in the configuration.", comment: "")
+        case .invalidContentId:
+            return NSLocalizedString("Verify that the content ID is correct and matches the expected format for your DRM system.", comment: "")
+        case .invalidAppCert:
+            return NSLocalizedString("Check if the application certificate is valid and properly formatted for your DRM system.", comment: "")
+        case .keyRequestCreationFailed:
+            return NSLocalizedString("Review your DRM configuration and ensure all required parameters are correctly set.", comment: "")
+        case .persistableKeyRequestFailed:
+            return NSLocalizedString("Verify that offline playback is supported and properly configured for your content.", comment: "")
+        case .embeddedKeyExtractionFailed:
+            return NSLocalizedString("Check if the embedded key is present in the URL and the custom scheme is correctly implemented.", comment: "")
+        case .offlineDRMNotSupported:
+            return NSLocalizedString("Check if localSourceEncryptionKeyScheme is set", comment: "")
+        case .unsupportedDRMType:
+            return NSLocalizedString("Verify that you are using fairplay (on Apple devices)", comment: "")
+        case .simulatorDRMNotSupported:
+            return NSLocalizedString("You need to test DRM content on real device", comment: "")
+        }
     }
+}
+
+// MARK: - RCTVideoErrorHandler
 
-    static let invalidContentId = NSError(
-        domain: "RCTVideo",
-        code: RCTVideoError.invalidContentId.rawValue,
-        userInfo: [
-            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
-            NSLocalizedFailureReasonErrorKey: "No valide content Id received",
-            NSLocalizedRecoverySuggestionErrorKey: "Is the contentId and url ok?",
+enum RCTVideoErrorHandler {
+    static func createError(from error: RCTVideoError) -> [String: Any] {
+        return [
+            "code": error.errorCode,
+            "localizedDescription": error.localizedDescription,
+            "localizedFailureReason": error.failureReason ?? "",
+            "localizedRecoverySuggestion": error.recoverySuggestion ?? "",
+            "domain": "RCTVideo",
         ]
-    )
+    }
 }
diff --git a/ios/Video/Features/RCTVideoSave.swift b/ios/Video/Features/RCTVideoSave.swift
index 76fc2901fa..cdf1fdf9fb 100644
--- a/ios/Video/Features/RCTVideoSave.swift
+++ b/ios/Video/Features/RCTVideoSave.swift
@@ -19,26 +19,32 @@ enum RCTVideoSave {
             reject("ERROR_COULD_NOT_CREATE_EXPORT_SESSION", "Could not create export session", nil)
             return
         }
-        var path: String!
-        path = RCTVideoSave.generatePathInDirectory(
-            directory: URL(fileURLWithPath: RCTVideoSave.cacheDirectoryPath() ?? "").appendingPathComponent("Videos").path,
-            withExtension: ".mp4"
-        )
-        let url: NSURL! = NSURL.fileURL(withPath: path) as NSURL
-        exportSession.outputFileType = AVFileType.mp4
-        exportSession.outputURL = url as URL?
-        exportSession.videoComposition = playerItem?.videoComposition
-        exportSession.shouldOptimizeForNetworkUse = true
-        exportSession.exportAsynchronously(completionHandler: {
-            switch exportSession.status {
-            case .failed:
-                reject("ERROR_COULD_NOT_EXPORT_VIDEO", "Could not export video", exportSession.error)
-            case .cancelled:
-                reject("ERROR_EXPORT_SESSION_CANCELLED", "Export session was cancelled", exportSession.error)
-            default:
-                resolve(["uri": url.absoluteString])
-            }
-        })
+
+        #if !os(visionOS)
+            var path: String!
+            path = RCTVideoSave.generatePathInDirectory(
+                directory: URL(fileURLWithPath: RCTVideoSave.cacheDirectoryPath() ?? "").appendingPathComponent("Videos").path,
+                withExtension: ".mp4"
+            )
+            let url: NSURL! = NSURL.fileURL(withPath: path) as NSURL
+            exportSession.outputFileType = .mp4
+            exportSession.outputFileType = AVFileType.mp4
+            exportSession.outputURL = url as URL?
+            exportSession.videoComposition = playerItem?.videoComposition
+            exportSession.shouldOptimizeForNetworkUse = true
+            exportSession.exportAsynchronously(completionHandler: {
+                switch exportSession.status {
+                case .failed:
+                    reject("ERROR_COULD_NOT_EXPORT_VIDEO", "Could not export video", exportSession.error)
+                case .cancelled:
+                    reject("ERROR_EXPORT_SESSION_CANCELLED", "Export session was cancelled", exportSession.error)
+                default:
+                    resolve(["uri": url.absoluteString])
+                }
+            })
+        #else
+            reject("ERROR_EXPORT_SESSION_CANCELLED", "this function is not supported on visionOS", nil)
+        #endif
     }
 
     static func generatePathInDirectory(directory: String?, withExtension extension: String?) -> String? {
@@ -54,13 +60,11 @@ enum RCTVideoSave {
 
     static func ensureDirExists(withPath path: String?) -> Bool {
         var isDir: ObjCBool = false
-        var error: Error?
         let exists = FileManager.default.fileExists(atPath: path ?? "", isDirectory: &isDir)
         if !(exists && isDir.boolValue) {
             do {
                 try FileManager.default.createDirectory(atPath: path ?? "", withIntermediateDirectories: true, attributes: nil)
-            } catch {}
-            if error != nil {
+            } catch {
                 return false
             }
         }
diff --git a/ios/Video/Features/RCTVideoUtils.swift b/ios/Video/Features/RCTVideoUtils.swift
index 40a011611f..943bbf4fe4 100644
--- a/ios/Video/Features/RCTVideoUtils.swift
+++ b/ios/Video/Features/RCTVideoUtils.swift
@@ -81,22 +81,25 @@ enum RCTVideoUtils {
         return 0
     }
 
-    static func urlFilePath(filepath: NSString!, searchPath: FileManager.SearchPathDirectory) -> NSURL! {
-        if filepath.contains("file://") {
-            return NSURL(string: filepath as String)
+    static func urlFilePath(filepath: NSString?, searchPath: FileManager.SearchPathDirectory) -> NSURL! {
+        guard let _filepath = filepath else { return nil }
+
+        if _filepath.contains("file://") {
+            return NSURL(string: _filepath as String)
         }
 
         // if no file found, check if the file exists in the Document directory
-        let paths: [String]! = NSSearchPathForDirectoriesInDomains(searchPath, .userDomainMask, true)
-        var relativeFilePath: String! = filepath.lastPathComponent
+        let paths: [String] = NSSearchPathForDirectoriesInDomains(searchPath, .userDomainMask, true)
+        var relativeFilePath: String = _filepath.lastPathComponent
         // the file may be multiple levels below the documents directory
-        let directoryString: String! = searchPath == .cachesDirectory ? "Library/Caches/" : "Documents"
-        let fileComponents: [String]! = filepath.components(separatedBy: directoryString)
+        let directoryString: String = searchPath == .cachesDirectory ? "Library/Caches/" : "Documents"
+        let fileComponents: [String] = _filepath.components(separatedBy: directoryString)
         if fileComponents.count > 1 {
             relativeFilePath = fileComponents[1]
         }
 
-        let path: String! = (paths.first! as NSString).appendingPathComponent(relativeFilePath)
+        guard let _pathFirst = paths.first else { return nil }
+        let path: String = (_pathFirst as NSString).appendingPathComponent(relativeFilePath)
         if FileManager.default.fileExists(atPath: path) {
             return NSURL.fileURL(withPath: path) as NSURL
         }
@@ -135,7 +138,7 @@ enum RCTVideoUtils {
             return []
         }
 
-        let audioTracks: NSMutableArray! = NSMutableArray()
+        let audioTracks = NSMutableArray()
 
         let group = await RCTVideoAssetsUtils.getMediaSelectionGroup(asset: asset, for: .audible)
 
@@ -146,7 +149,7 @@ enum RCTVideoUtils {
             if (values?.count ?? 0) > 0, let value = values?[0] {
                 title = value as! String
             }
-            let language: String! = currentOption?.extendedLanguageTag ?? ""
+            let language: String = currentOption?.extendedLanguageTag ?? ""
 
             var roleFlags = [String]()
             if (currentOption?.hasMediaCharacteristic(AVMediaCharacteristic.describesVideoForAccessibility) == true) {
@@ -158,7 +161,7 @@ enum RCTVideoUtils {
             let audioTrack = [
                 "index": NSNumber(value: i),
                 "title": title,
-                "language": language ?? "",
+                "language": language,
                 "selected": currentOption?.displayName == selectedOption?.displayName,
                 "roleFlags": roleFlags,
                 "isSupported": true
@@ -185,7 +188,7 @@ enum RCTVideoUtils {
             if (values?.count ?? 0) > 0, let value = values?[0] {
                 title = value as! String
             }
-            let language: String! = currentOption?.extendedLanguageTag ?? ""
+            let language: String = currentOption?.extendedLanguageTag ?? ""
 
             var roleFlags = [String]()
             if (currentOption?.hasMediaCharacteristic(AVMediaCharacteristic.describesVideoForAccessibility) == true) {
@@ -201,12 +204,11 @@ enum RCTVideoUtils {
                 roleFlags.append("transcribes-spoken-dialog")
             }
 
-            let selectedOpt = player.currentItem?.currentMediaSelection
             let selectedOption: AVMediaSelectionOption? = player.currentItem?.currentMediaSelection.selectedMediaOption(in: group!)
             let textTrack = TextTrack([
                 "index": NSNumber(value: i),
                 "title": title,
-                "language": language,
+                "language": language as Any,
                 "selected": currentOption?.displayName == selectedOption?.displayName,
                 "roleFlags": roleFlags,
             ])
@@ -387,10 +389,11 @@ enum RCTVideoUtils {
     static func prepareAsset(source: VideoSource) -> (asset: AVURLAsset?, assetOptions: NSMutableDictionary?)? {
         guard let sourceUri = source.uri, sourceUri != "" else { return nil }
         var asset: AVURLAsset!
-        let bundlePath = Bundle.main.path(forResource: source.uri, ofType: source.type) ?? ""
-        let url = source.isNetwork || source.isAsset
-            ? URL(string: source.uri ?? "")
-            : URL(fileURLWithPath: bundlePath)
+        let bundlePath = Bundle.main.path(forResource: sourceUri, ofType: source.type) ?? ""
+        guard let url = source.isNetwork || source.isAsset
+            ? URL(string: sourceUri)
+            : URL(fileURLWithPath: bundlePath) else { return nil }
+
         let assetOptions: NSMutableDictionary! = NSMutableDictionary()
 
         if source.isNetwork {
@@ -398,10 +401,10 @@ enum RCTVideoUtils {
                 assetOptions.setObject(headers, forKey: "AVURLAssetHTTPHeaderFieldsKey" as NSCopying)
             }
             let cookies: [AnyObject]! = HTTPCookieStorage.shared.cookies
-            assetOptions.setObject(cookies, forKey: AVURLAssetHTTPCookiesKey as NSCopying)
-            asset = AVURLAsset(url: url!, options: assetOptions as! [String: Any])
+            assetOptions.setObject(cookies as Any, forKey: AVURLAssetHTTPCookiesKey as NSCopying)
+            asset = AVURLAsset(url: url, options: assetOptions as? [String: Any])
         } else {
-            asset = AVURLAsset(url: url!)
+            asset = AVURLAsset(url: url)
         }
         return (asset, assetOptions)
     }
@@ -454,14 +457,10 @@ enum RCTVideoUtils {
             return try? await AVVideoComposition.videoComposition(
                 with: asset,
                 applyingCIFiltersWithHandler: { (request: AVAsynchronousCIImageFilteringRequest) in
-                    if filter == nil {
-                        request.finish(with: request.sourceImage, context: nil)
-                    } else {
-                        let image: CIImage! = request.sourceImage.clampedToExtent()
-                        filter.setValue(image, forKey: kCIInputImageKey)
-                        let output: CIImage! = filter.outputImage?.cropped(to: request.sourceImage.extent)
-                        request.finish(with: output, context: nil)
-                    }
+                    let image: CIImage! = request.sourceImage.clampedToExtent()
+                    filter.setValue(image, forKey: kCIInputImageKey)
+                    let output: CIImage! = filter.outputImage?.cropped(to: request.sourceImage.extent)
+                    request.finish(with: output, context: nil)
                 }
             )
         } else {
@@ -469,14 +468,10 @@ enum RCTVideoUtils {
                 return AVVideoComposition(
                     asset: asset,
                     applyingCIFiltersWithHandler: { (request: AVAsynchronousCIImageFilteringRequest) in
-                        if filter == nil {
-                            request.finish(with: request.sourceImage, context: nil)
-                        } else {
-                            let image: CIImage! = request.sourceImage.clampedToExtent()
-                            filter.setValue(image, forKey: kCIInputImageKey)
-                            let output: CIImage! = filter.outputImage?.cropped(to: request.sourceImage.extent)
-                            request.finish(with: output, context: nil)
-                        }
+                        let image: CIImage! = request.sourceImage.clampedToExtent()
+                        filter.setValue(image, forKey: kCIInputImageKey)
+                        let output: CIImage! = filter.outputImage?.cropped(to: request.sourceImage.extent)
+                        request.finish(with: output, context: nil)
                     }
                 )
             #endif
diff --git a/ios/Video/RCTVideo.swift b/ios/Video/RCTVideo.swift
index 48c76b51fc..e7bbf39add 100644
--- a/ios/Video/RCTVideo.swift
+++ b/ios/Video/RCTVideo.swift
@@ -17,7 +17,6 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
 
     private var _playerViewController: RCTVideoPlayerViewController?
     private var _videoURL: NSURL?
-    private var _localSourceEncryptionKeyScheme: String?
 
     /* Required to publish events */
     private var _eventDispatcher: RCTEventDispatcher?
@@ -42,20 +41,19 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
     private var _repeat = false
     private var _isPlaying = false
     private var _allowsExternalPlayback = true
-    private var _textTracks: [TextTrack] = []
-    private var _selectedTextTrackCriteria: SelectedTrackCriteria?
-    private var _selectedAudioTrackCriteria: SelectedTrackCriteria?
+    private var _selectedTextTrackCriteria: SelectedTrackCriteria = .none()
+    private var _selectedAudioTrackCriteria: SelectedTrackCriteria = .none()
     private var _playbackStalled = false
     private var _playInBackground = false
     private var _preventsDisplaySleepDuringVideoPlayback = true
     private var _preferredForwardBufferDuration: Float = 0.0
     private var _playWhenInactive = false
-    private var _ignoreSilentSwitch: String! = "inherit" // inherit, ignore, obey
-    private var _mixWithOthers: String! = "inherit" // inherit, mix, duck
-    private var _resizeMode: String! = "cover"
+    private var _ignoreSilentSwitch: String = "inherit" // inherit, ignore, obey
+    private var _mixWithOthers: String = "inherit" // inherit, mix, duck
+    private var _resizeMode: String = "cover"
     private var _fullscreen = false
     private var _fullscreenAutorotate = true
-    private var _fullscreenOrientation: String! = "all"
+    private var _fullscreenOrientation: String = "all"
     private var _fullscreenPlayerPresented = false
     private var _fullscreenUncontrolPlayerPresented = false // to call events switching full screen mode from player controls
     private var _filterName: String!
@@ -63,6 +61,8 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
     private var _presentingViewController: UIViewController?
     private var _startPosition: Float64 = -1
     private var _showNotificationControls = false
+    // Buffer last bitrate value received. Initialized to -2 to ensure -1 (sometimes reported by AVPlayer) is not missed
+    private var _lastBitrate = -2.0
     private var _pictureInPictureEnabled = false {
         didSet {
             #if os(iOS)
@@ -96,7 +96,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
     private var _didRequestAds = false
     private var _adPlaying = false
 
-    private var _resouceLoaderDelegate: RCTResourceLoaderDelegate?
+    private lazy var _drmManager: DRMManager? = DRMManager()
     private var _playerObserver: RCTPlayerObserver = .init()
 
     #if USE_VIDEO_CACHING
@@ -351,7 +351,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         #endif
 
         if let video = _player?.currentItem,
-           video == nil || video.status != AVPlayerItem.Status.readyToPlay {
+           video.status != AVPlayerItem.Status.readyToPlay {
             return
         }
 
@@ -384,7 +384,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
                 "playableDuration": RCTVideoUtils.calculatePlayableDuration(_player, withSource: _source),
                 "atValue": currentTime?.value ?? .zero,
                 "currentPlaybackTime": NSNumber(value: Double(currentPlaybackTime?.timeIntervalSince1970 ?? 0 * 1000)).int64Value,
-                "target": reactTag,
+                "target": reactTag as Any,
                 "seekableDuration": RCTVideoUtils.calculateSeekableDuration(_player),
             ])
         }
@@ -416,17 +416,17 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         // Perform on next run loop, otherwise onVideoLoadStart is nil
         onVideoLoadStart?([
             "src": [
-                "uri": _source?.uri ?? NSNull(),
+                "uri": _source?.uri ?? NSNull() as Any,
                 "type": _source?.type ?? NSNull(),
                 "isNetwork": NSNumber(value: _source?.isNetwork ?? false),
             ],
-            "drm": source.drm?.json ?? NSNull(),
-            "target": reactTag,
+            "drm": source.drm.json ?? NSNull(),
+            "target": reactTag as Any,
         ])
 
         if let uri = source.uri, uri.starts(with: "ph://") {
             let photoAsset = await RCTVideoUtils.preparePHAsset(uri: uri)
-            return await playerItemPrepareText(asset: photoAsset, assetOptions: nil, uri: source.uri ?? "")
+            return await playerItemPrepareText(source: source, asset: photoAsset, assetOptions: nil, uri: source.uri ?? "")
         }
 
         guard let assetResult = RCTVideoUtils.prepareAsset(source: source),
@@ -452,23 +452,26 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         }
 
         #if USE_VIDEO_CACHING
-            if _videoCache.shouldCache(source: source, textTracks: _textTracks) {
-                return try await _videoCache.playerItemForSourceUsingCache(uri: source.uri, assetOptions: assetOptions)
+            if _videoCache.shouldCache(source: source) {
+                return try await _videoCache.playerItemForSourceUsingCache(source: source, assetOptions: assetOptions)
             }
         #endif
 
-        if source.drm != nil || _localSourceEncryptionKeyScheme != nil {
-            _resouceLoaderDelegate = RCTResourceLoaderDelegate(
+        if source.drm.json != nil {
+            if _drmManager == nil {
+                _drmManager = DRMManager()
+            }
+
+            _drmManager?.createContentKeyRequest(
                 asset: asset,
-                drm: source.drm,
-                localSourceEncryptionKeyScheme: _localSourceEncryptionKeyScheme,
+                drmParams: source.drm,
+                reactTag: reactTag,
                 onVideoError: onVideoError,
-                onGetLicense: onGetLicense,
-                reactTag: reactTag
+                onGetLicense: onGetLicense
             )
         }
 
-        return await playerItemPrepareText(asset: asset, assetOptions: assetOptions, uri: source.uri ?? "")
+        return await playerItemPrepareText(source: source, asset: asset, assetOptions: assetOptions, uri: source.uri ?? "")
     }
 
     func setupPlayer(playerItem: AVPlayerItem) async throws {
@@ -489,7 +492,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
 
         if _player == nil {
             _player = AVPlayer()
-            ReactNativeVideoManager.shared.onInstanceCreated(id: instanceId, player: _player)
+            ReactNativeVideoManager.shared.onInstanceCreated(id: instanceId, player: _player as Any)
 
             _player!.replaceCurrentItem(with: playerItem)
 
@@ -498,7 +501,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
                 NowPlayingInfoCenterManager.shared.registerPlayer(player: _player!)
             }
         } else {
-            #if !os(tvOS)
+            #if !os(tvOS) && !os(visionOS)
                 if #available(iOS 16.0, *) {
                     // This feature caused crashes, if the app was put in bg, before the source change
                     // https://github.com/TheWidlarzGroup/react-native-video/issues/3900
@@ -506,7 +509,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
                 }
             #endif
             _player?.replaceCurrentItem(with: playerItem)
-            #if !os(tvOS)
+            #if !os(tvOS) && !os(visionOS)
                 if #available(iOS 16.0, *) {
                     self._playerViewController?.allowsVideoFrameAnalysis = true
                 }
@@ -561,7 +564,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
             }
             self.removePlayerLayer()
             self._playerObserver.player = nil
-            self._resouceLoaderDelegate = nil
+            self._drmManager = nil
             self._playerObserver.playerItem = nil
 
             // perform on next run loop, otherwise other passed react-props may not be set
@@ -593,13 +596,8 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         DispatchQueue.global(qos: .default).async(execute: initializeSource)
     }
 
-    @objc
-    func setLocalSourceEncryptionKeyScheme(_ keyScheme: String) {
-        _localSourceEncryptionKeyScheme = keyScheme
-    }
-
-    func playerItemPrepareText(asset: AVAsset!, assetOptions: NSDictionary?, uri: String) async -> AVPlayerItem {
-        if self._textTracks.isEmpty == true || (uri.hasSuffix(".m3u8")) {
+    func playerItemPrepareText(source: VideoSource, asset: AVAsset!, assetOptions: NSDictionary?, uri: String) async -> AVPlayerItem {
+        if source.textTracks.isEmpty == true || uri.hasSuffix(".m3u8") {
             return await self.playerItemPropegateMetadata(AVPlayerItem(asset: asset))
         }
 
@@ -610,15 +608,15 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
             asset: asset,
             assetOptions: assetOptions,
             mixComposition: mixComposition,
-            textTracks: self._textTracks
+            textTracks: source.textTracks
         )
 
         if validTextTracks.isEmpty {
             DebugLog("Strange state, not valid textTrack")
         }
 
-        if validTextTracks.count != self._textTracks.count {
-            self.setTextTracks(validTextTracks)
+        if validTextTracks.count != source.textTracks.count {
+            setSelectedTextTrack(_selectedTextTrackCriteria)
         }
 
         return await self.playerItemPropegateMetadata(AVPlayerItem(asset: mixComposition))
@@ -743,14 +741,14 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
 
     @objc
     func setIgnoreSilentSwitch(_ ignoreSilentSwitch: String?) {
-        _ignoreSilentSwitch = ignoreSilentSwitch
+        _ignoreSilentSwitch = ignoreSilentSwitch ?? "inherit"
         RCTPlayerOperations.configureAudio(ignoreSilentSwitch: _ignoreSilentSwitch, mixWithOthers: _mixWithOthers, audioOutput: _audioOutput)
         applyModifiers()
     }
 
     @objc
     func setMixWithOthers(_ mixWithOthers: String?) {
-        _mixWithOthers = mixWithOthers
+        _mixWithOthers = mixWithOthers ?? "inherit"
         applyModifiers()
     }
 
@@ -810,7 +808,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
             self.setPaused(self._paused)
             self.onVideoSeek?(["currentTime": NSNumber(value: Float(CMTimeGetSeconds(item.currentTime()))),
                                "seekTime": time,
-                               "target": self.reactTag])
+                               "target": self.reactTag as Any])
         }
 
         _pendingSeek = false
@@ -908,7 +906,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
 
     func applyModifiers() {
         if let video = _player?.currentItem,
-           video == nil || video.status != AVPlayerItem.Status.readyToPlay {
+           video.status != AVPlayerItem.Status.readyToPlay {
             return
         }
         if _muted {
@@ -933,10 +931,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
             setMaxBitRate(_maxBitRate)
         }
 
-        if _selectedTextTrackCriteria != nil {
-            setSelectedTextTrack(_selectedTextTrackCriteria)
-        }
-
+        setSelectedTextTrack(_selectedTextTrackCriteria)
         setAudioOutput(_audioOutput)
         setSelectedAudioTrack(_selectedAudioTrackCriteria)
         setResizeMode(_resizeMode)
@@ -957,7 +952,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
     }
 
     func setSelectedAudioTrack(_ selectedAudioTrack: SelectedTrackCriteria?) {
-        _selectedAudioTrackCriteria = selectedAudioTrack
+        _selectedAudioTrackCriteria = selectedAudioTrack ?? SelectedTrackCriteria.none()
         Task {
             await RCTPlayerOperations.setMediaSelectionTrackForCharacteristic(player: _player, characteristic: AVMediaCharacteristic.audible,
                                                                               criteria: _selectedAudioTrackCriteria)
@@ -970,9 +965,10 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
     }
 
     func setSelectedTextTrack(_ selectedTextTrack: SelectedTrackCriteria?) {
-        _selectedTextTrackCriteria = selectedTextTrack
-        if !_textTracks.isEmpty { // sideloaded text tracks
-            RCTPlayerOperations.setSideloadedText(player: _player, textTracks: _textTracks, criteria: _selectedTextTrackCriteria)
+        _selectedTextTrackCriteria = selectedTextTrack ?? SelectedTrackCriteria.none()
+        guard let source = _source else { return }
+        if !source.textTracks.isEmpty { // sideloaded text tracks
+            RCTPlayerOperations.setSideloadedText(player: _player, textTracks: source.textTracks, criteria: _selectedTextTrackCriteria)
         } else { // text tracks included in the HLS playlist§
             Task {
                 await RCTPlayerOperations.setMediaSelectionTrackForCharacteristic(player: _player, characteristic: AVMediaCharacteristic.legible,
@@ -981,21 +977,6 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         }
     }
 
-    @objc
-    func setTextTracks(_ textTracks: [NSDictionary]?) {
-        setTextTracks(textTracks?.map { TextTrack($0) })
-    }
-
-    func setTextTracks(_ textTracks: [TextTrack]?) {
-        if textTracks == nil {
-            _textTracks = []
-        } else {
-            _textTracks = textTracks!
-        }
-        // in case textTracks was set after selectedTextTrack
-        if _selectedTextTrackCriteria != nil { setSelectedTextTrack(_selectedTextTrackCriteria) }
-    }
-
     @objc
     func setChapters(_ chapters: [NSDictionary]?) {
         setChapters(chapters?.map { Chapter($0) })
@@ -1007,7 +988,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
 
     @objc
     func setFullscreen(_ fullscreen: Bool) {
-        var alreadyFullscreenPresented = _presentingViewController?.presentedViewController != nil
+        let alreadyFullscreenPresented = _presentingViewController?.presentedViewController != nil
         if fullscreen && !_fullscreenPlayerPresented && _player != nil && !alreadyFullscreenPresented {
             // Ensure player view controller is not null
             // Controls will be displayed even if it is disabled in configuration
@@ -1046,7 +1027,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
                         self._fullscreenPlayerPresented = fullscreen
                         self._playerViewController?.autorotate = self._fullscreenAutorotate
 
-                        self.onVideoFullscreenPlayerDidPresent?(["target": self.reactTag])
+                        self.onVideoFullscreenPlayerDidPresent?(["target": self.reactTag as Any])
                     })
                 }
             }
@@ -1069,9 +1050,9 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
 
     @objc
     func setFullscreenOrientation(_ orientation: String?) {
-        _fullscreenOrientation = orientation
+        _fullscreenOrientation = orientation ?? "all"
         if _fullscreenPlayerPresented {
-            _playerViewController?.preferredOrientation = orientation
+            _playerViewController?.preferredOrientation = _fullscreenOrientation
         }
     }
 
@@ -1243,7 +1224,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
     }
 
     @objc
-    func setAdTagUrl(_ adTagUrl: String!) {
+    func setAdTagUrl(_ adTagUrl: String?) {
         _adTagUrl = adTagUrl
     }
 
@@ -1305,14 +1286,13 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         _playerItem = nil
         _source = nil
         _chapters = nil
-        _textTracks = []
-        _selectedTextTrackCriteria = nil
-        _selectedAudioTrackCriteria = nil
+        _selectedTextTrackCriteria = SelectedTrackCriteria.none()
+        _selectedAudioTrackCriteria = SelectedTrackCriteria.none()
         _presentingViewController = nil
 
-        ReactNativeVideoManager.shared.onInstanceRemoved(id: instanceId, player: _player)
+        ReactNativeVideoManager.shared.onInstanceRemoved(id: instanceId, player: _player as Any)
         _player = nil
-        _resouceLoaderDelegate = nil
+        _drmManager = nil
         _playerObserver.clearPlayer()
 
         self.removePlayerLayer()
@@ -1345,12 +1325,12 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         )
     }
 
-    func setLicenseResult(_ license: String!, _ licenseUrl: String!) {
-        _resouceLoaderDelegate?.setLicenseResult(license, licenseUrl)
+    func setLicenseResult(_ license: String, _ licenseUrl: String) {
+        _drmManager?.setJSLicenseResult(license: license, licenseUrl: licenseUrl)
     }
 
-    func setLicenseResultError(_ error: String!, _ licenseUrl: String!) {
-        _resouceLoaderDelegate?.setLicenseResultError(error, licenseUrl)
+    func setLicenseResultError(_ error: String, _ licenseUrl: String) {
+        _drmManager?.setJSLicenseError(error: error, licenseUrl: licenseUrl)
     }
 
     // MARK: - RCTPlayerObserverHandler
@@ -1364,7 +1344,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
             _isBuffering = false
         }
         onReadyForDisplay?([
-            "target": reactTag,
+            "target": reactTag as Any,
         ])
     }
 
@@ -1383,7 +1363,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         }
 
         onTimedMetadata?([
-            "target": reactTag,
+            "target": reactTag as Any,
             "metadata": metadata,
         ])
     }
@@ -1417,7 +1397,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
 
     func handleReadyToPlay() {
         guard let _playerItem else { return }
-
+        guard let source = _source else { return }
         Task {
             if self._pendingSeek {
                 self.setSeek(NSNumber(value: self._pendingSeekTime), NSNumber(value: 100))
@@ -1446,7 +1426,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
                 var orientation = "undefined"
 
                 let tracks = await RCTVideoAssetsUtils.getTracks(asset: _playerItem.asset, withMediaType: .video)
-                var presentationSize = _playerItem.presentationSize
+                let presentationSize = _playerItem.presentationSize
                 if presentationSize.height != 0.0 {
                     width = Float(presentationSize.width)
                     height = Float(presentationSize.height)
@@ -1473,7 +1453,7 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
                                        "orientation": orientation,
                                    ],
                                    "audioTracks": audioTracks,
-                                   "textTracks": extractJsonWithIndex(from: _textTracks) ?? textTracks.map(\.json),
+                                   "textTracks": extractJsonWithIndex(from: source.textTracks) ?? textTracks.map(\.json),
                                    "videoTracks": [AnyObject](),
                                    "target": self.reactTag as Any])
             }
@@ -1494,14 +1474,14 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
             [
                 "error": [
                     "code": NSNumber(value: (_playerItem.error! as NSError).code),
-                    "localizedDescription": _playerItem.error?.localizedDescription == nil ? "" : _playerItem.error?.localizedDescription,
+                    "localizedDescription": _playerItem.error?.localizedDescription == nil ? "" : _playerItem.error?.localizedDescription as Any,
                     "localizedFailureReason": ((_playerItem.error! as NSError).localizedFailureReason == nil ?
                         "" : (_playerItem.error! as NSError).localizedFailureReason) ?? "",
                     "localizedRecoverySuggestion": ((_playerItem.error! as NSError).localizedRecoverySuggestion == nil ?
                         "" : (_playerItem.error! as NSError).localizedRecoverySuggestion) ?? "",
                     "domain": (_playerItem.error as! NSError).domain,
                 ],
-                "target": reactTag,
+                "target": reactTag as Any,
             ]
         )
     }
@@ -1614,12 +1594,12 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
             [
                 "error": [
                     "code": NSNumber(value: (error as NSError).code),
-                    "localizedDescription": error.localizedDescription ?? "",
+                    "localizedDescription": error.localizedDescription,
                     "localizedFailureReason": (error as NSError).localizedFailureReason ?? "",
                     "localizedRecoverySuggestion": (error as NSError).localizedRecoverySuggestion ?? "",
                     "domain": (error as NSError).domain,
                 ],
-                "target": reactTag,
+                "target": reactTag as Any,
             ]
         )
     }
@@ -1663,16 +1643,19 @@ class RCTVideo: UIView, RCTVideoPlayerViewControllerDelegate, RCTPlayerObserverH
         guard let accessLog = (notification.object as? AVPlayerItem)?.accessLog() else {
             return
         }
-
         guard let lastEvent = accessLog.events.last else { return }
-        onVideoBandwidthUpdate?(["bitrate": lastEvent.indicatedBitrate, "target": reactTag])
+        if lastEvent.indicatedBitrate != _lastBitrate {
+            _lastBitrate = lastEvent.indicatedBitrate
+            onVideoBandwidthUpdate?(["bitrate": _lastBitrate, "target": reactTag as Any])
+        }
     }
 
     func handleTracksChange(playerItem _: AVPlayerItem, change _: NSKeyValueObservedChange<[AVPlayerItemTrack]>) {
+        guard let source = _source else { return }
         if onTextTracks != nil {
             Task {
                 let textTracks = await RCTVideoUtils.getTextTrackInfo(self._player)
-                self.onTextTracks?(["textTracks": extractJsonWithIndex(from: _textTracks) ?? textTracks.compactMap(\.json)])
+                self.onTextTracks?(["textTracks": extractJsonWithIndex(from: source.textTracks) ?? textTracks.compactMap(\.json)])
             }
         }
 
diff --git a/ios/Video/RCTVideoPlayerViewControllerDelegate.swift b/ios/Video/RCTVideoPlayerViewControllerDelegate.swift
index 2f9fec3fbd..acce37e4e3 100644
--- a/ios/Video/RCTVideoPlayerViewControllerDelegate.swift
+++ b/ios/Video/RCTVideoPlayerViewControllerDelegate.swift
@@ -1,7 +1,7 @@
 import AVKit
 import Foundation
 
-protocol RCTVideoPlayerViewControllerDelegate: class {
+protocol RCTVideoPlayerViewControllerDelegate: AnyObject {
     func videoPlayerViewControllerWillDismiss(playerViewController: AVPlayerViewController)
     func videoPlayerViewControllerDidDismiss(playerViewController: AVPlayerViewController)
 }
diff --git a/ios/VideoCaching/RCTVideoCachingHandler.swift b/ios/VideoCaching/RCTVideoCachingHandler.swift
index aeab331aed..061230d527 100644
--- a/ios/VideoCaching/RCTVideoCachingHandler.swift
+++ b/ios/VideoCaching/RCTVideoCachingHandler.swift
@@ -4,20 +4,20 @@ import Foundation
 
 class RCTVideoCachingHandler: NSObject, DVAssetLoaderDelegatesDelegate {
     private var _videoCache: RCTVideoCache! = RCTVideoCache.sharedInstance()
-    var playerItemPrepareText: ((AVAsset?, NSDictionary?, String) async -> AVPlayerItem)?
+    var playerItemPrepareText: ((VideoSource, AVAsset?, NSDictionary?, String) async -> AVPlayerItem)?
 
     override init() {
         super.init()
     }
 
-    func shouldCache(source: VideoSource, textTracks: [TextTrack]?) -> Bool {
-        if source.isNetwork && source.shouldCache && ((textTracks == nil) || (textTracks!.isEmpty)) {
+    func shouldCache(source: VideoSource) -> Bool {
+        if source.isNetwork && source.shouldCache && source.textTracks.isEmpty {
             /* The DVURLAsset created by cache doesn't have a tracksWithMediaType property, so trying
              * to bring in the text track code will crash. I suspect this is because the asset hasn't fully loaded.
              * Until this is fixed, we need to bypass caching when text tracks are specified.
              */
             DebugLog("""
-              Caching is not supported for uri '\(source.uri)' because text tracks are not compatible with the cache.
+              Caching is not supported for uri '\(source.uri ?? "NO URI")' because text tracks are not compatible with the cache.
               Checkout https://github.com/react-native-community/react-native-video/blob/master/docs/caching.md
             """)
             return true
@@ -25,7 +25,8 @@ class RCTVideoCachingHandler: NSObject, DVAssetLoaderDelegatesDelegate {
         return false
     }
 
-    func playerItemForSourceUsingCache(uri: String!, assetOptions options: NSDictionary!) async throws -> AVPlayerItem {
+    func playerItemForSourceUsingCache(source: VideoSource, assetOptions options: NSDictionary) async throws -> AVPlayerItem {
+        let uri = source.uri!
         let url = URL(string: uri)
         let (videoCacheStatus, cachedAsset) = await getItemForUri(uri)
 
@@ -36,33 +37,33 @@ class RCTVideoCachingHandler: NSObject, DVAssetLoaderDelegatesDelegate {
         switch videoCacheStatus {
         case .missingFileExtension:
             DebugLog("""
-              Could not generate cache key for uri '\(uri ?? "NO_URI")'.
+              Could not generate cache key for uri '\(uri)'.
               It is currently not supported to cache urls that do not include a file extension.
               The video file will not be cached.
               Checkout https://github.com/react-native-community/react-native-video/blob/master/docs/caching.md
             """)
-            let asset: AVURLAsset! = AVURLAsset(url: url!, options: options as! [String: Any])
-            return await playerItemPrepareText(asset, options, "")
+            let asset: AVURLAsset! = AVURLAsset(url: url!, options: options as? [String: Any])
+            return await playerItemPrepareText(source, asset, options, "")
 
         case .unsupportedFileExtension:
             DebugLog("""
-              Could not generate cache key for uri '\(uri ?? "NO_URI")'.
+              Could not generate cache key for uri '\(uri)'.
               The file extension of that uri is currently not supported.
               The video file will not be cached.
               Checkout https://github.com/react-native-community/react-native-video/blob/master/docs/caching.md
             """)
-            let asset: AVURLAsset! = AVURLAsset(url: url!, options: options as! [String: Any])
-            return await playerItemPrepareText(asset, options, "")
+            let asset: AVURLAsset! = AVURLAsset(url: url!, options: options as? [String: Any])
+            return await playerItemPrepareText(source, asset, options, "")
 
         default:
             if let cachedAsset {
-                DebugLog("Playing back uri '\(uri ?? "NO_URI")' from cache")
+                DebugLog("Playing back uri '\(uri)' from cache")
                 // See note in playerItemForSource about not being able to support text tracks & caching
                 return AVPlayerItem(asset: cachedAsset)
             }
         }
 
-        let asset: DVURLAsset! = DVURLAsset(url: url, options: options as! [String: Any], networkTimeout: 10000)
+        let asset: DVURLAsset! = DVURLAsset(url: url, options: options as? [String: Any], networkTimeout: 10000)
         asset.loaderDelegate = self
 
         /* More granular code to have control over the DVURLAsset
diff --git a/package.json b/package.json
index 02cbbfd1c2..ca11e4d0d9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "react-native-video",
-    "version": "6.5.0",
+    "version": "6.6.2",
     "description": "A <Video /> element for react-native",
     "main": "lib/index",
     "source": "src/index",
diff --git a/src/Video.tsx b/src/Video.tsx
index b375b5bf72..8f8dd6c04b 100644
--- a/src/Video.tsx
+++ b/src/Video.tsx
@@ -79,6 +79,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       poster,
       posterResizeMode,
       renderLoader,
+      contentStartTime,
       drm,
       textTracks,
       selectedVideoTrack,
@@ -118,6 +119,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       onTextTrackDataChanged,
       onVideoTracks,
       onAspectRatio,
+      localSourceEncryptionKeyScheme,
       ...rest
     },
     ref,
@@ -126,8 +128,18 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
 
     const isPosterDeprecated = typeof poster === 'string';
 
+    const _renderLoader = useMemo(
+      () =>
+        !renderLoader
+          ? undefined
+          : renderLoader instanceof Function
+          ? renderLoader
+          : () => renderLoader,
+      [renderLoader],
+    );
+
     const hasPoster = useMemo(() => {
-      if (renderLoader) {
+      if (_renderLoader) {
         return true;
       }
 
@@ -136,7 +148,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       }
 
       return !!poster?.source;
-    }, [isPosterDeprecated, poster, renderLoader]);
+    }, [isPosterDeprecated, poster, _renderLoader]);
 
     const [showPoster, setShowPoster] = useState(hasPoster);
 
@@ -166,6 +178,7 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       );
 
       const selectedDrm = source.drm || drm;
+      const _textTracks = source.textTracks || textTracks;
       const _drm = !selectedDrm
         ? undefined
         : {
@@ -177,6 +190,9 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
             base64Certificate: selectedDrm.base64Certificate,
             useExternalGetLicense: !!selectedDrm.getLicense,
             multiDrm: selectedDrm.multiDrm,
+            localSourceEncryptionKeyScheme:
+              selectedDrm.localSourceEncryptionKeyScheme ||
+              localSourceEncryptionKeyScheme,
           };
 
       let _cmcd: NativeCmcdConfiguration | undefined;
@@ -203,6 +219,9 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
         }
       }
 
+      const selectedContentStartTime =
+        source.contentStartTime || contentStartTime;
+
       return {
         uri,
         isNetwork,
@@ -215,13 +234,21 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
         startPosition: resolvedSource.startPosition ?? -1,
         cropStart: resolvedSource.cropStart || 0,
         cropEnd: resolvedSource.cropEnd,
+        contentStartTime: selectedContentStartTime,
         metadata: resolvedSource.metadata,
         drm: _drm,
         cmcd: _cmcd,
+        textTracks: _textTracks,
         textTracksAllowChunklessPreparation:
           resolvedSource.textTracksAllowChunklessPreparation,
       };
-    }, [drm, source]);
+    }, [
+      drm,
+      source,
+      textTracks,
+      contentStartTime,
+      localSourceEncryptionKeyScheme,
+    ]);
 
     const _selectedTextTrack = useMemo(() => {
       if (!selectedTextTrack) {
@@ -681,15 +708,23 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       }
 
       // render poster
-      if (renderLoader && (poster || posterResizeMode)) {
+      if (_renderLoader && (poster || posterResizeMode)) {
         console.warn(
           'You provided both `renderLoader` and `poster` or `posterResizeMode` props. `renderLoader` will be used.',
         );
       }
 
       // render loader
-      if (renderLoader) {
-        return <View style={StyleSheet.absoluteFill}>{renderLoader}</View>;
+      if (_renderLoader) {
+        return (
+          <View style={StyleSheet.absoluteFill}>
+            {_renderLoader({
+              source: source,
+              style: posterStyle,
+              resizeMode: resizeMode,
+            })}
+          </View>
+        );
       }
 
       return (
@@ -704,8 +739,10 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
       isPosterDeprecated,
       poster,
       posterResizeMode,
-      renderLoader,
+      _renderLoader,
       showPoster,
+      source,
+      resizeMode,
     ]);
 
     const _style: StyleProp<ViewStyle> = useMemo(
@@ -727,7 +764,6 @@ const Video = forwardRef<VideoRef, ReactVideoProps>(
           restoreUserInterfaceForPIPStopCompletionHandler={
             _restoreUserInterfaceForPIPStopCompletionHandler
           }
-          textTracks={textTracks}
           selectedTextTrack={_selectedTextTrack}
           selectedAudioTrack={_selectedAudioTrack}
           selectedVideoTrack={_selectedVideoTrack}
diff --git a/src/expo-plugins/withNotificationControls.ts b/src/expo-plugins/withNotificationControls.ts
index 8c76f81423..df204eebca 100644
--- a/src/expo-plugins/withNotificationControls.ts
+++ b/src/expo-plugins/withNotificationControls.ts
@@ -24,6 +24,19 @@ export const withNotificationControls: ConfigPlugin<boolean> = (
         application.service = [];
       }
 
+      // We check if the VideoPlaybackService is already defined in the AndroidManifest.xml
+      // to prevent adding duplicate service entries. If the service exists, we will remove
+      // it before adding the updated configuration to ensure there are no conflicts or redundant
+      // service declarations in the manifest.
+      const existingServiceIndex = application.service.findIndex(
+        (service) =>
+          service?.$?.['android:name'] ===
+          'com.brentvatne.exoplayer.VideoPlaybackService',
+      );
+      if (existingServiceIndex !== -1) {
+        application.service.splice(existingServiceIndex, 1);
+      }
+
       application.service.push({
         $: {
           'android:name': 'com.brentvatne.exoplayer.VideoPlaybackService',
diff --git a/src/specs/VideoNativeComponent.ts b/src/specs/VideoNativeComponent.ts
index f26012a9f6..2f81cc36ea 100644
--- a/src/specs/VideoNativeComponent.ts
+++ b/src/specs/VideoNativeComponent.ts
@@ -38,10 +38,12 @@ export type VideoSrc = Readonly<{
   startPosition?: Float;
   cropStart?: Float;
   cropEnd?: Float;
+  contentStartTime?: Int32; // Android
   metadata?: VideoMetadata;
   drm?: Drm;
   cmcd?: NativeCmcdConfiguration; // android
   textTracksAllowChunklessPreparation?: boolean; // android
+  textTracks?: TextTracks;
 }>;
 
 type DRMType = WithDefault<string, 'widevine'>;
@@ -60,6 +62,7 @@ type Drm = Readonly<{
   base64Certificate?: boolean; // ios default: false
   useExternalGetLicense?: boolean; // ios
   multiDrm?: WithDefault<boolean, false>; // android
+  localSourceEncryptionKeyScheme?: string; // ios
 }>;
 
 type CmcdMode = WithDefault<Int32, 1>;
@@ -322,7 +325,6 @@ export interface VideoNativeProps extends ViewProps {
   automaticallyWaitsToMinimizeStalling?: boolean;
   shutterColor?: Int32;
   audioOutput?: WithDefault<string, 'speaker'>;
-  textTracks?: TextTracks;
   selectedTextTrack?: SelectedTextTrack;
   selectedAudioTrack?: SelectedAudioTrack;
   selectedVideoTrack?: SelectedVideoTrack; // android
@@ -345,11 +347,9 @@ export interface VideoNativeProps extends ViewProps {
   fullscreenOrientation?: WithDefault<string, 'all'>;
   progressUpdateInterval?: Float;
   restoreUserInterfaceForPIPStopCompletionHandler?: boolean;
-  localSourceEncryptionKeyScheme?: string;
   debug?: DebugConfig;
   showNotificationControls?: WithDefault<boolean, false>; // Android, iOS
   bufferConfig?: BufferConfig; // Android
-  contentStartTime?: Int32; // Android
   currentPlaybackTime?: Double; // Android
   disableDisconnectError?: boolean; // Android
   focusable?: boolean; // Android
diff --git a/src/types/video.ts b/src/types/video.ts
index 0fbc9b72b8..9e25e25ea5 100644
--- a/src/types/video.ts
+++ b/src/types/video.ts
@@ -7,6 +7,7 @@ import type {
   ViewStyle,
   ImageRequireSource,
   ImageURISource,
+  ImageStyle,
 } from 'react-native';
 import type {ReactNode} from 'react';
 import type VideoResizeMode from './ResizeMode';
@@ -31,10 +32,12 @@ export type ReactVideoSourceProperties = {
   startPosition?: number;
   cropStart?: number;
   cropEnd?: number;
+  contentStartTime?: number; // Android
   metadata?: VideoMetadata;
   drm?: Drm;
   cmcd?: Cmcd; // android
   textTracksAllowChunklessPreparation?: boolean;
+  textTracks?: TextTracks;
 };
 
 export type ReactVideoSource = Readonly<
@@ -78,6 +81,7 @@ export type Drm = Readonly<{
   certificateUrl?: string; // ios
   base64Certificate?: boolean; // ios default: false
   multiDrm?: boolean; // android
+  localSourceEncryptionKeyScheme?: string; // ios
   /* eslint-disable @typescript-eslint/no-unused-vars */
   getLicense?: (
     spcBase64: string,
@@ -252,9 +256,15 @@ export type ControlsStyles = {
   hideNotificationBarOnFullScreenMode?: boolean;
 };
 
+export interface ReactVideoRenderLoaderProps {
+  source?: ReactVideoSource;
+  style?: StyleProp<ImageStyle>;
+  resizeMode?: EnumValues<VideoResizeMode>;
+}
+
 export interface ReactVideoProps extends ReactVideoEvents, ViewProps {
   source?: ReactVideoSource;
-  /** @deprecated */
+  /** @deprecated Use source.drm */
   drm?: Drm;
   style?: StyleProp<ViewStyle>;
   adTagUrl?: string;
@@ -264,6 +274,7 @@ export interface ReactVideoProps extends ReactVideoEvents, ViewProps {
   bufferConfig?: BufferConfig; // Android
   bufferingStrategy?: BufferingStrategyType;
   chapters?: Chapters[]; // iOS
+  /** @deprecated Use source.contentStartTime */
   contentStartTime?: number; // Android
   controls?: boolean;
   currentPlaybackTime?: number; // Android
@@ -292,7 +303,7 @@ export interface ReactVideoProps extends ReactVideoEvents, ViewProps {
   preventsDisplaySleepDuringVideoPlayback?: boolean;
   progressUpdateInterval?: number;
   rate?: number;
-  renderLoader?: ReactNode;
+  renderLoader?: ReactNode | ((arg0: ReactVideoRenderLoaderProps) => ReactNode);
   repeat?: boolean;
   reportBandwidth?: boolean; //Android
   resizeMode?: EnumValues<VideoResizeMode>;
@@ -302,14 +313,16 @@ export interface ReactVideoProps extends ReactVideoEvents, ViewProps {
   selectedVideoTrack?: SelectedVideoTrack; // android
   subtitleStyle?: SubtitleStyle; // android
   shutterColor?: string; // Android
+  /** @deprecated Use source.textTracks */
   textTracks?: TextTracks;
   testID?: string;
   viewType?: ViewType;
-  /** @deprecated */
+  /** @deprecated Use viewType */
   useTextureView?: boolean; // Android
-  /** @deprecated */
+  /** @deprecated Use viewType*/
   useSecureView?: boolean; // Android
   volume?: number;
+  /** @deprecated use **localSourceEncryptionKeyScheme** key in **drm** props instead */
   localSourceEncryptionKeyScheme?: string;
   debug?: DebugConfig;
   allowsExternalPlayback?: boolean; // iOS