react-native-theoplayer 1.6.0 → 1.7.0

package/ios/THEOplayerRCTContentProtectionAPI.swift

@@ -0,0 +1,359 @@
+//
+//  THEOplayerRCTContentProtectionAPI.swift
+//  Theoplayer
+//
+//  Created by William van Haevre on 09/09/2022.
+//  Copyright © 2022 Facebook. All rights reserved.
+//
+
+import Foundation
+import UIKit
+import THEOplayerSDK
+
+let CPI_EVENT_PROP_REQUEST_ID: String = "requestId"
+let CPI_EVENT_PROP_INTEGRATION_ID: String = "integrationId"
+let CPI_EVENT_PROP_KEYSYSTEM_ID: String = "keySystemId"
+let CPI_EVENT_PROP_DRM_CONFIG: String = "drmConfig"
+let CPI_EVENT_PROP_FAIRPLAY_SKD_URL: String = "fairplaySkdUrl"
+
+let CPI_TAG: String = "[ContentProtectionIntegrationAPI]"
+let BRIDGE_REQUEST_TIMEOUT = 10.0
+
+@objc(THEOplayerRCTContentProtectionAPI)
+class THEOplayerRCTContentProtectionAPI: RCTEventEmitter {
+    
+    private var buildIntegrationCompletions: [String:(Bool) -> Void] = [:]                              // [requestId : completion]
+    private var certificateRequestCompletions: [String:(Data?, Error?) -> Void] = [:]                   // [requestId : completion]
+    private var certificateResponseCompletions: [String:(Data?, Error?) -> Void] = [:]                  // [requestId : completion]
+    private var licenseRequestCompletions: [String:(Data?, Error?) -> Void] = [:]                       // [requestId : completion]
+    private var licenseResponseCompletions: [String:(Data?, Error?) -> Void] = [:]                      // [requestId : completion]
+    private var extractFairplayCompletions: [String:(String, Error?) -> Void] = [:]                     // [requestId : completion]
+    private var requestTimers: [String:Timer] = [:]                                                     // [requestId : Timer]
+    private var requestIntegrationIds: [String:String] = [:]                                            // [requestId : integrationId]
+    private var requestKeySystemIds: [String:String] = [:]                                              // [requestId : keySystemId]
+    
+    
+    override static func moduleName() -> String! {
+        return "ContentProtectionModule"
+    }
+    
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return ["onBuildIntegration",
+                "onCertificateRequest",
+                "onCertificateResponse",
+                "onLicenseRequest",
+                "onLicenseResponse",
+                "onExtractFairplayContentId"
+        ]
+    }
+    
+    private func invalidateRequestWithId(_ requestId: String) {
+        if let timer = self.requestTimers[requestId] {
+            timer.invalidate()
+            self.requestTimers.removeValue(forKey: requestId)
+        }
+    }
+    
+    // MARK: Module actions
+    func handleBuildIntegration(integrationId: String, keySystemId: String, drmConfig: DRMConfiguration, completion: @escaping (Bool) -> Void) {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "handleBuildIntegration.") }
+        let requestId = UUID().uuidString
+        self.buildIntegrationCompletions[requestId] = completion
+        self.sendEvent(withName: "onBuildIntegration",
+                       body: THEOplayerRCTContentProtectionAggregator.aggregateDrmConfiguration(integrationId: integrationId,
+                                                                                                keySystemId: keySystemId,
+                                                                                                requestId: requestId,
+                                                                                                drmConfig: drmConfig))
+        self.requestTimers[requestId] = Timer.scheduledTimer(withTimeInterval: BRIDGE_REQUEST_TIMEOUT, repeats: false, block: { t in
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "Build timeout reached: removing completion for request with Id \(requestId)") }
+            self.invalidateRequestWithId(requestId)
+            self.buildIntegrationCompletions.removeValue(forKey: requestId)
+        })
+    }
+    
+    func handleCertificateRequest(integrationId: String, keySystemId: String, certificateRequest: CertificateRequest, completion: @escaping (Data?, Error?) -> Void) {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "handleCertificateRequest.") }
+        let requestId = UUID().uuidString
+        self.requestIntegrationIds[requestId] = integrationId
+        self.requestKeySystemIds[requestId] = keySystemId
+        self.certificateRequestCompletions[requestId] = completion
+        self.sendEvent(withName: "onCertificateRequest",
+                       body: THEOplayerRCTContentProtectionAggregator.aggregateCertificateRequest(integrationId: integrationId,
+                                                                                                  keySystemId: keySystemId,
+                                                                                                  requestId: requestId,
+                                                                                                  certificateRequest: certificateRequest))
+        self.requestTimers[requestId] = Timer.scheduledTimer(withTimeInterval: BRIDGE_REQUEST_TIMEOUT, repeats: false, block: { t in
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onCertificateRequest timeout reached: removing completion for request with Id \(requestId)") }
+            self.invalidateRequestWithId(requestId)
+            self.requestIntegrationIds.removeValue(forKey: requestId)
+            self.requestKeySystemIds.removeValue(forKey: requestId)
+            self.certificateRequestCompletions.removeValue(forKey: requestId)
+        })
+    }
+    
+    func handleCertificateResponse(integrationId: String, keySystemId: String, certificateResponse: CertificateResponse, completion: @escaping (Data?, Error?) -> Void) {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "handleCertificateResponse.") }
+        let requestId = UUID().uuidString
+        self.certificateResponseCompletions[requestId] = completion
+        self.sendEvent(withName: "onCertificateResponse",
+                       body: THEOplayerRCTContentProtectionAggregator.aggregateCertificateResponse(integrationId: integrationId,
+                                                                                                   keySystemId: keySystemId,
+                                                                                                   requestId: requestId,
+                                                                                                   certificateResponse: certificateResponse))
+        self.requestTimers[requestId] = Timer.scheduledTimer(withTimeInterval: BRIDGE_REQUEST_TIMEOUT, repeats: false, block: { t in
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onCertificateResponse timeout reached: removing completion for request with Id \(requestId)") }
+            self.invalidateRequestWithId(requestId)
+            self.certificateResponseCompletions.removeValue(forKey: requestId)
+        })
+    }
+    
+    func handleLicenseRequest(integrationId: String, keySystemId: String, licenseRequest: LicenseRequest, completion: @escaping (Data?, Error?) -> Void) {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "handleLicenseRequest.") }
+        let requestId = UUID().uuidString
+        self.requestIntegrationIds[requestId] = integrationId
+        self.requestKeySystemIds[requestId] = keySystemId
+        self.licenseRequestCompletions[requestId] = completion
+        self.sendEvent(withName: "onLicenseRequest",
+                       body: THEOplayerRCTContentProtectionAggregator.aggregateLicenseRequest(integrationId: integrationId,
+                                                                                              keySystemId: keySystemId,
+                                                                                              requestId: requestId,
+                                                                                              licenseRequest: licenseRequest))
+        self.requestTimers[requestId] = Timer.scheduledTimer(withTimeInterval: BRIDGE_REQUEST_TIMEOUT, repeats: false, block: { t in
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onLicenseRequest timeout reached: removing completion for request with Id \(requestId)") }
+            self.invalidateRequestWithId(requestId)
+            self.requestIntegrationIds.removeValue(forKey: requestId)
+            self.requestKeySystemIds.removeValue(forKey: requestId)
+            self.licenseRequestCompletions.removeValue(forKey: requestId)
+        })
+    }
+    
+    func handleLicenseResponse(integrationId: String, keySystemId: String, licenseResponse: LicenseResponse, completion: @escaping (Data?, Error?) -> Void) {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "handleLicenseResponse.") }
+        let requestId = UUID().uuidString
+        self.licenseResponseCompletions[requestId] = completion
+        self.sendEvent(withName: "onLicenseResponse",
+                       body: THEOplayerRCTContentProtectionAggregator.aggregateLicenseResponse(integrationId: integrationId,
+                                                                                               keySystemId: keySystemId,
+                                                                                               requestId: requestId,
+                                                                                               licenseResponse: licenseResponse))
+        self.requestTimers[requestId] = Timer.scheduledTimer(withTimeInterval: BRIDGE_REQUEST_TIMEOUT, repeats: false, block: { t in
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onLicenseResponse timeout reached: removing completion for request with Id \(requestId)") }
+            self.invalidateRequestWithId(requestId)
+            self.licenseResponseCompletions.removeValue(forKey: requestId)
+        })
+    }
+    
+    func handleExtractFairplayContentId(integrationId: String, keySystemId: String, skdUrl: String, completion: @escaping (String, Error?) -> Void) {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "handleExtractFairplayContentId.") }
+        let requestId = UUID().uuidString
+        self.extractFairplayCompletions[requestId] = completion
+        self.sendEvent(withName: "onExtractFairplayContentId", body: [
+            CPI_EVENT_PROP_INTEGRATION_ID: integrationId,
+            CPI_EVENT_PROP_KEYSYSTEM_ID: keySystemId,
+            CPI_EVENT_PROP_REQUEST_ID: requestId,
+            CPI_EVENT_PROP_FAIRPLAY_SKD_URL: skdUrl
+        ])
+        self.requestTimers[requestId] = Timer.scheduledTimer(withTimeInterval: BRIDGE_REQUEST_TIMEOUT, repeats: false, block: { t in
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "Fairplay contentId extraction timeout reached: removing completion for request with Id \(requestId)") }
+            self.invalidateRequestWithId(requestId)
+            self.extractFairplayCompletions.removeValue(forKey: requestId)
+        })
+    }
+    
+    // MARK: Incoming JS Notifications
+    @objc(registerContentProtectionIntegration:keySystemId:)
+    func registerContentProtectionIntegration(_ integrationId: String, keySystemId: String) -> Void {
+        if keySystemId == "fairplay" {
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "Registering ContentProtectionIntegration for \(integrationId) - \(keySystemId)") }
+            // Create a proxy factory
+            let integrationFactory = THEOplayerRCTProxyContentProtectionIntegrationFactory(contentProtectionAPI: self,
+                                                                                           integrationId: integrationId,
+                                                                                           keySystemId: keySystemId)
+            // Register that factory on the THEOplayerSDK:
+            let keySystem = self.keySystemFromString(keySystemId)
+            THEOplayerSDK.THEOplayer.registerContentProtectionIntegration(integrationId: integrationId,
+                                                                          keySystem: keySystem,
+                                                                          integrationFactory: integrationFactory)
+        } else {
+            if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "Prevented registering ContentProtectionIntegration for \(integrationId) - \(keySystemId)") }
+        }
+    }
+    
+    @objc(onBuildProcessed:)
+    func onBuildProcessed(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onBuildProcessed.") }
+        if let requestId = result["requestId"] as? String,
+           let resultString = result["resultString"] as? String,
+           let completion = self.buildIntegrationCompletions.removeValue(forKey: requestId) {
+            self.invalidateRequestWithId(requestId)
+            completion(resultString == "success")
+        } else {
+            print(CPI_TAG, "Failed to process buildIntegration result")
+        }
+    }
+    
+    @objc(onCertificateRequestProcessedAsRequest:)
+    func onCertificateRequestProcessedAsRequest(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onCertificateRequestProcessedAsRequest.") }
+        if let requestId = result["requestId"] as? String,
+           let completion = self.certificateRequestCompletions.removeValue(forKey: requestId),
+           let integrationId = self.requestIntegrationIds.removeValue(forKey: requestId),
+           let keySystemId = self.requestKeySystemIds.removeValue(forKey: requestId),
+           let urlString = result["url"] as? String,
+           let url = URL(string: urlString),
+           let method = result["method"] as? String,
+           let headers = result["headers"] as? [String:String] {
+            var bodyData: Data?
+            if let base64body = result["base64body"] as? String {
+                bodyData = Data(base64Encoded: base64body, options: .ignoreUnknownCharacters)
+            }
+            self.invalidateRequestWithId(requestId)
+            THEOplayerRCTNetworkUtils.shared.requestFromUrl(url: url, method: method, body: bodyData, headers: headers) { data, statusCode, responseHeaders, error in
+                if let responseError = error {
+                    print(CPI_TAG, "Certificate request failure: error = \(responseError.localizedDescription)")
+                } else if statusCode >= 400 {
+                    print("Certificate request failure: statusCode = \(statusCode)")
+                } else {
+                    if DEBUG_CONTENT_PROTECTION_API {print(CPI_TAG, "Certificate request success: statusCode = \(statusCode)") }
+                    let certificateRequest = CertificateRequest(url: urlString, method: method, headers: headers, body: bodyData)
+                    let certificateResponse = CertificateResponse(certificateRequest: certificateRequest, url: urlString, status: statusCode, statusText: "", headers: responseHeaders, body: data ?? Data())
+                    self.handleCertificateResponse(integrationId: integrationId, keySystemId: keySystemId, certificateResponse: certificateResponse) { data, error in
+                        completion(data, error)
+                    }
+                }
+            }
+        } else {
+            print(CPI_TAG, "Failed to process certificate request as request")
+        }
+    }
+    
+    @objc(onCertificateRequestProcessedAsCertificate:)
+    func onCertificateRequestProcessedAsCertificate(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onCertificateRequestProcessedAsCertificate.") }
+        if let requestId = result["requestId"] as? String,
+           let completion = self.certificateRequestCompletions.removeValue(forKey: requestId) {
+            var bodyData = Data()
+            if let base64body = result["base64body"] as? String {
+                bodyData = Data(base64Encoded: base64body, options: .ignoreUnknownCharacters) ?? Data()
+            }
+            self.invalidateRequestWithId(requestId)
+            completion(bodyData, nil)
+        } else {
+            print(CPI_TAG, "Failed to process certificate request as certificate")
+        }
+    }
+    
+    @objc(onCertificateResponseProcessed:)
+    func onCertificateResponseProcessed(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onCertificateResponseProcessed.") }
+        if let requestId = result["requestId"] as? String,
+           let completion = self.certificateResponseCompletions.removeValue(forKey: requestId) {
+            var bodyData = Data()
+            if let base64body = result["base64body"] as? String {
+                bodyData = Data(base64Encoded: base64body, options: .ignoreUnknownCharacters) ?? Data()
+            }
+            self.invalidateRequestWithId(requestId)
+            completion(bodyData, nil)
+        } else {
+            print(CPI_TAG, "Failed to process certificate response")
+        }
+    }
+    
+    @objc(onLicenseRequestProcessedAsRequest:)
+    func onLicenseRequestProcessedAsRequest(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onLicenseRequestProcessedAsRequest.") }
+        if let requestId = result["requestId"] as? String,
+           let completion = self.licenseRequestCompletions.removeValue(forKey: requestId),
+           let integrationId = self.requestIntegrationIds.removeValue(forKey: requestId),
+           let keySystemId = self.requestKeySystemIds.removeValue(forKey: requestId),
+           let urlString = result["url"] as? String,
+           let url = URL(string: urlString),
+           let method = result["method"] as? String,
+           let headers = result["headers"] as? [String:String] {
+            var bodyData: Data?
+            if let base64body = result["base64body"] as? String {
+                bodyData = Data(base64Encoded: base64body, options: .ignoreUnknownCharacters)
+            }
+            self.invalidateRequestWithId(requestId)
+            THEOplayerRCTNetworkUtils.shared.requestFromUrl(url: url, method: method, body: bodyData, headers: headers) { data, statusCode, responseHeaders, error in
+                if let responseError = error {
+                    print(CPI_TAG, "License request failure: error = \(responseError.localizedDescription)")
+                } else if statusCode >= 400 {
+                    print(CPI_TAG, "License request failure: statusCode = \(statusCode)")
+                } else {
+                    if DEBUG_CONTENT_PROTECTION_API {print(CPI_TAG, "License request success: statusCode = \(statusCode)") }
+                    let licenseRequest = LicenseRequest(url: urlString, method: method, headers: headers, body: bodyData, fairplaySkdUrl: nil, useCredentials: false)
+                    let licenseResponse = LicenseResponse(licenseRequest: licenseRequest, url: urlString, status: statusCode, statusText: "", headers: responseHeaders, body: data ?? Data())
+                    self.handleLicenseResponse(integrationId: integrationId, keySystemId: keySystemId, licenseResponse: licenseResponse) { data, error in
+                        completion(data, error)
+                    }
+                }
+            }
+        } else {
+            print(CPI_TAG, "Failed to process license request as request")
+        }
+    }
+    
+    @objc(onLicenseRequestProcessedAsLicense:)
+    func onLicenseRequestProcessedAsLicense(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onLicenseRequestProcessedAsLicense.") }
+        if let requestId = result["requestId"] as? String,
+           let completion = self.licenseRequestCompletions.removeValue(forKey: requestId) {
+            var bodyData = Data()
+            if let base64body = result["base64body"] as? String {
+                bodyData = Data(base64Encoded: base64body, options: .ignoreUnknownCharacters) ?? Data()
+            }
+            self.invalidateRequestWithId(requestId)
+            completion(bodyData, nil)
+        } else {
+            print(CPI_TAG, "Failed to process license request as license")
+        }
+    }
+    
+    @objc(onLicenseResponseProcessed:)
+    func onLicenseResponseProcessed(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onLicenseResponseProcessed.") }
+        if let requestId = result["requestId"] as? String,
+           let completion = self.licenseResponseCompletions.removeValue(forKey: requestId) {
+            var bodyData = Data()
+            if let base64body = result["base64body"] as? String {
+                bodyData = Data(base64Encoded: base64body, options: .ignoreUnknownCharacters) ?? Data()
+            }
+            self.invalidateRequestWithId(requestId)
+            completion(bodyData, nil)
+        } else {
+            print(CPI_TAG, "Failed to process license response")
+        }
+    }
+    
+    @objc(onExtractFairplayContentIdProcessed:)
+    func onExtractFairplayContentIdProcessed(_ result: NSDictionary) -> Void {
+        if DEBUG_CONTENT_PROTECTION_API { print(CPI_TAG, "onExtractFairplayContentIdProcessed.") }
+        if let requestId = result["requestId"] as? String,
+           let contentId = result["contentId"] as? String,
+           let completion = self.extractFairplayCompletions.removeValue(forKey: requestId) {
+            self.invalidateRequestWithId(requestId)
+            completion(contentId, nil)
+        } else {
+            print(CPI_TAG, "Failed to process extracted contentId result")
+        }
+    }
+    
+    // MARK: Helpers
+    private func keySystemFromString(_ keySystemIdString: String) -> THEOplayerSDK.KeySystemId {
+        switch keySystemIdString.lowercased() {
+        case "fairplay":
+            return .FAIRPLAY
+        case "widevine":
+            return .WIDEVINE
+        case "playready":
+            return .PLAYREADY
+        default:
+            return .FAIRPLAY // fallback to fairplay on iOS...
+        }
+    }
+}

