feat(android): allow both exoplayer and vlc

android/src/main/java/dev/zoriya/omni/OmniPlayer.kt

@@ -7,6 +7,7 @@ import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Intent
 import android.os.Build
+import android.os.Bundle
 import android.view.SurfaceHolder
 import androidx.core.app.NotificationCompat
 import androidx.media3.common.AudioAttributes
@@ -14,7 +15,12 @@ import androidx.media3.common.C
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
 import androidx.media3.common.Player
+import androidx.media3.datasource.DefaultDataSource
+import androidx.media3.datasource.DefaultHttpDataSource
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.omni.AndroidBackend
 import com.margelo.nitro.omni.CastStatus
 import com.margelo.nitro.omni.HybridOmniPlayerSpec
 import com.margelo.nitro.omni.MixAudioMode
@@ -34,11 +40,26 @@ import dev.zoriya.omni.utils.ThreadHelper.runOnMainThread
 import dev.zoriya.omni.utils.ThreadHelper.runOnMainThreadSync
 
 @SuppressLint("UnsafeOptInUsageError")
-class OmniPlayer : HybridOmniPlayerSpec() {
+class OmniPlayer(private val backend: AndroidBackend = AndroidBackend.VLC) : HybridOmniPlayerSpec() {
     private val ctx = NitroModules.applicationContext ?: throw Error("No Context available!")
+
+    // exoplayer only, used to specify request headers.
+    private var httpDataSourceFactory: DefaultHttpDataSource.Factory? = null
+
     val player: Player = runOnMainThreadSync {
-        // ExoPlayer.Builder(ctx).build()
-        VlcPlayer(ctx)
+        when (backend) {
+            AndroidBackend.EXOPLAYER -> {
+                val http = DefaultHttpDataSource.Factory().setAllowCrossProtocolRedirects(true)
+                httpDataSourceFactory = http
+                ExoPlayer.Builder(ctx)
+                    .setMediaSourceFactory(
+                        DefaultMediaSourceFactory(DefaultDataSource.Factory(ctx, http))
+                    )
+                    .build()
+            }
+
+            AndroidBackend.VLC -> VlcPlayer(ctx)
+        }
     }
     override val eventMap = EventMap(player)
 
@@ -77,13 +98,10 @@ class OmniPlayer : HybridOmniPlayerSpec() {
         metadata: com.margelo.nitro.omni.Metadata?,
         subtitles: Array<com.margelo.nitro.omni.Subtitle>
     ): MediaItem {
-        //        val headers = Bundle().apply {
-        //            putStringArrayList(
-        //                VlcPlayer.REQUEST_HEADER_NAMES_KEY,
-        //                VlcPlayer.REQUEST_HEADER_VALUES_KEY,
-        //                putLong(VlcPlayer.REQUEST_START_MS_KEY, (it.coerceAtLeast(0.0) * 1000.0).toLong())
-        //            }
-        //        }
+        // vlc only path (and it only supports a few headers :c)
+        val extras = if (src.headers.isEmpty()) null else Bundle(src.headers.size).apply {
+            for ((name, value) in src.headers) putString(name, value)
+        }
         return MediaItem.Builder()
             .setUri(src.uri)
             .setMimeType(src.mimeType)
@@ -108,7 +126,7 @@ class OmniPlayer : HybridOmniPlayerSpec() {
             .setRequestMetadata(
                 RequestMetadata.Builder()
                     .setMediaUri(src.uri.toUri())
-                    // .setExtras(headers)
+                    .apply { extras?.let { setExtras(it) } }
                     .build()
             )
             .build()
@@ -203,6 +221,8 @@ class OmniPlayer : HybridOmniPlayerSpec() {
                 return
             }
 
+            httpDataSourceFactory?.setDefaultRequestProperties(firstSrc.headers)
+
             val currentItem = buildMediaItem(firstSrc, value.metadata, value.subtitles)
             val mediaItems = mutableListOf<MediaItem>()
 

android/src/main/java/dev/zoriya/omni/OmniPlayerFactory.kt

@@ -2,13 +2,15 @@ package dev.zoriya.omni
 
 import android.util.Log
 import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.omni.AndroidBackend
 import com.margelo.nitro.omni.HybridOmniPlayerFactorySpec
 import com.margelo.nitro.omni.HybridOmniPlayerSpec
+import com.margelo.nitro.omni.PlayerBackend
 import com.margelo.nitro.omni.Source
 
 class OmniPlayerFactory(val context: ThemedReactContext) : HybridOmniPlayerFactorySpec() {
-    override fun createPlayer(props: Source?): HybridOmniPlayerSpec {
-        return OmniPlayer().apply {
+    override fun createPlayer(props: Source?, backend: PlayerBackend?): HybridOmniPlayerSpec {
+        return OmniPlayer(backend?.android ?: AndroidBackend.VLC).apply {
             source = props
         }
     }

android/src/main/java/dev/zoriya/omni/VlcPlayer.kt

@@ -5,6 +5,7 @@ import android.content.Context
 import android.media.AudioFocusRequest
 import android.media.AudioManager
 import android.os.Build
+import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import android.view.Surface
@@ -350,6 +351,7 @@ class VlcPlayer(ctx: Context) :
             if (!uri.isNullOrEmpty()) {
                 val media = Media(libVLC, uri.toUri())
                 media.setHWDecoderEnabled(true, false)
+                applyRequestHeaders(media, item.requestMetadata.extras)
 
                 item.localConfiguration?.subtitleConfigurations?.forEach { subtitle ->
                     media.addSlave(
@@ -382,6 +384,18 @@ class VlcPlayer(ctx: Context) :
         }
     }
 
+    // vlc doesn't allow arbitrary headers :c
+    private fun applyRequestHeaders(media: Media, extras: Bundle?) {
+        if (extras == null) return
+        for (name in extras.keySet()) {
+            val value = extras.getString(name) ?: continue
+            when (name.lowercase()) {
+                "user-agent" -> media.addOption(":http-user-agent=$value")
+                "referer", "referrer" -> media.addOption(":http-referrer=$value")
+            }
+        }
+    }
+
     override fun addMediaItems(
         p0: Int,
         p1: List<MediaItem>

bun.lock

@@ -12,6 +12,7 @@
       },
       "devDependencies": {
         "@biomejs/biome": "2.5.3",
+        "@types/chromecast-caf-sender": "^1.0.11",
         "@types/jest": "^30.0.0",
         "@types/react": "19.2.17",
         "nitrogen": "0.36.1",
@@ -596,6 +597,10 @@
 
     "@types/bonjour": ["@types/bonjour@3.5.13", "", { "dependencies": { "@types/node": "*" } }, "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ=="],
 
+    "@types/chrome": ["@types/chrome@0.2.2", "", { "dependencies": { "@types/filesystem": "*", "@types/har-format": "*" } }, "sha512-8rSMZ4cvo2xmaSyQg0sN5yRL7oiDkntLoiHxUhfwQnv1mvnkrdoZ25SlNrKWmYKaeP50WvrfWj1pmc02+U9KKw=="],
+
+    "@types/chromecast-caf-sender": ["@types/chromecast-caf-sender@1.0.11", "", { "dependencies": { "@types/chrome": "*" } }, "sha512-Pv3xvNYtxD/cTM/tKfuZRlLasvpxAm+CFni0GJd6Cp8XgiZS9g9tMZkR1uymsi5fIFv057SZKKAWVFFgy7fJtw=="],
+
     "@types/connect": ["@types/connect@3.4.38", "", { "dependencies": { "@types/node": "*" } }, "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug=="],
 
     "@types/connect-history-api-fallback": ["@types/connect-history-api-fallback@1.5.4", "", { "dependencies": { "@types/express-serve-static-core": "*", "@types/node": "*" } }, "sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw=="],
@@ -606,6 +611,12 @@
 
     "@types/express-serve-static-core": ["@types/express-serve-static-core@4.19.8", "", { "dependencies": { "@types/node": "*", "@types/qs": "*", "@types/range-parser": "*", "@types/send": "*" } }, "sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA=="],
 
+    "@types/filesystem": ["@types/filesystem@0.0.36", "", { "dependencies": { "@types/filewriter": "*" } }, "sha512-vPDXOZuannb9FZdxgHnqSwAG/jvdGM8Wq+6N4D/d80z+D4HWH+bItqsZaVRQykAn6WEVeEkLm2oQigyHtgb0RA=="],
+
+    "@types/filewriter": ["@types/filewriter@0.0.33", "", {}, "sha512-xFU8ZXTw4gd358lb2jw25nxY9QAgqn2+bKKjKOYfNCzN4DKCFetK7sPtrlpg66Ywe3vWY9FNxprZawAh9wfJ3g=="],
+
+    "@types/har-format": ["@types/har-format@1.2.16", "", {}, "sha512-fluxdy7ryD3MV6h8pTfTYpy/xQzCFC7m89nOH9y94cNqJ1mDIDPut7MnRHI3F6qRmh/cT2fUjG1MLdCNb4hE9A=="],
+
     "@types/html-minifier-terser": ["@types/html-minifier-terser@6.1.0", "", {}, "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg=="],
 
     "@types/http-errors": ["@types/http-errors@2.0.5", "", {}, "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg=="],

nitrogen/generated/android/c++/JAndroidBackend.hpp

@@ -0,0 +1,58 @@
+///
+/// JAndroidBackend.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AndroidBackend.hpp"
+
+namespace margelo::nitro::omni {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidBackend" and the Kotlin enum "AndroidBackend".
+   */
+  struct JAndroidBackend final: public jni::JavaClass<JAndroidBackend> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/omni/AndroidBackend;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidBackend.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidBackend toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidBackend>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidBackend> fromCpp(AndroidBackend value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AndroidBackend::VLC:
+          static const auto fieldVLC = clazz->getStaticField<JAndroidBackend>("VLC");
+          return clazz->getStaticFieldValue(fieldVLC);
+        case AndroidBackend::EXOPLAYER:
+          static const auto fieldEXOPLAYER = clazz->getStaticField<JAndroidBackend>("EXOPLAYER");
+          return clazz->getStaticFieldValue(fieldEXOPLAYER);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::omni

nitrogen/generated/android/c++/JHybridOmniPlayerFactorySpec.cpp

@@ -19,6 +19,10 @@ namespace margelo::nitro::omni { struct Subtitle; }
 namespace margelo::nitro::omni { struct Metadata; }
 // Forward declaration of `MixAudioMode` to properly resolve imports.
 namespace margelo::nitro::omni { enum class MixAudioMode; }
+// Forward declaration of `PlayerBackend` to properly resolve imports.
+namespace margelo::nitro::omni { struct PlayerBackend; }
+// Forward declaration of `AndroidBackend` to properly resolve imports.
+namespace margelo::nitro::omni { enum class AndroidBackend; }
 
 #include <memory>
 #include "HybridOmniPlayerSpec.hpp"
@@ -37,6 +41,10 @@ namespace margelo::nitro::omni { enum class MixAudioMode; }
 #include "JMetadata.hpp"
 #include "MixAudioMode.hpp"
 #include "JMixAudioMode.hpp"
+#include "PlayerBackend.hpp"
+#include "JPlayerBackend.hpp"
+#include "AndroidBackend.hpp"
+#include "JAndroidBackend.hpp"
 
 namespace margelo::nitro::omni {
 
@@ -71,9 +79,9 @@ namespace margelo::nitro::omni {
   
 
   // Methods
-  std::shared_ptr<HybridOmniPlayerSpec> JHybridOmniPlayerFactorySpec::createPlayer(const std::optional<Source>& props) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridOmniPlayerSpec::JavaPart>(jni::alias_ref<JSource> /* props */)>("createPlayer");
-    auto __result = method(_javaPart, props.has_value() ? JSource::fromCpp(props.value()) : nullptr);
+  std::shared_ptr<HybridOmniPlayerSpec> JHybridOmniPlayerFactorySpec::createPlayer(const std::optional<Source>& props, const std::optional<PlayerBackend>& backend) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridOmniPlayerSpec::JavaPart>(jni::alias_ref<JSource> /* props */, jni::alias_ref<JPlayerBackend> /* backend */)>("createPlayer");
+    auto __result = method(_javaPart, props.has_value() ? JSource::fromCpp(props.value()) : nullptr, backend.has_value() ? JPlayerBackend::fromCpp(backend.value()) : nullptr);
     return __result->getJHybridOmniPlayerSpec();
   }
 

nitrogen/generated/android/c++/JHybridOmniPlayerFactorySpec.hpp

@@ -54,7 +54,7 @@ namespace margelo::nitro::omni {
 
   public:
     // Methods
-    std::shared_ptr<HybridOmniPlayerSpec> createPlayer(const std::optional<Source>& props) override;
+    std::shared_ptr<HybridOmniPlayerSpec> createPlayer(const std::optional<Source>& props, const std::optional<PlayerBackend>& backend) override;
 
   private:
     jni::global_ref<JHybridOmniPlayerFactorySpec::JavaPart> _javaPart;

nitrogen/generated/android/c++/JPlayerBackend.hpp

@@ -0,0 +1,59 @@
+///
+/// JPlayerBackend.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "PlayerBackend.hpp"
+
+#include "AndroidBackend.hpp"
+#include "JAndroidBackend.hpp"
+#include <optional>
+
+namespace margelo::nitro::omni {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "PlayerBackend" and the Kotlin data class "PlayerBackend".
+   */
+  struct JPlayerBackend final: public jni::JavaClass<JPlayerBackend> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/omni/PlayerBackend;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct PlayerBackend by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PlayerBackend toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAndroid = clazz->getField<JAndroidBackend>("android");
+      jni::local_ref<JAndroidBackend> android = this->getFieldValue(fieldAndroid);
+      return PlayerBackend(
+        android != nullptr ? std::make_optional(android->toCpp()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JPlayerBackend::javaobject> fromCpp(const PlayerBackend& value) {
+      using JSignature = JPlayerBackend(jni::alias_ref<JAndroidBackend>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.android.has_value() ? JAndroidBackend::fromCpp(value.android.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::omni

nitrogen/generated/android/kotlin/com/margelo/nitro/omni/AndroidBackend.kt

@@ -0,0 +1,23 @@
+///
+/// AndroidBackend.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.omni
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "AndroidBackend".
+ */
+@DoNotStrip
+@Keep
+enum class AndroidBackend(@DoNotStrip @Keep val value: Int) {
+  VLC(0),
+  EXOPLAYER(1);
+
+  companion object
+}

nitrogen/generated/android/kotlin/com/margelo/nitro/omni/HybridOmniPlayerFactorySpec.kt

@@ -30,7 +30,7 @@ abstract class HybridOmniPlayerFactorySpec: HybridObject() {
   // Methods
   @DoNotStrip
   @Keep
-  abstract fun createPlayer(props: Source?): HybridOmniPlayerSpec
+  abstract fun createPlayer(props: Source?, backend: PlayerBackend?): HybridOmniPlayerSpec
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

nitrogen/generated/android/kotlin/com/margelo/nitro/omni/PlayerBackend.kt

@@ -0,0 +1,51 @@
+///
+/// PlayerBackend.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.omni
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "PlayerBackend".
+ */
+@DoNotStrip
+@Keep
+data class PlayerBackend(
+  @DoNotStrip
+  @Keep
+  val android: AndroidBackend?
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is PlayerBackend) return false
+    return Objects.deepEquals(this.android, other.android)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      android
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(android: AndroidBackend?): PlayerBackend {
+      return PlayerBackend(android)
+    }
+  }
+}

nitrogen/generated/shared/c++/AndroidBackend.hpp

@@ -0,0 +1,76 @@
+///
+/// AndroidBackend.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::omni {
+
+  /**
+   * An enum which can be represented as a JavaScript union (AndroidBackend).
+   */
+  enum class AndroidBackend {
+    VLC      SWIFT_NAME(vlc) = 0,
+    EXOPLAYER      SWIFT_NAME(exoplayer) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::omni
+
+namespace margelo::nitro {
+
+  // C++ AndroidBackend <> JS AndroidBackend (union)
+  template <>
+  struct JSIConverter<margelo::nitro::omni::AndroidBackend> final {
+    static inline margelo::nitro::omni::AndroidBackend fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("vlc"): return margelo::nitro::omni::AndroidBackend::VLC;
+        case hashString("exoplayer"): return margelo::nitro::omni::AndroidBackend::EXOPLAYER;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum AndroidBackend - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::omni::AndroidBackend arg) {
+      switch (arg) {
+        case margelo::nitro::omni::AndroidBackend::VLC: return JSIConverter<std::string>::toJSI(runtime, "vlc");
+        case margelo::nitro::omni::AndroidBackend::EXOPLAYER: return JSIConverter<std::string>::toJSI(runtime, "exoplayer");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert AndroidBackend to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("vlc"):
+        case hashString("exoplayer"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

nitrogen/generated/shared/c++/HybridOmniPlayerFactorySpec.hpp

@@ -17,11 +17,14 @@
 namespace margelo::nitro::omni { class HybridOmniPlayerSpec; }
 // Forward declaration of `Source` to properly resolve imports.
 namespace margelo::nitro::omni { struct Source; }
+// Forward declaration of `PlayerBackend` to properly resolve imports.
+namespace margelo::nitro::omni { struct PlayerBackend; }
 
 #include <memory>
 #include "HybridOmniPlayerSpec.hpp"
 #include "Source.hpp"
 #include <optional>
+#include "PlayerBackend.hpp"
 
 namespace margelo::nitro::omni {
 
@@ -54,7 +57,7 @@ namespace margelo::nitro::omni {
 
     public:
       // Methods
-      virtual std::shared_ptr<HybridOmniPlayerSpec> createPlayer(const std::optional<Source>& props) = 0;
+      virtual std::shared_ptr<HybridOmniPlayerSpec> createPlayer(const std::optional<Source>& props, const std::optional<PlayerBackend>& backend) = 0;
 
     protected:
       // Hybrid Setup

nitrogen/generated/shared/c++/PlayerBackend.hpp

@@ -0,0 +1,85 @@
+///
+/// PlayerBackend.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `AndroidBackend` to properly resolve imports.
+namespace margelo::nitro::omni { enum class AndroidBackend; }
+
+#include "AndroidBackend.hpp"
+#include <optional>
+
+namespace margelo::nitro::omni {
+
+  /**
+   * A struct which can be represented as a JavaScript object (PlayerBackend).
+   */
+  struct PlayerBackend final {
+  public:
+    std::optional<AndroidBackend> android     SWIFT_PRIVATE;
+
+  public:
+    PlayerBackend() = default;
+    explicit PlayerBackend(std::optional<AndroidBackend> android): android(android) {}
+
+  public:
+    friend bool operator==(const PlayerBackend& lhs, const PlayerBackend& rhs) = default;
+  };
+
+} // namespace margelo::nitro::omni
+
+namespace margelo::nitro {
+
+  // C++ PlayerBackend <> JS PlayerBackend (object)
+  template <>
+  struct JSIConverter<margelo::nitro::omni::PlayerBackend> final {
+    static inline margelo::nitro::omni::PlayerBackend fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::omni::PlayerBackend(
+        JSIConverter<std::optional<margelo::nitro::omni::AndroidBackend>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "android")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::omni::PlayerBackend& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "android"), JSIConverter<std::optional<margelo::nitro::omni::AndroidBackend>>::toJSI(runtime, arg.android));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<margelo::nitro::omni::AndroidBackend>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "android")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package.json

@@ -69,6 +69,7 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.5.3",
+		"@types/chromecast-caf-sender": "^1.0.11",
 		"@types/jest": "^30.0.0",
 		"@types/react": "19.2.17",
 		"nitrogen": "0.36.1",

src/index.ts

@@ -2,9 +2,11 @@ export { useEvent, usePlayerState } from "./events";
 export { OmniProvider, usePlayer } from "./provider";
 export type { OmniEvents } from "./types/events";
 export type {
+	AndroidBackend,
 	CastStatus,
 	OmniPlayer,
 	OmniPlayerState,
+	PlayerBackend,
 	PlayerStatus,
 	Rendition,
 	Track,

src/player.web.tsx

@@ -244,26 +244,22 @@ export class WebOmniPlayer implements OmniPlayer {
 		this.setOverlaySubtitle(overlay ?? null);
 
 		if (this.castStatus === "connected") {
-			try {
-				// if the cast receiver handles overlay subtitles like us, send this message.
-				const ctx = (
-					window as unknown as {
-						// biome-ignore lint/suspicious/noExplicitAny: cast sender SDK global
-						cast?: { framework?: { CastContext?: { getInstance(): any } } };
-					}
-				).cast?.framework?.CastContext?.getInstance?.();
-				ctx
-					?.getCurrentSession?.()
-					?.sendMessage("urn:x-cast:dev.zoriya.omni", {
-						subtitle: overlay?.id ?? null,
-					})
-					?.catch?.(() => {});
-			} catch {
-				// no active cast session / sender SDK not loaded
-			}
+			window.cast.framework.CastContext.getInstance()
+				.getCurrentSession()
+				?.sendMessage("urn:x-cast:dev.zoriya.omni", {
+					subtitle: overlay?.id ?? null,
+				})
+				.catch(() => {});
 		}
 	}
 
+	// To be used on a callback of a chromecast session, it only changes the local state
+	applyRemoteSubtitle(id: string | null): void {
+		this.setOverlaySubtitle(
+			id ? (this.overlaySubtitles.find((s) => s.id === id) ?? null) : null,
+		);
+	}
+
 	private setOverlaySubtitle(sub: Subtitle | null): void {
 		if (this.overlaySubtitle === sub) return;
 		this.overlaySubtitle = sub;

src/provider.tsx

@@ -1,7 +1,7 @@
 import { createContext, type ReactNode, useContext, useEffect } from "react";
 import { NitroModules } from "react-native-nitro-modules";
 import type { OmniPlayerFactory } from "./specs/omni-player.nitro";
-import type { OmniPlayer } from "./types/player";
+import type { OmniPlayer, PlayerBackend } from "./types/player";
 import type { CastOptions, Source } from "./types/source";
 import { useLazyRef } from "./utils/lazy-ref";
 
@@ -13,15 +13,19 @@ const PlayerCtx = createContext<OmniPlayer>(null!);
 export const OmniProvider = ({
 	children,
 	source,
+	backend = { android: "vlc" },
 	showNotification = false,
 	cast: _,
 }: {
 	source?: Source;
 	cast?: CastOptions;
+	backend?: PlayerBackend;
 	children: ReactNode;
 	showNotification?: boolean;
 }) => {
-	const player = useLazyRef(() => ProviderFactory.createPlayer(source));
+	const player = useLazyRef(() =>
+		ProviderFactory.createPlayer(source, backend),
+	);
 
 	useEffect(() => {
 		player.source = source;

src/provider.web.tsx

@@ -8,7 +8,7 @@ import {
 	useRef,
 } from "react";
 import { WebOmniPlayer } from "./player.web";
-import type { OmniPlayer } from "./types/player";
+import type { OmniPlayer, PlayerBackend } from "./types/player";
 import type { CastOptions, Source } from "./types/source";
 import { useLazyRef } from "./utils/lazy-ref";
 
@@ -20,10 +20,13 @@ export const OmniProvider = ({
 	children,
 	source,
 	cast,
+	// Web always uses video.js; accepted for API parity with native.
+	backend: _backend,
 	showNotification = false,
 }: {
 	source?: Source;
 	cast?: CastOptions;
+	backend?: PlayerBackend;
 	children: ReactNode;
 	showNotification?: boolean;
 }) => {
@@ -72,6 +75,36 @@ const PlayerInitializer = ({
 		player.showNotification = showNotification;
 	}, [showNotification]);
 
+	useEffect(() => {
+		let media: chrome.cast.media.Media | null = null;
+
+		const onMediaUpdate = () => {
+			const data = media?.customData as { subtitle?: unknown } | undefined;
+			player.applyRemoteSubtitle(
+				typeof data?.subtitle === "string" ? data.subtitle : null,
+			);
+		};
+
+		const syncMedia = () => {
+			const next =
+				window.cast.framework.CastContext.getInstance()
+					.getCurrentSession()
+					?.getMediaSession() ?? null;
+			if (next === media) return;
+			media?.removeUpdateListener(onMediaUpdate);
+			media = next;
+			media?.addUpdateListener(onMediaUpdate);
+			onMediaUpdate();
+		};
+
+		const unsubscribe = store.subscribe(syncMedia);
+		syncMedia();
+		return () => {
+			unsubscribe();
+			media?.removeUpdateListener(onMediaUpdate);
+		};
+	}, [store]);
+
 	return <PlayerCtx.Provider value={player}>{children}</PlayerCtx.Provider>;
 };
 

src/specs/omni-player.nitro.ts

@@ -3,6 +3,7 @@ import type { OmniEvents } from "../types/events";
 import type {
 	OmniPlayerState,
 	OmniPlayer as OmniPlayerT,
+	PlayerBackend,
 	PlayerStatus,
 } from "../types/player";
 import type { Source } from "../types/source";
@@ -59,5 +60,5 @@ export interface OmniPlayer
 }
 
 export interface OmniPlayerFactory extends HybridObject<{ android: "kotlin" }> {
-	createPlayer(props?: Source): OmniPlayer;
+	createPlayer(props?: Source, backend?: PlayerBackend): OmniPlayer;
 }

src/types/player.ts

@@ -64,3 +64,9 @@ export interface Rendition {
 	readonly bitrate: number;
 	readonly selected: boolean;
 }
+
+export type AndroidBackend = "vlc" | "exoplayer";
+
+export interface PlayerBackend {
+	android?: AndroidBackend;
+}

tsconfig.json

@@ -17,6 +17,7 @@
 		"skipLibCheck": true,
 		"strict": true,
 		"target": "esnext",
+		"types": ["chromecast-caf-sender"],
 		"verbatimModuleSyntax": true
 	},
 	"exclude": [