react-native-theoplayer 1.6.1 → 1.7.1

package/ios/THEOplayerRCTAdAggregator.swift

@@ -0,0 +1,158 @@
+// THEOplayerRCTAdAggregator.swift
+
+import Foundation
+import THEOplayerSDK
+
+let PROP_AD_INTEGRATION: String = "integration"
+let PROP_AD_TYPE: String = "type"
+let PROP_AD_ID: String = "id"
+let PROP_AD_BREAK: String = "adBreak"
+let PROP_AD_DURATION: String = "duration"
+let PROP_AD_SKIP_OFFSET: String = "skipOffset"
+let PROP_AD_COMPANIONS: String = "companions"
+let PROP_AD_CLICK_THROUGH: String = "clickThrough"
+let PROP_AD_RESOURCE_URI: String = "resourceURI"
+let PROP_AD_UNIVERSAL_AD_IDS: String = "universalAdIds"
+let PROP_GOOGLE_AD_AD_SYSTEM: String = "adSystem"
+let PROP_GOOGLE_AD_CREATIVE_ID: String = "creativeId"
+let PROP_GOOGLE_AD_TRAFFICKING_PARAMETERS_STRING: String = "traffickingParametersString"
+let PROP_GOOGLE_AD_TRAFFICKING_PARAMETERS: String = "traffickingParameters"
+let PROP_GOOGLE_AD_BITRATE: String = "bitrate"
+let PROP_GOOGLE_AD_WIDTH: String = "width"
+let PROP_GOOGLE_AD_HEIGHT: String = "height"
+let PROP_GOOGLE_AD_CONTENT_TYPE: String = "contentType"
+let PROP_GOOGLE_AD_ID_REGISTRY: String = "adIdRegistry"
+let PROP_GOOGLE_AD_ID_VALUE: String = "adIdValue"
+let PROP_GOOLGE_AD_WRAPPER_AD_IDS: String = "wrapperAdIds"
+let PROP_GOOLGE_AD_WRAPPER_AD_SYSTEMS: String = "wrapperAdSystems"
+let PROP_GOOLGE_AD_WRAPPER_CREATIVE_IDS: String = "wrapperCreativeIds"
+let PROP_ADBREAK_MAX_DURATION: String = "maxDuration"
+let PROP_ADBREAK_TIME_OFFSET: String = "timeOffset"
+let PROP_ADBREAK_MAX_REMAINING_DURATION: String = "maxRemainingDuration"
+let PROP_ADBREAK_ADS: String = "ads"
+let PROP_ADBREAK_INTEGRATION: String = "integration"
+let PROP_COMPANION_AD_SLOT_ID: String = "adSlotId"
+let PROP_COMPANION_ALT_TEXT: String = "altText"
+let PROP_COMPANION_CLICK_THROUGH: String = "clickThrough"
+let PROP_COMPANION_WIDTH: String = "width"
+let PROP_COMPANION_HEIGHT: String = "height"
+let PROP_COMPANION_RESOURCE_URI: String = "resourceURI"
+
+class THEOplayerRCTAdAggregator {
+
+    class func aggregateAd(ad: Ad, processAdBreak: Bool = true) -> [String:Any] {
+        var adData: [String:Any] = [:]
+        adData[PROP_AD_INTEGRATION] = ad.integration._rawValue
+        adData[PROP_AD_TYPE] = ad.type
+        if let adId = ad.id {
+            adData[PROP_AD_ID] = adId
+        }
+        if let resourceURI = ad.resourceURI {
+            adData[PROP_AD_RESOURCE_URI] = resourceURI
+        }
+        if let skipOffset = ad.skipOffset {
+            adData[PROP_AD_SKIP_OFFSET] = (skipOffset == -1) ? skipOffset : skipOffset * 1000 // sec -> msec
+        }
+        if processAdBreak,
+           let adBreak = ad.adBreak {
+            adData[PROP_AD_BREAK] = THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak: adBreak)
+        }
+        adData[PROP_AD_COMPANIONS] = THEOplayerRCTAdAggregator.aggregateCompanionAds(companionAds: ad.companions)
+        adData[PROP_AD_UNIVERSAL_AD_IDS] = []
+        
+        // Add additional properties for Linear Ads
+        if let linearAd = ad as? LinearAd {
+            if let adDuration = linearAd.duration {
+                adData[PROP_AD_DURATION] = adDuration * 1000 // sec -> msec
+            }
+        }
+        
+        // Add additional properties for NonLinear Ads
+        if let nonLinearAd = ad as? NonLinearAd {
+            if let adClickThrough = nonLinearAd.clickThrough {
+                adData[PROP_AD_CLICK_THROUGH] = adClickThrough
+            }
+        }
+
+        // Add additional properties for GoogleIma Ads
+        if let googleImaAd = ad as? GoogleImaAd {
+            if let adSystem = googleImaAd.adSystem {
+                adData[PROP_GOOGLE_AD_AD_SYSTEM] = adSystem
+            }
+            if let creativeId = googleImaAd.creativeId {
+                adData[PROP_GOOGLE_AD_CREATIVE_ID] = creativeId
+            }
+            let traffickingParametersString = googleImaAd.traffickingParameters
+            adData[PROP_GOOGLE_AD_TRAFFICKING_PARAMETERS_STRING] = traffickingParametersString
+            if let traffickingParameters = THEOplayerRCTAdAggregator.aggregateTraffickingParameters(traffickingParametersString: traffickingParametersString) {
+                adData[PROP_GOOGLE_AD_TRAFFICKING_PARAMETERS] = traffickingParameters
+            }
+            adData[PROP_GOOGLE_AD_BITRATE] = googleImaAd.vastMediaBitrate
+            if let width = googleImaAd.width {
+                adData[PROP_GOOGLE_AD_WIDTH] = width
+            }
+            if let height = googleImaAd.height {
+                adData[PROP_GOOGLE_AD_HEIGHT] = height
+            }
+            if !googleImaAd.universalAdIds.isEmpty {
+                var adIdList: [[String:Any]] = []
+                for adId in googleImaAd.universalAdIds {
+                    var adIdData: [String:Any] = [:]
+                    adIdData[PROP_GOOGLE_AD_ID_REGISTRY] = adId.adIdRegistry
+                    adIdData[PROP_GOOGLE_AD_ID_VALUE] = adId.adIdValue
+                    adIdList.append(adIdData)
+                }
+                adData[PROP_AD_UNIVERSAL_AD_IDS] = adIdList
+            }
+            adData[PROP_GOOLGE_AD_WRAPPER_AD_IDS] = googleImaAd.wrapperAdIds
+            adData[PROP_GOOLGE_AD_WRAPPER_AD_SYSTEMS] = googleImaAd.wrapperAdSystems
+            adData[PROP_GOOLGE_AD_WRAPPER_CREATIVE_IDS] = googleImaAd.wrapperCreativeIds
+        }
+        
+        return adData
+    }
+    
+    class func aggregateAdBreak(adBreak: AdBreak) -> [String:Any] {
+        var adBreakData: [String:Any] = [:]
+        adBreakData[PROP_ADBREAK_MAX_DURATION] = adBreak.maxDuration * 1000 // sec -> msec
+        adBreakData[PROP_ADBREAK_TIME_OFFSET] = adBreak.timeOffset * 1000 // sec -> msec
+        adBreakData[PROP_ADBREAK_MAX_REMAINING_DURATION] = adBreak.maxRemainingDuration * 1000.0 // sec -> msec
+        // process adds when adbreak contains them
+        if !adBreak.ads.isEmpty {
+            var adList: [[String:Any]] = []
+            for ad in adBreak.ads {
+                adList.append(THEOplayerRCTAdAggregator.aggregateAd(ad: ad, processAdBreak: false))
+            }
+            adBreakData[PROP_ADBREAK_ADS] = adList
+            if adList.count > 0,
+               let integration = adList[0][PROP_AD_INTEGRATION] {
+                adBreakData[PROP_ADBREAK_INTEGRATION] = integration
+            }
+        }
+        return adBreakData
+    }
+    
+    class private func aggregateCompanionAds(companionAds: [CompanionAd?]) -> [[String:Any]] {
+        var companionAdsData: [[String:Any]] = []
+        for cAd in companionAds {
+            if let companionAd = cAd {
+                var companionAdData: [String:Any] = [:]
+                companionAdData[PROP_COMPANION_AD_SLOT_ID] = companionAd.adSlotId ?? ""
+                companionAdData[PROP_COMPANION_ALT_TEXT] = companionAd.altText ?? ""
+                companionAdData[PROP_COMPANION_CLICK_THROUGH] = companionAd.clickThrough ?? ""
+                companionAdData[PROP_COMPANION_WIDTH] = companionAd.width ?? 0
+                companionAdData[PROP_COMPANION_HEIGHT] = companionAd.height ?? 0
+                companionAdData[PROP_COMPANION_RESOURCE_URI] = companionAd.resourceURI ?? ""
+                companionAdsData.append(companionAdData)
+            }
+        }
+        return companionAdsData
+    }
+    
+    class private func aggregateTraffickingParameters(traffickingParametersString: String) -> [String:Any]? {
+        if let data = traffickingParametersString.data(using: .utf8) {
+            return try? JSONSerialization.jsonObject(with: data, options: .mutableContainers) as? [String:Any]
+        }
+        return nil
+    }
+}