package/ios/THEOplayerRCTContentProtectionAggregator.swift

@@ -0,0 +1,119 @@
+// THEOplayerRCTContentProtectionAggregator.swift
+
+import Foundation
+import THEOplayerSDK
+
+let DRM_PROP_INTEGRATION: String = "integration"
+let DRM_PROP_INTEGRATION_ID: String = "integrationId"
+let DRM_PROP_REQUEST_ID: String = "requestId"
+let DRM_PROP_KEYSYSTEM_ID: String = "keySystemId"
+let DRM_PROP_DRM_CONFIG: String = "drmConfig"
+let DRM_PROP_URL: String = "url"
+let DRM_PROP_METHOD: String = "method"
+let DRM_PROP_HEADERS: String = "headers"
+let DRM_PROP_INTEGRATION_PARAMS: String = "integrationParameters"
+let DRM_PROP_FAIRPLAY: String = "fairplay"
+let DRM_PROP_WIDEVINE: String = "widevine"
+let DRM_PROP_LICENSE_URL: String = "licenseAcquisitionURL"
+let DRM_PROP_CERTIFICATE_URL: String = "certificateURL"
+let DRM_PROP_BASE64_BODY: String = "base64body"
+let DRM_PROP_FAIRPLAY_SKD_URL: String = "fairplaySkdUrl"
+let DRM_PROP_STATUS: String = "status"
+let DRM_PROP_STATUS_TEXT: String = "statusText"
+let DRM_PROP_REQUEST: String = "request"
+
+let CPI_AGGREGATOR_TAG: String = "[ContentProtectionAggregator]"
+
+class THEOplayerRCTContentProtectionAggregator {
+    
+    class func aggregateDrmConfiguration(integrationId: String, keySystemId: String, requestId: String, drmConfig: THEOplayerSDK.DRMConfiguration) -> [String:Any] {
+        var aggregatedData: [String:Any] = THEOplayerRCTContentProtectionAggregator.bridgeData(integrationId: integrationId, keySystemId: keySystemId, requestId: requestId)
+        
+        var aggregatedDrmConfig: [String:Any] = [:]
+        aggregatedDrmConfig[DRM_PROP_INTEGRATION] = drmConfig.customIntegrationId ?? "unknown"
+        aggregatedDrmConfig[DRM_PROP_INTEGRATION_PARAMS] = drmConfig.integrationParameters
+        if let multiDrmConfigCollection = drmConfig as? THEOplayerSDK.MultiplatformDRMConfiguration {
+            let keySystemConfigurations: THEOplayerSDK.KeySystemConfigurationCollection = multiDrmConfigCollection.keySystemConfigurations
+            if let fairplayConfig: THEOplayerSDK.KeySystemConfiguration = keySystemConfigurations.fairplay {
+                aggregatedDrmConfig[DRM_PROP_FAIRPLAY] = THEOplayerRCTContentProtectionAggregator.aggregateKeySystemConfiguration(keySystemConfig: fairplayConfig)
+            }
+            if let widevineConfig: THEOplayerSDK.KeySystemConfiguration = keySystemConfigurations.widevine {
+                aggregatedDrmConfig[DRM_PROP_WIDEVINE] = THEOplayerRCTContentProtectionAggregator.aggregateKeySystemConfiguration(keySystemConfig: widevineConfig)
+            }
+        } else if let fairplayDrmConfig = drmConfig as? THEOplayerSDK.FairPlayDRMConfiguration {
+            aggregatedDrmConfig[DRM_PROP_FAIRPLAY] = THEOplayerRCTContentProtectionAggregator.aggregateKeySystemConfiguration(keySystemConfig: fairplayDrmConfig.fairplay)
+        }
+        aggregatedData[DRM_PROP_DRM_CONFIG] = aggregatedDrmConfig
+        return aggregatedData
+    }
+    
+    class func aggregateCertificateRequest(integrationId: String, keySystemId: String, requestId: String, certificateRequest: THEOplayerSDK.Request) -> [String:Any] {
+        var aggregatedData: [String:Any] = THEOplayerRCTContentProtectionAggregator.bridgeData(integrationId: integrationId, keySystemId: keySystemId, requestId: requestId)
+        aggregatedData[DRM_PROP_URL] = certificateRequest.url
+        aggregatedData[DRM_PROP_METHOD] = certificateRequest.method
+        aggregatedData[DRM_PROP_HEADERS] = certificateRequest.headers
+        if let body = certificateRequest.body {
+            aggregatedData[DRM_PROP_BASE64_BODY] = body.base64EncodedString()
+        }
+        return aggregatedData
+    }
+    
+    class func aggregateCertificateResponse(integrationId: String, keySystemId: String, requestId: String, certificateResponse: THEOplayerSDK.Response) -> [String:Any] {
+        var aggregatedData: [String:Any] = THEOplayerRCTContentProtectionAggregator.bridgeData(integrationId: integrationId, keySystemId: keySystemId, requestId: requestId)
+        aggregatedData[DRM_PROP_URL] = certificateResponse.url
+        aggregatedData[DRM_PROP_STATUS] = certificateResponse.status
+        aggregatedData[DRM_PROP_STATUS_TEXT] = certificateResponse.statusText
+        aggregatedData[DRM_PROP_HEADERS] = certificateResponse.headers
+        aggregatedData[DRM_PROP_REQUEST] = THEOplayerRCTContentProtectionAggregator.aggregateCertificateRequest(integrationId:integrationId,
+                                                                                                                keySystemId:keySystemId,
+                                                                                                                requestId: requestId,
+                                                                                                                certificateRequest: certificateResponse.request)
+        aggregatedData[DRM_PROP_BASE64_BODY] = certificateResponse.body.base64EncodedString()
+        return aggregatedData
+    }
+    
+    class func aggregateLicenseRequest(integrationId: String, keySystemId: String, requestId: String, licenseRequest: THEOplayerSDK.Request) -> [String:Any] {
+        var aggregatedData: [String:Any] = THEOplayerRCTContentProtectionAggregator.bridgeData(integrationId: integrationId, keySystemId: keySystemId, requestId: requestId)
+        aggregatedData[DRM_PROP_URL] = licenseRequest.url
+        aggregatedData[DRM_PROP_METHOD] = licenseRequest.method
+        aggregatedData[DRM_PROP_HEADERS] = licenseRequest.headers
+        aggregatedData[DRM_PROP_FAIRPLAY_SKD_URL] = (licenseRequest as? THEOplayerSDK.LicenseRequest)?.fairplaySkdUrl ?? ""
+        if let body = licenseRequest.body {
+            aggregatedData[DRM_PROP_BASE64_BODY] = body.base64EncodedString()
+        }
+        return aggregatedData
+    }
+    
+    class func aggregateLicenseResponse(integrationId: String, keySystemId: String, requestId: String, licenseResponse: THEOplayerSDK.Response) -> [String:Any] {
+        var aggregatedData: [String:Any] = THEOplayerRCTContentProtectionAggregator.bridgeData(integrationId: integrationId, keySystemId: keySystemId, requestId: requestId)
+        aggregatedData[DRM_PROP_URL] = licenseResponse.url
+        aggregatedData[DRM_PROP_STATUS] = licenseResponse.status
+        aggregatedData[DRM_PROP_STATUS_TEXT] = licenseResponse.statusText
+        aggregatedData[DRM_PROP_HEADERS] = licenseResponse.headers
+        aggregatedData[DRM_PROP_REQUEST] = THEOplayerRCTContentProtectionAggregator.aggregateLicenseRequest(integrationId:integrationId,
+                                                                                                            keySystemId:keySystemId,
+                                                                                                            requestId: requestId,
+                                                                                                            licenseRequest: licenseResponse.request)
+        aggregatedData[DRM_PROP_BASE64_BODY] = licenseResponse.body.base64EncodedString()
+        return aggregatedData
+    }
+    
+    private class func bridgeData(integrationId: String, keySystemId: String, requestId: String) -> [String:Any] {
+        var aggregatedData: [String:Any] = [:]
+        aggregatedData[DRM_PROP_REQUEST_ID] = requestId
+        aggregatedData[DRM_PROP_INTEGRATION_ID] = integrationId
+        aggregatedData[DRM_PROP_KEYSYSTEM_ID] = keySystemId
+        return aggregatedData
+    }
+    
+    private class func aggregateKeySystemConfiguration(keySystemConfig: THEOplayerSDK.KeySystemConfiguration) -> [String:Any] {
+        var aggregatedKeySystem: [String:Any] = [:]
+        if let licenseURL = keySystemConfig.licenseAcquisitionURL?.absoluteString {
+            aggregatedKeySystem[DRM_PROP_LICENSE_URL] = licenseURL
+        }
+        if let certificateURL = keySystemConfig.certificateURL?.absoluteString {
+            aggregatedKeySystem[DRM_PROP_CERTIFICATE_URL] = certificateURL
+        }
+        return aggregatedKeySystem
+    }
+}

