bitmovin-player-react-native 1.0.0-alpha.0 → 1.0.0-alpha.2

package/ios/PlayerModule.swift

@@ -2,8 +2,6 @@ import BitmovinPlayer
 import ExpoModulesCore
 
 public class PlayerModule: Module {
-    private var players: Registry<Player> = [:]
-
     // swiftlint:disable:next function_body_length
     public func definition() -> ModuleDefinition {
         Name("PlayerModule")
@@ -12,117 +10,121 @@ public class PlayerModule: Module {
             // Destroy all players on the main thread when the module is deallocated.
             // This is necessary when the IMA SDK is present in the app,
             // as it may crash if the players are destroyed on a background thread.
-            DispatchQueue.main.async { [players] in
-                players.values.forEach { $0.destroy() }
+            DispatchQueue.main.async {
+                PlayerRegistry.getAllPlayers().forEach { $0.destroy() }
+                PlayerRegistry.clear()
             }
         }
-        AsyncFunction("play") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.play()
+        AsyncFunction("play") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.play()
         }.runOnQueue(.main)
-        AsyncFunction("pause") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.pause()
+        AsyncFunction("pause") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.pause()
         }.runOnQueue(.main)
-        AsyncFunction("mute") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.mute()
+        AsyncFunction("mute") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.mute()
         }.runOnQueue(.main)
-        AsyncFunction("unmute") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.unmute()
+        AsyncFunction("unmute") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.unmute()
         }.runOnQueue(.main)