package/ios/THEOplayerRCTAdsAPI.swift

@@ -0,0 +1,296 @@
+//
+//  THEOplayerRCTAdsAPI.swift
+//  Theoplayer
+//
+//  Created by William van Haevre on 09/09/2022.
+//  Copyright © 2022 Facebook. All rights reserved.
+//
+
+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"
+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 {
+    @objc var bridge: RCTBridge!
+    
+    static func moduleName() -> String! {
+        return "AdsModule"
+    }
+    
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+#if ADS && (GOOGLE_IMA || GOOGLE_DAI)
+    @objc(skip:)
+    func skip(_ node: NSNumber) -> Void {
+        
+        DispatchQueue.main.async {
+            let theView = self.bridge.uiManager.view(forReactTag: node) as! THEOplayerRCTView
+            if let ads = theView.ads() {
+                ads.skip()
+            } else {
+                if DEBUG_ADS_API { print("[NATIVE] Could not skip ad (ads module unavailable).") }
+            }
+        }
+    }
+    
+    @objc(playing:resolver:rejecter:)
+    func playing(_ 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() {
+                ads.requestPlaying { playing, error in
+                    if let err = error {
+                        reject(ERROR_CODE_ADS_GET_PLAYING_STATE_FAILED, err.localizedDescription, error)
+                        if DEBUG_ADS_API { print("[NATIVE] Retrieving ad playing state failed: \(err.localizedDescription)") }
+                    } else {
+                        resolve(playing)
+                    }
+                }
+            } else {
+                reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
+                if DEBUG_ADS_API { print("[NATIVE] Could not skip ad (ads module unavailable).") }
+            }
+        }
+    }
+    
+    @objc(currentAdBreak:resolver:rejecter:)
+    func currentAdBreak(_ 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() {
+                ads.requestCurrentAdBreak { adBreak, error in
+                    if let err = error {
+                        reject(ERROR_CODE_ADS_GET_CURRENT_ADBREAK_FAILED, err.localizedDescription, error)
+                        if DEBUG_ADS_API { print("[NATIVE] Retrieving current adbreak failed: \(err.localizedDescription)") }
+                    } else if let currentAdBreak = adBreak {
+                        resolve(THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak:currentAdBreak))
+                    } else {
+                        reject(ERROR_CODE_ADS_GET_CURRENT_ADBREAK_UNDEFINED, ERROR_MESSAGE_ADS_GET_CURRENT_ADBREAK_UNDEFINED, nil)
+                        if DEBUG_ADS_API { print("[NATIVE] Retrieving current adbreak failed: could not load adbreak.") }
+                    }
+                }
+            } else {
+                reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
+                if DEBUG_ADS_API { print("[NATIVE] Could not retrieve current adbreak (ads module unavailable).") }
+            }
+        }
+    }
+    
+    @objc(currentAds:resolver:rejecter:)
+    func currentAds(_ 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() {
+                ads.requestCurrentAds { adsArray, error in
+                    if let err = error {
+                        reject(ERROR_CODE_ADS_GET_CURRENT_ADS_FAILED, err.localizedDescription, error)
+                        if DEBUG_ADS_API { print("[NATIVE] Retrieving current ads failed: \(err.localizedDescription)") }
+                    } else if let currentAdsArray = adsArray {
+                        var currentAds: [[String:Any]] = []
+                        for ad in currentAdsArray {
+                            currentAds.append(THEOplayerRCTAdAggregator.aggregateAd(ad: ad))
+                        }
+                        resolve(currentAds)
+                    } else {
+                        reject(ERROR_CODE_ADS_GET_CURRENT_ADS_UNDEFINED, ERROR_MESSAGE_ADS_GET_CURRENT_ADS_UNDEFINED, nil)
+                        if DEBUG_ADS_API { print("[NATIVE] Retrieving current ads failed: could not load ads.") }
+                    }
+                }
+            } else {
+                reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
+                if DEBUG_ADS_API { print("[NATIVE] Could not retrieve current ad (ads module unavailable).") }
+            }
+        }
+    }
+    
+    @objc(scheduledAdBreaks:resolver:rejecter:)
+    func scheduledAdBreaks(_ 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() {
+                ads.requestScheduledAdBreaks { adBreaksArray, error in
+                    if let err = error {
+                        reject(ERROR_CODE_ADS_GET_SCHEDULED_ADBREAKS_FAILED, err.localizedDescription, error)
+                        if DEBUG_ADS_API { print("[NATIVE] Retrieving scheduled adbreaks failed: \(err.localizedDescription)") }
+                    } else if let currentAdBreaksArray = adBreaksArray {
+                        var currentAdBreaks: [[String:Any]] = []
+                        for adbreak in currentAdBreaksArray {
+                            currentAdBreaks.append(THEOplayerRCTAdAggregator.aggregateAdBreak(adBreak: adbreak))
+                        }
+                        resolve(currentAdBreaks)
+                    } else {
+                        reject(ERROR_CODE_ADS_GET_SCHEDULED_ADBREAKS_UNDEFINED, ERROR_MESSAGE_ADS_GET_SCHEDULED_ADBREAKS_UNDEFINED, nil)
+                        if DEBUG_ADS_API { print("[NATIVE] Retrieving current adbreaks failed: could not load adbreaks.") }
+                    }
+                }
+            } else {
+                reject(ERROR_CODE_ADS_ACCESS_FAILURE, ERROR_MESSAGE_ADS_ACCESS_FAILURE, nil)
+                if DEBUG_ADS_API { print("[NATIVE] Could not retrieve current ad (ads module unavailable).") }
+            }
+        }
+    }
+    
+    @objc(schedule:ad:)
+    func schedule(_ node: NSNumber, adDict: NSDictionary) -> Void {
+        DispatchQueue.main.async {
+            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) {
+                ads.schedule(adDescription: adDescription)
+            } else {
+                if DEBUG_ADS_API { print("[NATIVE] Could not schedule new ad.") }
+            }
+        }
+    }
+    
+    @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(skip:)
+    func skip(_ node: NSNumber) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        return
+    }
+    
+    @objc(playing:resolver:rejecter:)
+    func playing(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve(false)
+    }
+    
+    @objc(currentAdBreak:resolver:rejecter:)
+    func currentAdBreak(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve([:])
+    }
+    
+    @objc(currentAds:resolver:rejecter:)
+    func currentAds(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve([])
+    }
+    
+    @objc(scheduledAdBreaks:resolver:rejecter:)
+    func scheduledAdBreaks(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        resolve([])
+        // TODO: handle request for scheduled adbreaks. Awaiting iOS SDK implementation
+    }
+    
+    @objc(schedule:ad:)
+    func schedule(_ node: NSNumber, adDict: NSDictionary) -> Void {
+        if DEBUG_ADS_API { print(ERROR_MESSAGE_ADS_UNSUPPORTED_FEATURE) }
+        return
+    }
+    
+    @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/THEOplayerRCTBridge.m

