react-native-theoplayer 1.6.1 → 1.7.1

package/ios/THEOplayerRCTProxyContentProtectionIntegration.swift

@@ -0,0 +1,155 @@
+//
+//  THEOplayerRCTContentProtectionIntegration.swift
+//  Theoplayer
+//
+//  Created by William van Haevre on 28/10/2022.
+//
+
+import Foundation
+import THEOplayerSDK
+
+enum ProxyIntegrationError: Error {
+    case certificateRequestHandlingFailed
+    case certificateResponseHandlingFailed
+    case licenseRequestHandlingFailed
+    case licenseResponseHandlingFailed
+    case extractFairplayContentIdFailed
+}
+
+let CERTIFICATE_MARKER: String = "https://certificatemarker/"
+let PROXY_INTEGRATION_TAG: String = "[ProxyContentProtectionIntegration]"
+let BRIDGE_TIMEOUT = 10.0
+
+class THEOplayerRCTProxyContentProtectionIntegration: THEOplayerSDK.ContentProtectionIntegration {
+    private weak var contentProtectionAPI: THEOplayerRCTContentProtectionAPI?
+    private var integrationId: String!
+    private var keySystemId: String!
+    private var buildIntegrationSemaphore = DispatchSemaphore(value: 0)
+    private var contentIdExtractionSemaphore = DispatchSemaphore(value: 0)
+    private var drmConfig: THEOplayerSDK.DRMConfiguration
+    
+    init(contentProtectionAPI: THEOplayerRCTContentProtectionAPI?, integrationId: String, keySystemId: String, drmConfig: THEOplayerSDK.DRMConfiguration) {
+        self.contentProtectionAPI = contentProtectionAPI
+        self.integrationId = integrationId
+        self.keySystemId = keySystemId
+        self.drmConfig = drmConfig
+        self.contentProtectionAPI?.handleBuildIntegration(integrationId: integrationId, keySystemId: keySystemId, drmConfig: drmConfig, completion: { success in
+            if success {
+                print(PROXY_INTEGRATION_TAG, "Successfully created a THEOplayer ContentProtectionIntegration for \(integrationId) - \(keySystemId)")
+            } else {
+                print(PROXY_INTEGRATION_TAG, "WARNING: Failed to create a THEOplayer ContentProtectionIntegration for \(integrationId) - \(keySystemId)")
+            }
+            self.buildIntegrationSemaphore.signal()
+        })
+        _ = self.buildIntegrationSemaphore.wait(timeout: .now() + BRIDGE_TIMEOUT)
+    }
+    
+    func onCertificateRequest(request: CertificateRequest, callback: CertificateRequestCallback) {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "THEOplayer triggered an onCertificateRequest") }
+        let processedLocally = self.handleCertificateRequestLocally(drmConfig: drmConfig, callback: callback)
+        if !processedLocally {
+            if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "Handling certificate request through content protection integration.") }
+            self.contentProtectionAPI?.handleCertificateRequest(integrationId: self.integrationId, keySystemId: self.keySystemId, certificateRequest: request) { certificateData, error in
+                if let error = error {
+                    callback.error(error: error)
+                    return
+                }
+                if let data = certificateData {
+                    callback.respond(certificate: data)
+                } else {
+                    callback.error(error: ProxyIntegrationError.certificateRequestHandlingFailed)
+                }
+            }
+        }
+    }
+    
+    func onCertificateResponse(response: CertificateResponse, callback: CertificateResponseCallback) {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "THEOplayer triggered an onCertificateResponse") }
+        self.contentProtectionAPI?.handleCertificateResponse(integrationId: self.integrationId, keySystemId: self.keySystemId, certificateResponse: response) { certificateData, error in
+            if let error = error {
+                callback.error(error: error)
+                return
+            }
+            if let data = certificateData {
+                callback.respond(certificate: data)
+            } else {
+                callback.error(error: ProxyIntegrationError.certificateResponseHandlingFailed)
+            }
+        }
+    }
+    
+    func onLicenseRequest(request: LicenseRequest, callback: LicenseRequestCallback) {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "THEOplayer triggered an onLicenseRequest") }
+        self.contentProtectionAPI?.handleLicenseRequest(integrationId: self.integrationId, keySystemId: self.keySystemId, licenseRequest: request) { licenseData, error in
+            if let error = error {
+                callback.error(error: error)
+                return
+            }
+            if let data = licenseData {
+                callback.respond(license: data)
+            } else {
+                callback.error(error: ProxyIntegrationError.licenseRequestHandlingFailed)
+            }
+        }
+    }
+    
+    func onLicenseResponse(response: LicenseResponse, callback: LicenseResponseCallback) {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "THEOplayer triggered an onLicenseResponse") }
+        self.contentProtectionAPI?.handleLicenseResponse(integrationId: self.integrationId, keySystemId: self.keySystemId, licenseResponse: response) { licenseData, error in
+            if let error = error {
+                callback.error(error: error)
+                return
+            }
+            if let data = licenseData {
+                callback.respond(license: data)
+            } else {
+                callback.error(error: ProxyIntegrationError.licenseResponseHandlingFailed)
+            }
+        }
+    }
+    
+    func extractFairplayContentId(skdUrl: String) -> String {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "THEOplayer triggered an extractFairplayContentId") }
+        var extractedContentId = skdUrl
+        self.contentProtectionAPI?.handleExtractFairplayContentId(integrationId: self.integrationId, keySystemId: self.keySystemId, skdUrl: skdUrl) { contentId, error in
+            if let error = error {
+                extractedContentId = skdUrl
+                print(PROXY_INTEGRATION_TAG, "We encountered an issue while extracting the fairplay contentId: \(error.localizedDescription)")
+                self.contentIdExtractionSemaphore.signal()
+                return
+            }
+            extractedContentId = contentId
+            if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "Received extracted fairplay contentId \(extractedContentId) on RN bridge") }
+            self.contentIdExtractionSemaphore.signal()
+        }
+        // TODO: make extractFairplayContentId async on THEOplayer SDK
+        // FOR NOW: We temporarily block (topped to max 5 sec) the flow to retrieve the extracted contentId asynchronously.
+        _ = self.contentIdExtractionSemaphore.wait(timeout: .now() + BRIDGE_TIMEOUT)
+        return extractedContentId
+    }
+    
+    // MARK: local certificate handling
+    private func handleCertificateRequestLocally(drmConfig: THEOplayerSDK.DRMConfiguration, callback: CertificateRequestCallback) -> Bool {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "Checking for certificate in drmConfiguration...") }
+        var fairplayConfig: THEOplayerSDK.KeySystemConfiguration?
+        if let multiDrmConfigCollection = drmConfig as? THEOplayerSDK.MultiplatformDRMConfiguration {
+            let keySystemConfigurations: THEOplayerSDK.KeySystemConfigurationCollection = multiDrmConfigCollection.keySystemConfigurations
+            fairplayConfig = keySystemConfigurations.fairplay
+        } else if let fairplayDrmConfig = drmConfig as? THEOplayerSDK.FairPlayDRMConfiguration {
+            fairplayConfig = fairplayDrmConfig.fairplay
+        }
+
+        if let fairplay = fairplayConfig,
+           let certificateUrl = fairplay.certificateURL?.absoluteString,
+           certificateUrl.hasPrefix(CERTIFICATE_MARKER) {
+            let certificateBase64 = String(certificateUrl.suffix(from: CERTIFICATE_MARKER.endIndex))
+            if DEBUG_CONTENT_PROTECTION_API { print(PROXY_INTEGRATION_TAG, "Using provided base64 certificate: \(certificateBase64)") }
+            if let certificateData = Data(base64Encoded: certificateBase64, options: .ignoreUnknownCharacters) {
+                callback.respond(certificate: certificateData)
+                return true
+            }
+        }
+        
+        return false
+    }
+}