-        AsyncFunction("seek") { [weak self] (nativeId: NativeId, time: Double) in
-            self?.players[nativeId]?.seek(time: time)
+        AsyncFunction("seek") { (nativeId: NativeId, time: Double) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.seek(time: time)
         }.runOnQueue(.main)
-        AsyncFunction("timeShift") { [weak self] (nativeId: NativeId, offset: Double) in
-            self?.players[nativeId]?.timeShift = offset
+        AsyncFunction("timeShift") { (nativeId: NativeId, offset: Double) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.timeShift = offset
         }.runOnQueue(.main)
-        AsyncFunction("destroy") { [weak self] (nativeId: NativeId) in
-            if let player = self?.players[nativeId] {
+        AsyncFunction("destroy") { (nativeId: NativeId) in
+            if let player = PlayerRegistry.getPlayer(nativeId: nativeId) {
                 player.destroy()
-                self?.players[nativeId] = nil
+                PlayerRegistry.unregister(nativeId: nativeId)
             }
         }.runOnQueue(.main)
-        AsyncFunction("setVolume") { [weak self] (nativeId: NativeId, volume: Int) in
-            self?.players[nativeId]?.volume = volume
+        AsyncFunction("setVolume") { (nativeId: NativeId, volume: Int) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.volume = volume
         }.runOnQueue(.main)
-        AsyncFunction("unload") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.unload()
+        AsyncFunction("unload") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.unload()
         }.runOnQueue(.main)
-        AsyncFunction("setPlaybackSpeed") { [weak self] (nativeId: NativeId, playbackSpeed: Float) in
-            self?.players[nativeId]?.playbackSpeed = playbackSpeed
+        AsyncFunction("setPlaybackSpeed") { (nativeId: NativeId, playbackSpeed: Float) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.playbackSpeed = playbackSpeed
         }.runOnQueue(.main)
-        AsyncFunction("setMaxSelectableBitrate") { [weak self] (nativeId: NativeId, maxSelectableBitrate: Int) in
-            self?.players[nativeId]?.maxSelectableBitrate = UInt(maxSelectableBitrate)
+        AsyncFunction("setMaxSelectableBitrate") { (nativeId: NativeId, maxSelectableBitrate: Int) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.maxSelectableBitrate = UInt(maxSelectableBitrate)
         }.runOnQueue(.main)
-        AsyncFunction("getVolume") { [weak self] (nativeId: NativeId) -> Int? in
-            self?.players[nativeId]?.volume
+        AsyncFunction("getVolume") { (nativeId: NativeId) -> Int? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.volume
         }.runOnQueue(.main)
-        AsyncFunction("currentTime") { [weak self] (nativeId: NativeId, mode: String?) -> Double? in
-            let player = self?.players[nativeId]
+        AsyncFunction("currentTime") { (nativeId: NativeId, mode: String?) -> Double? in
+            let player = PlayerRegistry.getPlayer(nativeId: nativeId)
             if let mode {
                 return player?.currentTime(RCTConvert.timeMode(mode))
             }
             return player?.currentTime
         }.runOnQueue(.main)
-        AsyncFunction("isPlaying") { [weak self] (nativeId: NativeId) -> Bool? in
-            self?.players[nativeId]?.isPlaying
+        AsyncFunction("isPlaying") { (nativeId: NativeId) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isPlaying
         }.runOnQueue(.main)
-        AsyncFunction("isPaused") { [weak self] (nativeId: NativeId) -> Bool? in
-            self?.players[nativeId]?.isPaused
+        AsyncFunction("isPaused") { (nativeId: NativeId) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isPaused
         }.runOnQueue(.main)
-        AsyncFunction("duration") { [weak self] (nativeId: NativeId) -> Double? in
-            self?.players[nativeId]?.duration
+        AsyncFunction("duration") { (nativeId: NativeId) -> Double? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.duration
         }.runOnQueue(.main)
-        AsyncFunction("isMuted") { [weak self] (nativeId: NativeId) -> Bool? in
-            self?.players[nativeId]?.isMuted
+        AsyncFunction("isMuted") { (nativeId: NativeId) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isMuted
         }.runOnQueue(.main)
-        AsyncFunction("getTimeShift") { [weak self] (nativeId: NativeId) -> Double? in
-            self?.players[nativeId]?.timeShift
+        AsyncFunction("getTimeShift") { (nativeId: NativeId) -> Double? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.timeShift
         }.runOnQueue(.main)
-        AsyncFunction("isLive") { [weak self] (nativeId: NativeId) -> Bool? in
-            self?.players[nativeId]?.isLive
+        AsyncFunction("isLive") { (nativeId: NativeId) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isLive
         }.runOnQueue(.main)
-        AsyncFunction("getMaxTimeShift") { [weak self] (nativeId: NativeId) -> Double? in
-            self?.players[nativeId]?.maxTimeShift
+        AsyncFunction("getMaxTimeShift") { (nativeId: NativeId) -> Double? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.maxTimeShift
         }.runOnQueue(.main)
-        AsyncFunction("getPlaybackSpeed") { [weak self] (nativeId: NativeId) -> Float? in
-            self?.players[nativeId]?.playbackSpeed
+        AsyncFunction("getPlaybackSpeed") { (nativeId: NativeId) -> Float? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.playbackSpeed
         }.runOnQueue(.main)
-        AsyncFunction("isAd") { [weak self] (nativeId: NativeId) -> Bool? in
-            self?.players[nativeId]?.isAd
+        AsyncFunction("isAd") { (nativeId: NativeId) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isAd
         }.runOnQueue(.main)
-        AsyncFunction("canPlayAtPlaybackSpeed") { [weak self] (nativeId: NativeId, playbackSpeed: Float) -> Bool? in
-            self?.players[nativeId]?.canPlay(atPlaybackSpeed: playbackSpeed)
+        AsyncFunction("canPlayAtPlaybackSpeed") { (nativeId: NativeId, playbackSpeed: Float) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.canPlay(atPlaybackSpeed: playbackSpeed)
         }.runOnQueue(.main)
-        AsyncFunction("getAudioTrack") { [weak self] (nativeId: NativeId) -> [String: Any]? in
-            RCTConvert.audioTrackJson(self?.players[nativeId]?.audio)
+        AsyncFunction("getAudioTrack") { (nativeId: NativeId) -> [String: Any]? in
+            RCTConvert.audioTrackJson(PlayerRegistry.getPlayer(nativeId: nativeId)?.audio)
         }.runOnQueue(.main)
-        AsyncFunction("getAvailableAudioTracks") { [weak self] (nativeId: NativeId) -> [[String: Any]] in
-            self?.players[nativeId]?.availableAudio.compactMap { RCTConvert.audioTrackJson($0) } ?? []
+        AsyncFunction("getAvailableAudioTracks") { (nativeId: NativeId) -> [[String: Any]] in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?
+                .availableAudio.compactMap { RCTConvert.audioTrackJson($0) } ?? []
         }.runOnQueue(.main)
-        AsyncFunction("setAudioTrack") { [weak self] (nativeId: NativeId, trackIdentifier: String) in
-            self?.players[nativeId]?.setAudio(trackIdentifier: trackIdentifier)
+        AsyncFunction("setAudioTrack") { (nativeId: NativeId, trackIdentifier: String) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.setAudio(trackIdentifier: trackIdentifier)
         }.runOnQueue(.main)
-        AsyncFunction("getSubtitleTrack") { [weak self] (nativeId: NativeId) -> [String: Any]? in
-            RCTConvert.subtitleTrackJson(self?.players[nativeId]?.subtitle)
+        AsyncFunction("getSubtitleTrack") { (nativeId: NativeId) -> [String: Any]? in
+            RCTConvert.subtitleTrackJson(PlayerRegistry.getPlayer(nativeId: nativeId)?.subtitle)
         }.runOnQueue(.main)
-        AsyncFunction("getAvailableSubtitles") { [weak self] (nativeId: NativeId) -> [[String: Any]] in
-            self?.players[nativeId]?.availableSubtitles.compactMap { RCTConvert.subtitleTrackJson($0) } ?? []
+        AsyncFunction("getAvailableSubtitles") { (nativeId: NativeId) -> [[String: Any]] in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?
+                .availableSubtitles.compactMap { RCTConvert.subtitleTrackJson($0) } ?? []
         }.runOnQueue(.main)
-        AsyncFunction("setSubtitleTrack") { [weak self] (nativeId: NativeId, trackIdentifier: String?) in
-            self?.players[nativeId]?.setSubtitle(trackIdentifier: trackIdentifier)
+        AsyncFunction("setSubtitleTrack") { (nativeId: NativeId, trackIdentifier: String?) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.setSubtitle(trackIdentifier: trackIdentifier)
         }.runOnQueue(.main)
 
-        AsyncFunction("getVideoQuality") { [weak self] (nativeId: NativeId) -> [String: Any]? in
-            RCTConvert.toJson(videoQuality: self?.players[nativeId]?.videoQuality)
+        AsyncFunction("getVideoQuality") { (nativeId: NativeId) -> [String: Any]? in
+            RCTConvert.toJson(videoQuality: PlayerRegistry.getPlayer(nativeId: nativeId)?.videoQuality)
         }.runOnQueue(.main)
-        AsyncFunction("getAvailableVideoQualities") { [weak self] (nativeId: NativeId) -> [[String: Any]] in
-            self?.players[nativeId]?.availableVideoQualities.compactMap { RCTConvert.toJson(videoQuality: $0) } ?? []
+        AsyncFunction("getAvailableVideoQualities") { (nativeId: NativeId) -> [[String: Any]] in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?
+                .availableVideoQualities.compactMap { RCTConvert.toJson(videoQuality: $0) } ?? []
         }.runOnQueue(.main)
-        AsyncFunction("getThumbnail") { [weak self] (nativeId: NativeId, time: Double) -> [String: Any]? in
-            RCTConvert.toJson(thumbnail: self?.players[nativeId]?.thumbnail(forTime: time))
+        AsyncFunction("getThumbnail") { (nativeId: NativeId, time: Double) -> [String: Any]? in
+            RCTConvert.toJson(thumbnail: PlayerRegistry.getPlayer(nativeId: nativeId)?.thumbnail(forTime: time))
         }.runOnQueue(.main)
         AsyncFunction("loadOfflineContent") { [weak self] (nativeId: NativeId, bridgeId: String, options: [String: Any]?) in // swiftlint:disable:this line_length
             #if os(iOS)
-            guard let player = self?.players[nativeId],
+            guard let player = PlayerRegistry.getPlayer(nativeId: nativeId),
                   let offlineModule = self?.appContext?.moduleRegistry.get(OfflineModule.self),
                   let offlineContentManagerBridge = offlineModule.retrieve(bridgeId) else { return }
             let optionsDictionary = options ?? [:]
@@ -134,55 +136,57 @@ public class PlayerModule: Module {
             player.load(sourceConfig: offlineSourceConfig)
             #endif
         }.runOnQueue(.main)
-        AsyncFunction("scheduleAd") { [weak self] (nativeId: NativeId, adItemJson: [String: Any]) in
+        AsyncFunction("scheduleAd") { (nativeId: NativeId, adItemJson: [String: Any]) in
             guard let adItem = RCTConvert.adItem(adItemJson) else { return }
-            self?.players[nativeId]?.scheduleAd(adItem: adItem)
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.scheduleAd(adItem: adItem)
         }.runOnQueue(.main)
-        AsyncFunction("isAirPlayActive") { [weak self] (nativeId: NativeId) -> Bool? in
+        AsyncFunction("isAirPlayActive") { (nativeId: NativeId) -> Bool? in
             #if os(iOS)
-            return self?.players[nativeId]?.isAirPlayActive
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isAirPlayActive
             #else
-            return nil
+            nil
             #endif
         }.runOnQueue(.main)
-        AsyncFunction("isAirPlayAvailable") { [weak self] (nativeId: NativeId) -> Bool? in
+        AsyncFunction("isAirPlayAvailable") { (nativeId: NativeId) -> Bool? in
             #if os(iOS)
-            return self?.players[nativeId]?.allowsAirPlay
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.allowsAirPlay
             #else
-            return nil
+            nil
             #endif
         }.runOnQueue(.main)
-        AsyncFunction("isCastAvailable") { [weak self] (nativeId: NativeId) -> Bool? in
-            self?.players[nativeId]?.isCastAvailable
+        AsyncFunction("isCastAvailable") { (nativeId: NativeId) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isCastAvailable
         }.runOnQueue(.main)
-        AsyncFunction("isCasting") { [weak self] (nativeId: NativeId) -> Bool? in
-            self?.players[nativeId]?.isCasting
+        AsyncFunction("isCasting") { (nativeId: NativeId) -> Bool? in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.isCasting
         }.runOnQueue(.main)
-        AsyncFunction("castVideo") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.castVideo()
+        AsyncFunction("castVideo") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.castVideo()
         }.runOnQueue(.main)
-        AsyncFunction("castStop") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.castStop()
+        AsyncFunction("castStop") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.castStop()
         }.runOnQueue(.main)
-        AsyncFunction("skipAd") { [weak self] (nativeId: NativeId) in
-            self?.players[nativeId]?.skipAd()
+        AsyncFunction("skipAd") { (nativeId: NativeId) in
+            PlayerRegistry.getPlayer(nativeId: nativeId)?.skipAd()
         }.runOnQueue(.main)
         AsyncFunction(
             "initializeWithConfig"
         ) { [weak self] (nativeId: NativeId, config: [String: Any]?, networkNativeId: NativeId?, _: String?) in // swiftlint:disable:this line_length
-            guard self?.players[nativeId] == nil, let playerConfig = RCTConvert.playerConfig(config) else { return }
+            guard !PlayerRegistry.hasPlayer(nativeId: nativeId),
+                  let playerConfig = RCTConvert.playerConfig(config) else { return }
             #if os(iOS)
             self?.setupRemoteControlConfig(playerConfig.remoteControlConfig)
             #endif
             if let networkNativeId, let networkConfig = self?.setupNetworkConfig(nativeId: networkNativeId) {
                 playerConfig.networkConfig = networkConfig
             }
-            self?.players[nativeId] = PlayerFactory.create(playerConfig: playerConfig)
+            let player = PlayerFactory.create(playerConfig: playerConfig)
+            PlayerRegistry.register(player: player, nativeId: nativeId)
         }.runOnQueue(.main)
         AsyncFunction(
             "initializeWithAnalyticsConfig"
         ) { [weak self] (nativeId: NativeId, analyticsConfig: [String: Any]?, config: [String: Any]?, networkNativeId: NativeId?, _: String?) in // swiftlint:disable:this line_length
-            guard self?.players[nativeId] == nil,
+            guard !PlayerRegistry.hasPlayer(nativeId: nativeId),
                   let playerConfig = RCTConvert.playerConfig(config),
                   let analyticsConfig = RCTConvert.analyticsConfig(analyticsConfig) else { return } // swiftlint:disable:this line_length
             #if os(iOS)
@@ -192,14 +196,15 @@ public class PlayerModule: Module {
                 playerConfig.networkConfig = networkConfig
             }
             let defaultMetadata = RCTConvert.analyticsDefaultMetadataFromAnalyticsConfig(analyticsConfig)
-            self?.players[nativeId] = PlayerFactory.create(
+            let player = PlayerFactory.create(
                 playerConfig: playerConfig,
                 analyticsConfig: analyticsConfig,
                 defaultMetadata: defaultMetadata ?? DefaultMetadata()
             )
+            PlayerRegistry.register(player: player, nativeId: nativeId)
         }.runOnQueue(.main)
         AsyncFunction("loadSource") { [weak self] (nativeId: NativeId, sourceNativeId: NativeId) in
-            guard let player = self?.players[nativeId],
+            guard let player = PlayerRegistry.getPlayer(nativeId: nativeId),
                   let sourceModule = self?.appContext?.moduleRegistry.get(SourceModule.self), // swiftlint:disable:this line_length
                   let source = sourceModule.retrieve(sourceNativeId) else { return }
             player.load(source: source)
@@ -209,7 +214,7 @@ public class PlayerModule: Module {
     /// This needs to stay stable to maintain compatibility for cross-module access..
     @objc
     public func retrieve(_ nativeId: NativeId) -> Player? {
-        players[nativeId]
+        PlayerRegistry.getPlayer(nativeId: nativeId)
     }
 
     private func setupRemoteControlConfig(_ remoteControlConfig: RemoteControlConfig) {

package/ios/PlayerRegistry.swift

@@ -0,0 +1,88 @@
+import BitmovinPlayer
+import ExpoModulesCore
+
+/**
+ * Global registry for Player instances that allows static access from anywhere in native code
+ * without requiring access to the PlayerModule instance or Expo runtime.
+ */
+public class PlayerRegistry {
+    private static let shared = PlayerRegistry()
+    private var players: Registry<Player> = [:]
+    private let queue = DispatchQueue(label: "PlayerRegistry", attributes: .concurrent)
+
+    private init() {}
+
+    /**
+     * Register a player instance with the given native ID.
+     */
+    public static func register(player: Player, nativeId: NativeId) {
+        shared.queue.async(flags: .barrier) {
+            shared.players[nativeId] = player
+        }
+    }
+
+    /**
+     * Unregister a player instance with the given native ID.
+     */
+    public static func unregister(nativeId: NativeId) {
+        shared.queue.async(flags: .barrier) {
+            shared.players[nativeId] = nil
+        }
+    }
+
+    /**
+     * Get a player instance by native ID.
+     * Returns nil if no player is registered with the given ID.
+     */
+    public static func getPlayer(nativeId: NativeId) -> Player? {
+        shared.queue.sync {
+            shared.players[nativeId]
+        }
+    }
+
+    /**
+     * Get all registered player instances.
+     */
+    public static func getAllPlayers() -> [Player] {
+        shared.queue.sync {
+            Array(shared.players.values)
+        }
+    }
+
+    /**
+     * Get all registered native IDs.
+     */
+    public static func getAllNativeIds() -> [NativeId] {
+        shared.queue.sync {
+            Array(shared.players.keys)
+        }
+    }
+
+    /**
+     * Check if a player is registered with the given native ID.
+     */
+    public static func hasPlayer(nativeId: NativeId) -> Bool {
+        shared.queue.sync {
+            shared.players[nativeId] != nil
+        }
+    }
+
+    /**
+     * Clear all registered players.
+     * Note: This does not destroy the players, just removes them from the registry.
+     */
+    public static func clear() {
+        shared.queue.async(flags: .barrier) {
+            shared.players.removeAll()
+        }
+    }
+
+    /**
+     * Get the count of registered players.
+     */
+    public static func count() -> Int {
+        shared.queue.sync {
+            shared.players.count
+        }
+    }
+}

package/ios/RNPlayerView.swift

@@ -558,6 +558,7 @@ private extension RNPlayerView {
         return nil
     }
 
+    #if os(iOS)
     func attachCustomMessageHandlerBridge(
         id customMessageHandlerBridgeId: NativeId,
         to bitmovinUserInterfaceConfig: BitmovinUserInterfaceConfig
@@ -573,6 +574,7 @@ private extension RNPlayerView {
 
         bitmovinUserInterfaceConfig.customMessageHandler = customMessageHandlerBridge.customMessageHandler
     }
+    #endif
 
     @MainActor
     func maybeEmitPictureInPictureAvailabilityEvent(previousState: Bool) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bitmovin-player-react-native",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.2",
   "description": "Official React Native bindings for Bitmovin's mobile Player SDKs.",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/plugin/build/withBitmovinIosConfig.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_plugins_1 = require("expo/config-plugins");
+const isTV = !!process.env.EXPO_TV;
 const withBitmovinIosConfig = (config, { playerLicenseKey, features }) => {
     const offlineFeatureConfig = typeof features.offline === 'object'
         ? features.offline
@@ -25,29 +26,33 @@ const withBitmovinIosConfig = (config, { playerLicenseKey, features }) => {
             backgroundModes.add('audio');
             config.modResults['UIBackgroundModes'] = Array.from(backgroundModes);
         }
-        if (offlineFeatureConfig?.ios?.isEnabled) {
-            config.modResults['BitmovinPlayerOfflineSupportEnabled'] = true;
-        }
-        if (googleCastIosConfig) {
-            const appId = googleCastIosConfig.appId || 'FFE417E5';
-            const localNetworkUsageDescription = googleCastIosConfig.localNetworkUsageDescription ||
-                '${PRODUCT_NAME} uses the local network to discover Cast-enabled devices on your WiFi network.';
-            config.modResults['NSBonjourServices'] = [
-                '_googlecast._tcp',
-                `_${appId}._googlecast._tcp`,
-            ];
-            config.modResults['NSLocalNetworkUsageDescription'] =
-                localNetworkUsageDescription;
-        }
-        return config;
-    });
-    config = (0, config_plugins_1.withPodfileProperties)(config, (config) => {
-        if (googleCastIosConfig) {
-            config.modResults['BITMOVIN_GOOGLE_CAST_SDK_VERSION'] =
-                googleCastIosConfig.version;
+        if (!isTV) {
+            if (offlineFeatureConfig?.ios?.isEnabled) {
+                config.modResults['BitmovinPlayerOfflineSupportEnabled'] = true;
+            }
+            if (googleCastIosConfig) {
+                const appId = googleCastIosConfig.appId || 'FFE417E5';
+                const localNetworkUsageDescription = googleCastIosConfig.localNetworkUsageDescription ||
+                    '${PRODUCT_NAME} uses the local network to discover Cast-enabled devices on your WiFi network.';
+                config.modResults['NSBonjourServices'] = [
+                    '_googlecast._tcp',
+                    `_${appId}._googlecast._tcp`,
+                ];
+                config.modResults['NSLocalNetworkUsageDescription'] =
+                    localNetworkUsageDescription;
+            }
         }
         return config;
     });
+    if (!isTV) {
+        config = (0, config_plugins_1.withPodfileProperties)(config, (config) => {
+            if (googleCastIosConfig) {
+                config.modResults['BITMOVIN_GOOGLE_CAST_SDK_VERSION'] =
+                    googleCastIosConfig.version;
+            }
+            return config;
+        });
+    }
     return config;
 };
 exports.default = withBitmovinIosConfig;

package/plugin/src/withBitmovinIosConfig.ts

@@ -5,6 +5,8 @@ import {
 } from 'expo/config-plugins';
 import FeatureFlags from './FeatureFlags';
 
+const isTV = !!process.env.EXPO_TV;
+
 const withBitmovinIosConfig: ConfigPlugin<{
   playerLicenseKey: string;
   features: FeatureFlags;
@@ -38,32 +40,36 @@ const withBitmovinIosConfig: ConfigPlugin<{
       backgroundModes.add('audio');
       config.modResults['UIBackgroundModes'] = Array.from(backgroundModes);
     }
-    if (offlineFeatureConfig?.ios?.isEnabled) {
-      config.modResults['BitmovinPlayerOfflineSupportEnabled'] = true;
-    }
-    if (googleCastIosConfig) {
-      const appId = googleCastIosConfig.appId || 'FFE417E5';
-      const localNetworkUsageDescription =
-        googleCastIosConfig.localNetworkUsageDescription ||
-        '${PRODUCT_NAME} uses the local network to discover Cast-enabled devices on your WiFi network.';
+    if (!isTV) {
+      if (offlineFeatureConfig?.ios?.isEnabled) {
+        config.modResults['BitmovinPlayerOfflineSupportEnabled'] = true;
+      }
+      if (googleCastIosConfig) {
+        const appId = googleCastIosConfig.appId || 'FFE417E5';
+        const localNetworkUsageDescription =
+          googleCastIosConfig.localNetworkUsageDescription ||
+          '${PRODUCT_NAME} uses the local network to discover Cast-enabled devices on your WiFi network.';
 
-      config.modResults['NSBonjourServices'] = [
-        '_googlecast._tcp',
-        `_${appId}._googlecast._tcp`,
-      ];
-      config.modResults['NSLocalNetworkUsageDescription'] =
-        localNetworkUsageDescription;
+        config.modResults['NSBonjourServices'] = [
+          '_googlecast._tcp',
+          `_${appId}._googlecast._tcp`,
+        ];
+        config.modResults['NSLocalNetworkUsageDescription'] =
+          localNetworkUsageDescription;
+      }
     }
     return config;
   });
 
-  config = withPodfileProperties(config, (config) => {
-    if (googleCastIosConfig) {
-      config.modResults['BITMOVIN_GOOGLE_CAST_SDK_VERSION'] =
-        googleCastIosConfig.version;
-    }
-    return config;
-  });
+  if (!isTV) {
+    config = withPodfileProperties(config, (config) => {
+      if (googleCastIosConfig) {
+        config.modResults['BITMOVIN_GOOGLE_CAST_SDK_VERSION'] =
+          googleCastIosConfig.version;
+      }
+      return config;
+    });
+  }
 
   return config;
 };