react-native-theoplayer 1.8.0 → 1.8.2

package/ios/{THEOplayerRCTAdsAPI.swift → ads/THEOplayerRCTAdsAPI.swift}

@@ -10,7 +10,6 @@ import Foundation
 import UIKit
 
 let ERROR_CODE_ADS_ACCESS_FAILURE = "ads_access_failure"
-let ERROR_CODE_DAI_ACCESS_FAILURE = "dai_access_failure"
 let ERROR_CODE_ADS_GET_PLAYING_STATE_FAILED = "ads_get_playing_state_failure"
 let ERROR_CODE_ADS_GET_CURRENT_ADBREAK_FAILED = "ads_get_current_adbreak_failure"
 let ERROR_CODE_ADS_GET_CURRENT_ADBREAK_UNDEFINED = "ads_get_current_adbreak_undefined"
@@ -18,16 +17,11 @@ let ERROR_CODE_ADS_GET_CURRENT_ADS_FAILED = "ads_get_current_ads_failure"
 let ERROR_CODE_ADS_GET_CURRENT_ADS_UNDEFINED = "ads_get_current_ads_undefined"
 let ERROR_CODE_ADS_GET_SCHEDULED_ADBREAKS_FAILED = "ads_get_scheduled_adbreaks_failure"
 let ERROR_CODE_ADS_GET_SCHEDULED_ADBREAKS_UNDEFINED = "ads_get_scheduled_adbreaks_undefined"
-let ERROR_CODE_DAI_GET_SNAPBACK_FAILED = "dai_get_snapback_failed"
-let ERROR_CODE_DAI_GET_SNAPBACK_UNDEFINED = "dai_get_snapback_undefined"
-
 let ERROR_MESSAGE_ADS_ACCESS_FAILURE = "Could not access THEOplayer Ads Module"
-let ERROR_MESSAGE_DAI_ACCESS_FAILURE = "Could not access THEOplayer Ads DAI Module"
 let ERROR_MESSAGE_ADS_GET_CURRENT_ADBREAK_UNDEFINED = "Undefined adBreak object"
 let ERROR_MESSAGE_ADS_GET_CURRENT_ADS_UNDEFINED = "Undefined ads array"
 let ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE = "This functionality is not supported by the provided iOS SDK"
 let ERROR_MESSAGE_ADS_GET_SCHEDULED_ADBREAKS_UNDEFINED = "Undefined adbreaks array"
-let ERROR_MESSAGE_DAI_GET_SNAPBACK_UNDEFINED = "Undefined dai snapback"
 
 @objc(THEOplayerRCTAdsAPI)
 class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
@@ -41,7 +35,8 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
         return false
     }
 
-#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
+#if (GOOGLE_IMA || GOOGLE_DAI)
+    
     @objc(skip:)
     func skip(_ node: NSNumber) -> Void {
         
@@ -158,14 +153,16 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
             let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
             if let adData = adDict as? [String:Any],
                let ads = theView.ads(),
-               let adDescription = THEOplayerRCTSourceDescriptionBuilder.buildAdDescription(adData) {
+               let adDescription = THEOplayerRCTSourceDescriptionBuilder.buildSingleAdDescription(adData) {
                 ads.schedule(adDescription: adDescription)
             } else {
                 if DEBUG_ADS_API { print("[NATIVE] Could not schedule new ad.") }
             }
         }
     }
+    
 #else