package/ios/THEOplayerRCTDebug.swift

@@ -4,13 +4,22 @@
 let DEBUG = false
 
 // Debug flag to monitor incoming Theoplayer events
-let DEBUG_THEOPLAYER_EVENTS = DEBUG && true
+let DEBUG_THEOPLAYER_EVENTS = DEBUG && false
 
 // Debug flag to monitor eventhandler setup and breakdown
-let DEBUG_EVENTHANDLER = DEBUG && true
+let DEBUG_EVENTHANDLER = DEBUG && false
 
 // Debug flag to monitor the interactions for each view with its underlying theoplayer instance
-let DEBUG_THEOPLAYER_INTERACTION = DEBUG && true
+let DEBUG_THEOPLAYER_INTERACTION = DEBUG && false
+
+// Debug flag to monitor contentProtection integration handling
+let DEBUG_CONTENT_PROTECTION_API = DEBUG && false
 
 // Debug flag to monitor all updates made  on bridged properties
-let DEBUG_PROP_UPDATES = DEBUG && true
+let DEBUG_PROP_UPDATES = DEBUG && false
+
+// Debug flag to monitor correct SourceDescription buildup
+let DEBUG_SOURCE_DESCRIPTION_BUIDER = DEBUG && false
+
+// Debug flag to monitor ads API usage
+let DEBUG_ADS_API = DEBUG && false