package/ios/THEOplayerRCTProxyContentProtectionIntegrationFactory.swift

@@ -0,0 +1,32 @@
+//
+//  THEOplayerRCTContentProtectionIntegrationFactory.swift
+//  Theoplayer
+//
+//  Created by William van Haevre on 28/10/2022.
+//
+
+import Foundation
+import THEOplayerSDK
+
+let PROXY_FACTORY_TAG: String = "[ProxyContentProtectionIntegrationFactory]"
+
+class THEOplayerRCTProxyContentProtectionIntegrationFactory: THEOplayerSDK.ContentProtectionIntegrationFactory {
+    private weak var contentProtectionAPI: THEOplayerRCTContentProtectionAPI?
+    private var integrationId: String!
+    private var keySystemId: String!
+    
+    init(contentProtectionAPI: THEOplayerRCTContentProtectionAPI, integrationId: String, keySystemId: String) {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_FACTORY_TAG, "Proxy ContentProtectionIntegrationFactory initialised for \(integrationId)-\(keySystemId).") }
+        self.contentProtectionAPI = contentProtectionAPI
+        self.integrationId = integrationId
+        self.keySystemId = keySystemId
+    }
+    
+    func build(configuration: THEOplayerSDK.DRMConfiguration) -> ContentProtectionIntegration {
+        if DEBUG_CONTENT_PROTECTION_API { print(PROXY_FACTORY_TAG, "Building proxy ContentProtectionIntegration for \(self.integrationId ?? "") - \(self.keySystemId ?? "").") }
+        return THEOplayerRCTProxyContentProtectionIntegration(contentProtectionAPI: self.contentProtectionAPI,
+                                                              integrationId: self.integrationId,
+                                                              keySystemId: self.keySystemId,
+                                                              drmConfig: configuration)
+    }
+}