+    
     @objc(skip:)
     func skip(_ node: NSNumber) -> Void {
         if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
@@ -202,94 +199,7 @@ class THEOplayerRCTAdsAPI: NSObject, RCTBridgeModule {
         if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
         return
     }
-#endif
-    
-#if os(iOS) && ADS && GOOGLE_DAI
-    @objc(daiSnapback:resolver:rejecter:)
-    func daiSnapback(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        DispatchQueue.main.async {
-            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
-            if let ads = theView.ads(),
-               let dai = ads.dai {
-                dai.requestSnapBack { enabled, error in
-                    if let err = error {
-                        reject(ERROR_CODE_DAI_GET_SNAPBACK_FAILED, err.localizedDescription, error)
-                        if DEBUG_ADS_API { print("[NATIVE] Retrieving dai snapback status failed: \(err.localizedDescription)") }
-                    } else if let snapBack = enabled {
-                        resolve(snapBack)
-                    } else {
-                        reject(ERROR_CODE_DAI_GET_SNAPBACK_UNDEFINED, ERROR_MESSAGE_DAI_GET_SNAPBACK_UNDEFINED, nil)
-                        if DEBUG_ADS_API { print("[NATIVE] Retrieving dai snapback status failed.") }
-                    }
-                }
-            } else {
-                reject(ERROR_CODE_DAI_ACCESS_FAILURE, ERROR_MESSAGE_DAI_ACCESS_FAILURE, nil)
-                if DEBUG_ADS_API { print("[NATIVE] Could not retrieve dai snapback status (ads DAI module unavailable).") }
-            }
-        }
-    }
-    
-    @objc(daiSetSnapback:enabled:)
-    func daiSetSnapback(_ node: NSNumber, enabled: Bool) -> Void {
-        DispatchQueue.main.async {
-            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
-            if let ads = theView.ads(),
-               let dai = ads.dai {
-                dai.setSnapBack(enabled, completionHandler: nil)
-            } else {
-                if DEBUG_ADS_API { print("[NATIVE] Could not update dai snapback status (ads DAI module unavailable).") }
-            }
-        }
-    }
     
-    @objc(daiContentTimeForStreamTime:time:resolver:rejecter:)
-    func daiContentTimeForStreamTime(_ node: NSNumber, timeValue: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        DispatchQueue.main.async {
-            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
-            if let ads = theView.ads(),
-               let dai = ads.dai {
-                let streamTime = timeValue.doubleValue * 0.001                      // msec -> sec
-                let contentTime = dai.contentTime(from: streamTime) * 1000.0        // sec -> msec
-                resolve(contentTime)
-            } else {
-                reject(ERROR_CODE_DAI_ACCESS_FAILURE, ERROR_MESSAGE_DAI_ACCESS_FAILURE, nil)
-                if DEBUG_ADS_API { print("[NATIVE] Could not convert stream time to content time (ads DAI module unavailable).") }
-            }
-        }
-    }
-    
-    @objc(daiStreamTimeForContentTime:time:resolver:rejecter:)
-    func daiStreamTimeForContentTime(_ node: NSNumber, timeValue: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        DispatchQueue.main.async {
-            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
-            if let ads = theView.ads(),
-               let dai = ads.dai {
-                let contentTime = timeValue.doubleValue * 0.001                     // msec -> sec
-                let streamTime = dai.streamTime(from: contentTime) * 1000.0         // sec -> msec
-                resolve(streamTime)
-            } else {
-                reject(ERROR_CODE_DAI_ACCESS_FAILURE, ERROR_MESSAGE_DAI_ACCESS_FAILURE, nil)
-                if DEBUG_ADS_API { print("[NATIVE] Could not convert content time to stream time (ads DAI module unavailable).") }
-            }
-        }
-    }
-#else
-    @objc(daiSnapback:resolver:rejecter:)
-    func daiSnapback(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        resolve(false)
-    }
-    
-    @objc(daiContentTimeForStreamTime:time:resolver:rejecter:)
-    func daiContentTimeForStreamTime(_ node: NSNumber, timeValue: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        resolve(timeValue.doubleValue)
-    }
-    
-    @objc(daiStreamTimeForContentTime:time:resolver:rejecter:)
-    func daiStreamTimeForContentTime(_ node: NSNumber, timeValue: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
-        resolve(timeValue.doubleValue)
-    }
 #endif
+
 }