package/ios/THEOplayerRCTMetadataAggregator.swift

@@ -39,7 +39,7 @@ class THEOplayerRCTMetadataAggregator {
             EVENT_PROP_SELECTED_TEXT_TRACK: THEOplayerRCTMetadataAggregator.selectedTextTrack(textTracks: textTracks),
             EVENT_PROP_SELECTED_AUDIO_TRACK: THEOplayerRCTMetadataAggregator.selectedAudioTrack(audioTracks: audioTracks),
             EVENT_PROP_SELECTED_VIDEO_TRACK: THEOplayerRCTMetadataAggregator.selectedVideoTrack(videoTracks: videoTracks),
-            EVENT_PROP_DURATION: player.duration ?? 0
+            EVENT_PROP_DURATION: THEOplayerRCTTypeUtils.encodeInfNan((player.duration ?? Double.nan) * 1000)
         ]
     }
 

package/ios/THEOplayerRCTNetworkUtils.swift

@@ -0,0 +1,54 @@
+//
+//  THEOplayerRCTNetworkUtils.swift
+//  Theoplayer
+//
+//  Created by William van Haevre on 14/11/2022.
+//
+
+import Foundation
+
+class THEOplayerRCTNetworkUtils: NSObject, URLSessionDataDelegate {
+    // singleton setup
+    static let shared = THEOplayerRCTNetworkUtils()
+    
+    private var defaultUrlSession: URLSession!
+    private var defaultOperationQueue = OperationQueue()
+    
+    private override init() {
+        super.init()
+        let defaultConfig: URLSessionConfiguration = URLSessionConfiguration.default
+        defaultConfig.networkServiceType = NSURLRequest.NetworkServiceType.default
+        self.defaultOperationQueue.maxConcurrentOperationCount = 16
+        self.defaultOperationQueue.qualityOfService = .userInteractive
+        self.defaultUrlSession = URLSession(configuration: defaultConfig, delegate: nil, delegateQueue: self.defaultOperationQueue)
+    }
+    
+    func requestFromUrl(url: URL, method: String, body: Data?, headers: [String:String], completion:((Data?, Int, [String:String], Error?) -> Void)?) {
+        var request = URLRequest(url: url)
+        request.httpMethod = method
+        for (key, value) in headers {
+            request.addValue(value, forHTTPHeaderField: key)
+        }
+        request.httpBody = body
+        let task = self.defaultUrlSession.dataTask(with: request) { data, response, error in
+            if let error = error {
+                print("request Error: \(error.localizedDescription)")
+                return
+            }
+            if let urlResponse = response as? HTTPURLResponse {
+                let statusCode = urlResponse.statusCode
+                let responseHeaders = urlResponse.allHeaderFields
+                var allHeaders: [String:String] = [:]
+                for (key, value) in responseHeaders {
+                    if let headerKey = key as? String,
+                       let headerValue = value as? String {
+                        allHeaders[headerKey] = headerValue
+                    }
+                }
+                completion?(data, statusCode, allHeaders, error)
+            }
+        }
+        // start the task
+        task.resume()
+    }
+}