package/ios/THEOplayerRCTSourceDescriptionBuilder.swift

@@ -7,15 +7,34 @@ import UIKit
 let SD_PROP_SOURCES: String = "sources"
 let SD_PROP_POSTER: String = "poster"
 let SD_PROP_TEXTTRACKS: String = "textTracks"
+let SD_PROP_ADS: String = "ads"
 let SD_PROP_SRC: String = "src"
 let SD_PROP_TYPE: String = "type"
+let SD_PROP_SSAI: String = "ssai"
 let SD_PROP_INTEGRATION: String = "integration"
+let SD_PROP_INTEGRATION_PARAMETERS: String = "integrationParameters"
+let SD_PROP_AVAILABILITY_TYPE: String = "availabilityType"
+let SD_PROP_AUTH_TOKEN: String = "authToken"
+let SD_PROP_STREAM_ACTIVITY_MONITOR_ID: String = "streamActivityMonitorID"
+let SD_PROP_AD_TAG_PARAMETERS: String = "adTagParameters"
+let SD_PROP_APIKEY: String = "apiKey"
+let SD_PROP_VIDEOID: String = "videoID"
+let SD_PROP_CONTENT_SOURCE_ID: String = "contentSourceID"
+let SD_PROP_ASSET_KEY: String = "assetKey"
+let SD_PROP_TIME_OFFSET: String = "timeOffset"
 let SD_PROP_SRC_LANG: String = "srclang"
 let SD_PROP_DEFAULT: String = "default"
 let SD_PROP_LABEL: String = "label"
 let SD_PROP_KIND: String = "kind"
 let SD_PROP_FORMAT: String = "format"
 let SD_PROP_CONTENT_PROTECTION: String = "contentProtection"
+let SD_PROP_FAIRPLAY: String = "fairplay"
+let SD_PROP_WIDEVINE: String = "widevine"
+let SD_PROP_CERTIFICATE: String = "certificate"
+let SD_PROP_CERTIFICATE_URL: String = "certificateURL"
+let SD_PROP_LICENSE_URL: String = "licenseAcquisitionURL"
+let SD_PROP_HEADERS: String = "headers"
+let SD_PROP_LICENSE_TYPE: String = "licenseType"
 
 let EXTENSION_HLS: String = ".m3u8"
 let EXTENSION_MP4: String = ".mp4"