package/ios/{THEOplayerRCTViewAdEventHandler.swift → ads/THEOplayerRCTAdsEventHandler.swift}

@@ -16,7 +16,7 @@ let EVENT_TYPE_AD_THIRD_QUARTILE: String = "adthirdquartile"
 let EVENT_TYPE_AD_MIDPOINT: String = "admidpoint"
 let EVENT_TYPE_AD_LOADED: String = "adloaded"
 
-class THEOplayerRCTViewAdEventHandler {
+class THEOplayerRCTAdsEventHandler {
     // MARK: Members
     private weak var player: THEOplayer?
         
@@ -54,7 +54,7 @@ class THEOplayerRCTViewAdEventHandler {
             return
         }
         
-#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
+#if (GOOGLE_IMA || GOOGLE_DAI)
         // AD_BEGIN
         self.adBeginListener = player.ads.addEventListener(type: AdsEventTypes.AD_BEGIN) { [weak self] event in
             if DEBUG_THEOPLAYER_EVENTS { print("[NATIVE] Received AD_BEGIN event from THEOplayer Ads") }
@@ -180,7 +180,7 @@ class THEOplayerRCTViewAdEventHandler {
             return
         }
         
-#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
+#if (GOOGLE_IMA || GOOGLE_DAI)
         // AD_BEGIN
         if let adBeginListener = self.adBeginListener {
             player.ads.removeEventListener(type: AdsEventTypes.AD_BEGIN, listener: adBeginListener)

package/ios/ads/THEOplayerRCTSourceDescriptionBuilder+Ads.swift

@@ -0,0 +1,130 @@
+// THEOplayerRCTSourceDescriptionBuilder.swift
+
+import Foundation
+import THEOplayerSDK
+import UIKit
+
+let SD_PROP_ADS: String = "ads"
+
+extension THEOplayerRCTSourceDescriptionBuilder {
+
+    /**
+     Builds a THEOplayer SourceDescription that can be passed as a source for the THEOplayer.
+     - returns: a THEOplayer TypedSource. In case of SSAI we  support GoogleDAITypedSource with GoogleDAIVodConfiguration or GoogleDAILiveConfiguration
+     */
+    static func buildAdDescriptions(_ sourceData: NSDictionary) -> [AdDescription]? {
+        var adsDescriptions: [AdDescription]?
+
+#if GOOGLE_IMA
+        if let ads = sourceData[SD_PROP_ADS] {
+            adsDescriptions = []
+            // case: array of ads objects
+            if let adsDataArray = ads as? [[String:Any]] {
+                for adsData in adsDataArray {
+                    if let adDescription = THEOplayerRCTSourceDescriptionBuilder.buildSingleAdDescription(adsData) {
+                        adsDescriptions?.append(adDescription)
+                    } else {
+                        if DEBUG_SOURCE_DESCRIPTION_BUIDER {
+                            print("[NATIVE] Could not create THEOplayer GoogleImaAdDescription from adsData array")
+                        }
+                        return nil
+                    }
+                }
+            }
+            // case: single ads object
+            else if let adsData = ads as? [String:Any] {
+                if let adDescription = THEOplayerRCTSourceDescriptionBuilder.buildSingleAdDescription(adsData) {
+                    adsDescriptions?.append(adDescription)
+                } else {
+                    if DEBUG_SOURCE_DESCRIPTION_BUIDER {
+                        print("[NATIVE] Could not create THEOplayer GoogleImaAdDescription from adsData")
+                    }
+                    return nil
+                }
+            }
+        }
+#endif
+
+        return adsDescriptions
+    }
+
+    /**
+     Creates a THEOplayer GoogleImaAdDescription. This requires an ads property in the RN source description.
+     - returns: a THEOplayer GoogleImaAdDescription
+     */
+    static func buildSingleAdDescription(_ adsData: [String:Any]) -> AdDescription? {
+#if GOOGLE_IMA
+        if let integration = adsData[SD_PROP_INTEGRATION] as? String,
+           integration == AdIntegration.google_ima._rawValue {
+            // timeOffset can be Int or String: 10, "01:32:54.78", "1234.56", "start", "end", "10%", ...
+            let timeOffset = adsData[SD_PROP_TIME_OFFSET] as? String ?? String(adsData[SD_PROP_TIME_OFFSET] as? Int ?? 0)
+            var srcString: String?
+            if let sourcesData = adsData[SD_PROP_SOURCES] as? [String:Any] {
+                srcString = sourcesData[SD_PROP_SRC] as? String
+            } else if let sourcesData = adsData[SD_PROP_SOURCES] as? String {
+                srcString = sourcesData
+            }
+            if let src = srcString {
+                return GoogleImaAdDescription(src: src, timeOffset: timeOffset)
+            } else {
+                if DEBUG_SOURCE_DESCRIPTION_BUIDER  { print("[NATIVE] AdDescription requires 'src' property in 'ads' description.") }
+            }
+        }
+        if DEBUG_SOURCE_DESCRIPTION_BUIDER  { print("[NATIVE] We currently require and only support the 'google-ima' integration in the 'ads' description.") }
+#endif
+
+        return nil
+    }
+
+    static func buildDAITypedSource(_ typedSourceData: [String:Any], contentProtection: MultiplatformDRMConfiguration?) -> TypedSource? {
+#if GOOGLE_DAI
+        // check for alternative Google DAI SSAI
+        if let ssaiData = typedSourceData[SD_PROP_SSAI] as? [String:Any] {
+            if let integration = ssaiData[SD_PROP_INTEGRATION] as? String,
+               integration == SSAIIntegrationId.GoogleDAISSAIIntegrationID._rawValue {
+                if let availabilityType = ssaiData[SD_PROP_AVAILABILITY_TYPE] as? String {
+                    // build a GoogleDAIConfiguration
+                    var googleDaiConfig: GoogleDAIConfiguration?
+                    let authToken = ssaiData[SD_PROP_AUTH_TOKEN] as? String
+                    let streamActivityMonitorID = ssaiData[SD_PROP_STREAM_ACTIVITY_MONITOR_ID] as? String
+                    let adTagParameters = ssaiData[SD_PROP_AD_TAG_PARAMETERS] as? [String:String]
+                    let apiKey = ssaiData[SD_PROP_APIKEY] as? String ?? ""
+                    switch availabilityType {
+                    case StreamType.vod._rawValue:
+                        if let videoId = ssaiData[SD_PROP_VIDEOID] as? String,
+                           let contentSourceID = ssaiData[SD_PROP_CONTENT_SOURCE_ID] as? String {
+                            googleDaiConfig = GoogleDAIVodConfiguration(videoID: videoId,
+                                                                        contentSourceID: contentSourceID,
+                                                                        apiKey: apiKey,
+                                                                        authToken: authToken,
+                                                                        streamActivityMonitorID: streamActivityMonitorID,
+                                                                        adTagParameters: adTagParameters)
+                        }
+                    case StreamType.live._rawValue:
+                        if let assetKey = ssaiData[SD_PROP_ASSET_KEY] as? String {
+                            googleDaiConfig = GoogleDAILiveConfiguration(assetKey: assetKey,
+                                                                         apiKey: apiKey,
+                                                                         authToken: authToken,
+                                                                         streamActivityMonitorID: streamActivityMonitorID,
+                                                                         adTagParameters: adTagParameters)
+                        }
+                    default:
+                        if DEBUG_SOURCE_DESCRIPTION_BUIDER {
+                            print("[NATIVE] THEOplayer ssai 'availabilityType' must be 'live' or 'vod'")
+                        }
+                        return nil
+                    }
+                    // when valid, create a GoogleDAITypedSource from the GoogleDAIConfiguration
+                    if let config = googleDaiConfig {
+                        return GoogleDAITypedSource(src: "", type: "application/x-mpegurl",
+                                                    drm: contentProtection, ssai: config)
+                    }
+                }
+            }
+        }
+#endif
+
+        return nil
+    }
+
+}

package/ios/ads/THEOplayerRCTView+Ads.swift

@@ -0,0 +1,15 @@
+// THEOplayerRCTView+Ads.swift
+
+import Foundation
+import THEOplayerSDK
+
+extension THEOplayerRCTView {
+    
+    func ads() -> Ads? {
+        guard let player = self.player else {
+            return nil
+        }
+        return player.ads
+    }
+
+}

package/ios/ads/THEOplayerRCTView+AdsConfig.swift

@@ -0,0 +1,82 @@
+// THEOplayerRCTView+Ads.swift
+
+import Foundation
+import THEOplayerSDK
+
+struct AdsConfig {
+    var adSUIEnabled: Bool = true
+    var googleImaUsesNativeIma: Bool = true
+    var adPreloadTypeString: String = "none"
+}
+
+#if os(iOS)
+
+extension THEOplayerRCTView {
+    
+    func parseAdsConfig(configDict: NSDictionary) {
+        if let adsConfig = configDict["ads"] as? NSDictionary {
+            self.adsConfig.adSUIEnabled = adsConfig["uiEnabled"] as? Bool ?? true
+            if let adPreloadType = adsConfig["preload"] as? String {
+                self.adsConfig.adPreloadTypeString = adPreloadType
+            }
+            if let googleImaConfiguration = adsConfig["googleImaConfiguration"] as? NSDictionary {
+                self.adsConfig.googleImaUsesNativeIma = googleImaConfiguration["useNativeIma"] as? Bool ?? true
+            }
+        }
+    }
+
+#if (GOOGLE_IMA || GOOGLE_DAI)
+    func playerAdsConfiguration() -> AdsConfiguration? {
+        // NOTE: GoogleIMAAdsConfiguration, GoogleDAIAdsConfigurationBuilder, GoogleDAIAdsConfigurationBuilder require iOS SDK 4.5.1 or higher
+        let googleIMAAdsConfiguration = GoogleIMAAdsConfiguration()
+        googleIMAAdsConfiguration.useNativeIma = self.adsConfig.googleImaUsesNativeIma
+        googleIMAAdsConfiguration.disableUI = !self.adsConfig.adSUIEnabled
+        let daiBuilder = GoogleDAIAdsConfigurationBuilder()
+        daiBuilder.disableUI = !self.adsConfig.adSUIEnabled
+        daiBuilder.enableBackgroundPlayback = true
+        let googleDaiAdsConfiguration = daiBuilder.build()
+        return AdsConfiguration(showCountdown: self.adsConfig.adSUIEnabled,
+                                preload: self.adPreloadType(),
+                                googleIma: googleIMAAdsConfiguration,
+                                googleDai: googleDaiAdsConfiguration)
+        
+        // For lower iOS SDK versions replace the above with:
+        /*let googleIMAConfiguration = GoogleIMAConfiguration()
+         googleIMAConfiguration.useNativeIma = self.googleImaUsesNativeIma
+         googleIMAConfiguration.disableUI = !self.adSUIEnabled
+         return AdsConfiguration(showCountdown: self.adSUIEnabled,
+         preload: self.adPreloadType,
+         googleImaConfiguration: googleIMAConfiguration)*/
+    }
+    
+    private func adPreloadType() -> THEOplayerSDK.AdPreloadType {
+        switch self.adsConfig.adPreloadTypeString {
+        case "midroll-and-postroll":
+            return THEOplayerSDK.AdPreloadType.MIDROLL_AND_POSTROLL
+        case "none":
+            return THEOplayerSDK.AdPreloadType.NONE
+        default :
+            return THEOplayerSDK.AdPreloadType.NONE
+        }
+    }
+#else
+    func playerAdsConfiguration() -> AdsConfiguration? { return nil }
+#endif
+    
+}
+
+#elseif os(tvOS)
+
+extension THEOplayerRCTView {
+    
+    func parseAdsConfig(configDict: NSDictionary) {}
+    
+#if GOOGLE_IMA
+    func playerAdsConfiguration() -> AdsConfiguration? { return AdsConfiguration() }
+#else
+    func playerAdsConfiguration() -> AdsConfiguration? { return nil }
+#endif
+    
+}
+
+#endif

package/ios/casting/THEOplayerRCTCastAPI+Airplay.swift

@@ -0,0 +1,97 @@
+//  THEOplayerRCTCastAPI+Airplay.swift
+
+import Foundation
+
+let ERROR_CODE_AIRPLAY_ACCESS_FAILURE = "airplay_access_failure"
+let ERROR_MESSAGE_AIRPLAY_UNSUPPORTED_FEATURE = "Airplay is not supported by the provided iOS SDK"
+let ERROR_MESSAGE_AIRPLAY_ACCESS_FAILURE = "Could not access THEOplayer Airplay API"
+
+extension THEOplayerRCTCastAPI {
+    
+#if os(iOS)
+    
+    @objc(airplayCasting:resolver:rejecter:)
+    func airplayCasting(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let airplay = cast.airPlay {
+                resolve(airplay.casting)
+            } else {
+                reject(ERROR_CODE_AIRPLAY_ACCESS_FAILURE, ERROR_MESSAGE_AIRPLAY_ACCESS_FAILURE, nil)
+                if DEBUG_CAST_API { print("[NATIVE] Could not retrieve current airplay casting status.") }
+            }
+        }
+    }
+    
+    @objc(airplayState:resolver:rejecter:)
+    func airplayState(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let airplay = cast.airPlay {
+                resolve(airplay.state._rawValue)
+            } else {
+                reject(ERROR_CODE_AIRPLAY_ACCESS_FAILURE, ERROR_MESSAGE_AIRPLAY_ACCESS_FAILURE, nil)
+                if DEBUG_CAST_API { print("[NATIVE] Could not retrieve current airplay state.") }
+            }
+        }
+    }
+    
+    @objc(airplayStart:)
+    func airplayStart(_ node: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let airplay = cast.airPlay {
+                if DEBUG_CAST_API { print("[NATIVE] Starting airplay session.") }
+                airplay.start()
+            } else {
+                if DEBUG_CAST_API { print("[NATIVE] Could not start airplay session.") }
+            }
+        }
+    }
+    
+    @objc(airplayStop:)
+    func airplayStop(_ node: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let airplay = cast.airPlay {
+                if DEBUG_CAST_API { print("[NATIVE] Stopping airplay session.") }
+                airplay.stop()
+            } else {
+                if DEBUG_CAST_API { print("[NATIVE] Could not stop airplay session.") }
+            }
+        }
+    }
+    
+#else
+    
+    @objc(airplayCasting:resolver:rejecter:)
+    func airplayCasting(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_AIRPLAY_UNSUPPORTED_FEATURE) }
+        resolve(false)
+    }
+    
+    @objc(airplayState:resolver:rejecter:)
+    func airplayState(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_AIRPLAY_UNSUPPORTED_FEATURE) }
+        resolve("unavailable")
+    }
+    
+    @objc(airplayStart:)
+    func airplayStart(_ node: NSNumber) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_AIRPLAY_UNSUPPORTED_FEATURE) }
+    }
+    
+    @objc(airplayStop:)
+    func airplayStop(_ node: NSNumber) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_AIRPLAY_UNSUPPORTED_FEATURE) }
+    }
+
+#endif
+}
+
+
+