@@ -7,7 +7,10 @@
 //
 
 #import <React/RCTViewManager.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
+// View Manager
 @interface RCT_EXTERN_MODULE(THEOplayerRCTViewManager, RCTViewManager)
 
 RCT_EXPORT_VIEW_PROPERTY(src, NSDictionary);
@@ -40,9 +43,71 @@ RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerWillPresent, RCTDirectEventBloc
 RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerDidPresent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerWillDismiss, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeFullscreenPlayerDidDismiss, RCTDirectEventBlock);
+
 RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackListEvent, RCTDirectEventBlock);
 RCT_EXPORT_VIEW_PROPERTY(onNativeTextTrackEvent, RCTDirectEventBlock);
 
+RCT_EXPORT_VIEW_PROPERTY(onNativeAdEvent, RCTDirectEventBlock);
+
 RCT_EXTERN_METHOD(destroy:(nonnull NSNumber *)node);
 
 @end
+
+// Ads Module
+@interface RCT_EXTERN_REMAP_MODULE(AdsModule, THEOplayerRCTAdsAPI, NSObject)
+
+RCT_EXTERN_METHOD(skip:(nonnull NSNumber *)node)
+
+RCT_EXTERN_METHOD(playing:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(currentAdBreak:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(currentAds:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(scheduledAdBreaks:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(schedule:(nonnull NSNumber *)node
+                  ad: NSDictionary)
+
+RCT_EXTERN_METHOD(daiSnapback:(nonnull NSNumber *)node
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(daiSetSnapback:(nonnull NSNumber *)node
+                  enabled:(BOOL)enabled)
+
+RCT_EXTERN_METHOD(daiContentTimeForStreamTime:(nonnull NSNumber *)node
+                  time:(nonnull NSNumber *)timeValue
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(daiStreamTimeForContentTime:(nonnull NSNumber *)node
+                  time:(nonnull NSNumber *)timeValue
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end
+
+// ContentProtectionModule
+@interface RCT_EXTERN_REMAP_MODULE(ContentProtectionModule, THEOplayerRCTContentProtectionAPI, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(onBuildProcessed:(NSDictionary)result)
+RCT_EXTERN_METHOD(onCertificateRequestProcessedAsRequest:(NSDictionary)result)
+RCT_EXTERN_METHOD(onCertificateRequestProcessedAsCertificate:(NSDictionary)result)
+RCT_EXTERN_METHOD(onCertificateResponseProcessed:(NSDictionary)result)
+RCT_EXTERN_METHOD(onLicenseRequestProcessedAsRequest:(NSDictionary)result)
+RCT_EXTERN_METHOD(onLicenseRequestProcessedAsLicense:(NSDictionary)result)
+RCT_EXTERN_METHOD(onLicenseResponseProcessed:(NSDictionary)result)
+RCT_EXTERN_METHOD(onExtractFairplayContentIdProcessed:(NSDictionary)result)
+RCT_EXTERN_METHOD(registerContentProtectionIntegration:(nonnull NSString *)integrationId
+                  keySystemId:(nonnull NSString *)keySystemId)
+
+@end