@@ -30,9 +49,9 @@ let DRM_INTEGRATION_ID_KEYOS = "keyos"
 let DRM_INTEGRATION_ID_VERIMATRIX = "verimatrix"
 
 class THEOplayerRCTSourceDescriptionBuilder {
-    
+
     /**
-        Builds a THEOplayer SourceDescription that can be passed as a source for the THEOplayer.
+     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 buildSourceDescription(_ sourceData: NSDictionary) -> SourceDescription? {
@@ -40,7 +59,7 @@ class THEOplayerRCTSourceDescriptionBuilder {
         guard let sourcesData = sourceData[SD_PROP_SOURCES] else {
             return nil
         }
-        
+
         var typedSources: [TypedSource] = []
         // case: array of source objects
         if let sourcesDataArray = sourcesData as? [[String:Any]] {
@@ -66,10 +85,10 @@ class THEOplayerRCTSourceDescriptionBuilder {
                 return nil
             }
         }
-        
+
         // 2. extract 'poster'
         let poster = sourceData[SD_PROP_POSTER] as? String
-        
+
         // 3. extract 'textTracks'
         var textTrackDescriptions: [TextTrackDescription]?
         if let textTracksDataArray = sourceData[SD_PROP_TEXTTRACKS] as? [[String:Any]] {
@@ -84,20 +103,54 @@ class THEOplayerRCTSourceDescriptionBuilder {
                     return nil
                 }
             }
-            
+
         }
-        
-        // 4. construct and return SourceDescription
+
+        // 4. extract Google IMA "ads"
+        var adsDescriptions: [AdDescription]?
+
+#if ADS && 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.buildAdDescription(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.buildAdDescription(adsData) {
+                    adsDescriptions?.append(adDescription)
+                } else {
+                    if DEBUG_SOURCE_DESCRIPTION_BUIDER {
+                        print("[NATIVE] Could not create THEOplayer GoogleImaAdDescription from adsData")
+                    }
+                    return nil
+                }
+            }
+        }
+#endif
+
+        // 5. construct and return SourceDescription
         return SourceDescription(sources: typedSources,
                                  textTracks: textTrackDescriptions,
+                                 ads: adsDescriptions,
                                  poster: poster,
                                  metadata: nil)     // TODO
     }
-    
+
     // MARK: Private build methods
-    
+
     /**
-        Creates a THEOplayer TypedSource. This requires a source property for non SSAI strreams (either as a string or as an object contiaining a src property). For SSAI streams the TypeSource can be created from the ssai property.
+     Creates a THEOplayer TypedSource. This requires a source property for non SSAI strreams (either as a string or as an object contiaining a src property). For SSAI streams the TypeSource can be created from the ssai property.
      - returns: a THEOplayer TypedSource. In case of SSAI we  support GoogleDAITypedSource with GoogleDAIVodConfiguration or GoogleDAILiveConfiguration
      */
     private static func buildTypedSource(_ typedSourceData: [String:Any]) -> TypedSource? {
@@ -107,33 +160,77 @@ class THEOplayerRCTSourceDescriptionBuilder {
             // check for a contentProtection
             var contentProtection: MultiplatformDRMConfiguration?
             if let contentProtectionData = typedSourceData[SD_PROP_CONTENT_PROTECTION] as? [String:Any] {
-                contentProtection = THEOplayerRCTSourceDescriptionBuilder.buildContentProtection(contentProtectionData)
+                let sanitisedContentProtectionData = THEOplayerRCTSourceDescriptionBuilder.sanitiseContentProtectionData(contentProtectionData)
+                contentProtection = THEOplayerRCTSourceDescriptionBuilder.buildContentProtection(sanitisedContentProtectionData)
             }
-            
+
             return TypedSource(src: src,
                                type: type,
                                drm: contentProtection)
         }
 
+#if ADS && 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 GoolgeDAITypedSource from the GoogleDAIConfiguration
+                    if let config = googleDaiConfig {
+                        return GoogleDAITypedSource(ssai: config)
+                    }
+                }
+            }
+        }
+#endif
         if DEBUG_SOURCE_DESCRIPTION_BUIDER {
             print("[NATIVE] THEOplayer TypedSource requires 'src' property in 'sources' description")
         }
         return nil
     }