package/ios/casting/THEOplayerRCTCastAPI+Chromecast.swift

@@ -0,0 +1,132 @@
+//  THEOplayerRCTCastAPI+Chromecast.swift
+
+import Foundation
+
+let ERROR_CODE_CHROMECAST_ACCESS_FAILURE = "chromecast_access_failure"
+let ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE = "Chromecast is not supported by the provided iOS SDK"
+let ERROR_MESSAGE_CHROMECAST_ACCESS_FAILURE = "Could not access THEOplayer Chromecast API"
+
+extension THEOplayerRCTCastAPI {
+   
+#if os(iOS) && CHROMECAST
+    
+    @objc(chromecastCasting:resolver:rejecter:)
+    func chromecastCasting(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let chromecast = cast.chromecast {
+                resolve(chromecast.casting)
+            } else {
+                reject(ERROR_CODE_CHROMECAST_ACCESS_FAILURE, ERROR_MESSAGE_CHROMECAST_ACCESS_FAILURE, nil)
+                if DEBUG_CAST_API { print("[NATIVE] Could not retrieve current chromecast casting status.") }
+            }
+        }
+    }
+    
+    @objc(chromecastState:resolver:rejecter:)
+    func chromecastState(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let chromecast = cast.chromecast {
+                resolve(chromecast.state?._rawValue)
+            } else {
+                reject(ERROR_CODE_CHROMECAST_ACCESS_FAILURE, ERROR_MESSAGE_CHROMECAST_ACCESS_FAILURE, nil)
+                if DEBUG_CAST_API { print("[NATIVE] Could not retrieve current chromecast state.") }
+            }
+        }
+    }
+    
+    @objc(chromecastStart:)
+    func chromecastStart(_ node: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let chromecast = cast.chromecast {
+                if DEBUG_CAST_API { print("[NATIVE] Starting chromecast session.") }
+                chromecast.start()
+            } else {
+                if DEBUG_CAST_API { print("[NATIVE] Could not start chromecast session.") }
+            }
+        }
+    }
+    
+    @objc(chromecastStop:)
+    func chromecastStop(_ node: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let chromecast = cast.chromecast {
+                if DEBUG_CAST_API { print("[NATIVE] Stopping chromecast session.") }
+                chromecast.stop()
+            } else {
+                if DEBUG_CAST_API { print("[NATIVE] Could not stop chromecast session.") }
+            }
+        }
+    }
+    
+    @objc(chromecastJoin:)
+    func chromecastJoin(_ node: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let chromecast = cast.chromecast {
+                if DEBUG_CAST_API { print("[NATIVE] Joining chromecast session.") }
+                chromecast.join()
+            } else {
+                if DEBUG_CAST_API { print("[NATIVE] Could not join chromecast session.") }
+            }
+        }
+    }
+    
+    @objc(chromecastLeave:)
+    func chromecastLeave(_ node: NSNumber) -> Void {
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let cast = theView.cast(),
+               let chromecast = cast.chromecast {
+                if DEBUG_CAST_API { print("[NATIVE] Leaving chromecast session.") }
+                chromecast.leave()
+            } else {
+                if DEBUG_CAST_API { print("[NATIVE] Could not leave chromecast session.") }
+            }
+        }
+    }
+    
+#else
+    
+    @objc(chromecastCasting:resolver:rejecter:)
+    func chromecastCasting(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE) }
+        resolve(false)
+    }
+    
+    @objc(chromecastState:resolver:rejecter:)
+    func chromecastState(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE) }
+        resolve("unavailable")
+    }
+    
+    @objc(chromecastStart:)
+    func chromecastStart(_ node: NSNumber) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE) }
+    }
+    
+    @objc(chromecastStop:)
+    func chromecastStop(_ node: NSNumber) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE) }
+    }
+    
+    @objc(chromecastJoin:)
+    func chromecastJoin(_ node: NSNumber) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE) }
+    }
+    
+    @objc(chromecastLeave:)
+    func chromecastLeave(_ node: NSNumber) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE) }
+    }
+    
+#endif
+}