-    
+
     /**
-        Creates a THEOplayer TextTrackDescription. This requires a textTracks property in the RN source description.
+     Creates a THEOplayer TextTrackDescription. This requires a textTracks property in the RN source description.
      - returns: a THEOplayer TextTrackDescription
      */
     private static func buildTextTrackDescriptions(_ textTracksData: [String:Any]) -> TextTrackDescription? {
-        if let textTrackSrc = textTracksData[SD_PROP_SRC] as? String,
-           let textTrackSrcLang = textTracksData[SD_PROP_SRC_LANG] as? String {
+        if let textTrackSrc = textTracksData[SD_PROP_SRC] as? String {
+            let textTrackSrcLang = textTracksData[SD_PROP_SRC_LANG] as? String ?? ""
             let textTrackIsDefault = textTracksData[SD_PROP_DEFAULT] as? Bool
             let textTrackLabel = textTracksData[SD_PROP_LABEL] as? String
             let textTrackKind = THEOplayerRCTSourceDescriptionBuilder.extractTextTrackKind(textTracksData[SD_PROP_KIND] as? String)
             let textTrackFormat = THEOplayerRCTSourceDescriptionBuilder.extractTextTrackFormat(textTracksData[SD_PROP_FORMAT] as? String)
-            print(textTrackKind._rawValue)
-            print(textTrackFormat._rawValue)
             return TextTrackDescription(src: textTrackSrc,
                                         srclang: textTrackSrcLang,
                                         isDefault: textTrackIsDefault,
@@ -143,9 +240,105 @@ class THEOplayerRCTSourceDescriptionBuilder {
         }
         return nil
     }
-    
+
+#if ADS && GOOGLE_IMA
     /**
-        Creates a THEOplayer DRMConfiguration. This requires a contentProtection property in the RN source description.
+     Creates a THEOplayer GoogleImaAdDescription. This requires an ads property in the RN source description.
+     - returns: a THEOplayer GoogleImaAdDescription
+     */
+    static func buildAdDescription(_ adsData: [String:Any]) -> AdDescription? {
+        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.") }
+        return nil
+    }
+#endif
+
+	  /**
+     Updates the contentProtectionData to a valid iOS SDK contentProtectionData, flattening out cross SDK differences
+     - returns: a THEOplayer valid contentProtection data map
+     */
+    private static func sanitiseContentProtectionData(_ contentProtectionData: [String:Any]) -> [String:Any] {
+        var sanitisedContentProtectionData: [String:Any] = [:]
+        // integration
+        let sanitisedIntegration = contentProtectionData[SD_PROP_INTEGRATION] as? String
+        sanitisedContentProtectionData[SD_PROP_INTEGRATION] = sanitisedIntegration
+        // integrationParameters
+        let sanitisedIntegrationParameters = contentProtectionData[SD_PROP_INTEGRATION_PARAMETERS] as? [String:Any]
+        sanitisedContentProtectionData[SD_PROP_INTEGRATION_PARAMETERS] = sanitisedIntegrationParameters
+        // headers
+        if let headers = contentProtectionData[SD_PROP_HEADERS] as? [String:String] {
+            sanitisedContentProtectionData[SD_PROP_HEADERS] = headers
+        }
+        // fairplay
+        if let fairplayData = contentProtectionData[SD_PROP_FAIRPLAY] as? [String:Any] {
+            var sanitisedFairplayData: [String:Any] = [:]
+            // certificateUrl
+            if let certificateUrl = fairplayData[SD_PROP_CERTIFICATE_URL] as? String {
+                sanitisedFairplayData[SD_PROP_CERTIFICATE_URL] = certificateUrl
+            }
+            // convert certifiate into certificteUrl with marker prefix (also supported by THEOplayer Web SDK
+            if let certificate = fairplayData[SD_PROP_CERTIFICATE] as? String {
+                sanitisedFairplayData[SD_PROP_CERTIFICATE_URL] = "\(CERTIFICATE_MARKER)\(certificate)"
+            }
+            // licenseAcquisitionURL
+            if let licenseAcquisitionURL = fairplayData[SD_PROP_LICENSE_URL] as? String {
+                sanitisedFairplayData[SD_PROP_LICENSE_URL] = licenseAcquisitionURL
+            }
+            // headers
+            if let headers = fairplayData[SD_PROP_HEADERS] as? [String:String] {
+                sanitisedFairplayData[SD_PROP_HEADERS] = headers
+            }
+            // licenseType
+            if let licenseType = fairplayData[SD_PROP_LICENSE_TYPE] as? String {
+                sanitisedFairplayData[SD_PROP_LICENSE_TYPE] = licenseType
+            }
+            sanitisedContentProtectionData[SD_PROP_FAIRPLAY] = sanitisedFairplayData
+        }
+        // widevine
+        if let widevineData = contentProtectionData[SD_PROP_WIDEVINE] as? [String:Any] {
+            var sanitisedWidevineData: [String:Any] = [:]
+            // certificateUrl
+            if let certificateUrl = widevineData[SD_PROP_CERTIFICATE_URL] as? String {
+                sanitisedWidevineData[SD_PROP_CERTIFICATE_URL] = certificateUrl
+            }
+            // convert certifiate into certificteUrl with marker prefix (also supported by THEOplayer Web SDK
+            if let certificate = widevineData[SD_PROP_CERTIFICATE] as? String {
+                sanitisedWidevineData[SD_PROP_CERTIFICATE_URL] = "\(CERTIFICATE_MARKER)\(certificate)"
+            }
+            // licenseAcquisitionURL
+            if let licenseAcquisitionURL = widevineData[SD_PROP_LICENSE_URL] as? String {
+                sanitisedWidevineData[SD_PROP_LICENSE_URL] = licenseAcquisitionURL
+            }
+            // headers
+            if let headers = widevineData[SD_PROP_HEADERS] as? [String:String] {
+                sanitisedWidevineData[SD_PROP_HEADERS] = headers
+            }
+            // licenseType
+            if let licenseType = widevineData[SD_PROP_LICENSE_TYPE] as? String {
+                sanitisedWidevineData[SD_PROP_LICENSE_TYPE] = licenseType
+            }
+            sanitisedContentProtectionData[SD_PROP_WIDEVINE] = sanitisedWidevineData
+        }
+        return sanitisedContentProtectionData
+    }
+
+    /**
+     Creates a THEOplayer DRMConfiguration. This requires a contentProtection property in the RN source description.
      - returns: a THEOplayer DRMConfiguration
      */
     private static func buildContentProtection(_ contentProtectionData: [String:Any]) -> MultiplatformDRMConfiguration? {
@@ -156,7 +349,7 @@ class THEOplayerRCTSourceDescriptionBuilder {
                 case DRM_INTEGRATION_ID_EZDRM: return try JSONDecoder().decode(EzdrmDRMConfiguration.self, from: data)
                 case DRM_INTEGRATION_ID_KEYOS: return try JSONDecoder().decode(KeyOSDRMConfiguration.self, from: data)
                 case DRM_INTEGRATION_ID_VERIMATRIX: return try JSONDecoder().decode(VerimatrixDRMConfiguration.self, from: data)
-                default: print("[NATIVE] \(integration): unsupported drm integration")
+                default: return try JSONDecoder().decode(MultiplatformDRMConfiguration.self, from: data)
                 }
             } else {
                 print("[NATIVE] integration type not specified... trying default drm integration")
@@ -167,10 +360,10 @@ class THEOplayerRCTSourceDescriptionBuilder {
         }
         return nil
     }
-    
-    
+
+
     // MARK: Helper methods
-    
+
     private static func extractMimeType(_ src: String) -> String {
         if src.suffix(5) == EXTENSION_HLS {
             return MIMETYPE_HLS
@@ -181,12 +374,12 @@ class THEOplayerRCTSourceDescriptionBuilder {
         }
         return MIMETYPE_HLS
     }
-    
+
     private static func extractTextTrackKind(_ kindString: String?) -> THEOplayerSDK.TextTrackKind {
         guard let kind = kindString else {
             return THEOplayerSDK.TextTrackKind.none
         }
-        
+
         switch kind {
         case "subtitles": return THEOplayerSDK.TextTrackKind.subtitles
         case "captions": return THEOplayerSDK.TextTrackKind.captions
@@ -194,15 +387,15 @@ class THEOplayerRCTSourceDescriptionBuilder {
         case "chapters": return THEOplayerSDK.TextTrackKind.chapters
         case "metadata": return THEOplayerSDK.TextTrackKind.metadata
         default: return THEOplayerSDK.TextTrackKind.none
-            
+
         }
     }
-    
+
     private static func extractTextTrackFormat(_ formatString: String?) -> THEOplayerSDK.TextTrackFormat {
         guard let format = formatString else {
             return THEOplayerSDK.TextTrackFormat.none
         }
-        
+
         if format == "webvtt" {
             return THEOplayerSDK.TextTrackFormat.WebVTT
         } else {

package/ios/THEOplayerRCTTypeUtils.swift

@@ -0,0 +1,18 @@
+// THEOplayerRCTTypeUtils.swift
+
+import Foundation
+
+let NAN_VALUE: Double = -1.0
+let POS_INF_VALUE: Double = -2.0
+
+class THEOplayerRCTTypeUtils {
+    class func encodeInfNan(_ value: Double) -> Double {
+        if value.isNaN {
+            return NAN_VALUE
+        }
+        if value.isInfinite {
+            return POS_INF_VALUE
+        }
+        return value
+    }
+}