react-native-theoplayer 1.7.1 → 1.8.0

package/ios/THEOplayerRCTCastAPI.swift

@@ -0,0 +1,275 @@
+//
+//  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_CAST_ACCESS_FAILURE = "cast_access_failure"
+let ERROR_CODE_CHROMECAST_ACCESS_FAILURE = "chromecast_access_failure"
+let ERROR_CODE_AIRPLAY_ACCESS_FAILURE = "airplay_access_failure"
+
+let ERROR_MESSAGE_CASTING_UNSUPPORTED_FEATURE = "Chromecast and Airplay are not supported by the provided iOS SDK"
+let ERROR_MESSAGE_CHROMECAST_UNSUPPORTED_FEATURE = "Chromecast is not supported by the provided iOS SDK"
+let ERROR_MESSAGE_AIRPLAY_UNSUPPORTED_FEATURE = "Airplay is not supported by the provided iOS SDK"
+let ERROR_MESSAGE_CAST_ACCESS_FAILURE = "Could not access THEOplayer Cast Module"
+let ERROR_MESSAGE_CHROMECAST_ACCESS_FAILURE = "Could not access THEOplayer Chromecast API"
+let ERROR_MESSAGE_AIRPLAY_ACCESS_FAILURE = "Could not access THEOplayer Airplay API"
+
+@objc(THEOplayerRCTCastAPI)
+class THEOplayerRCTCastAPI: NSObject, RCTBridgeModule {
+    @objc var bridge: RCTBridge!
+    
+    static func moduleName() -> String! {
+        return "CastModule"
+    }
+    
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    // MARK: CHROMECAST AND AIRPLAY
+    
+#if os(iOS)
+    
+    @objc(casting:resolver:rejecter:)
+    func casting(_ 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() {
+                resolve(cast.casting)
+            } else {
+                reject(ERROR_CODE_CAST_ACCESS_FAILURE, ERROR_MESSAGE_CAST_ACCESS_FAILURE, nil)
+                if DEBUG_CAST_API { print("[NATIVE] Could not retrieve current casting status (cast module unavailable).") }
+            }
+        }
+    }
+    
+#else
+    
+    @objc(casting:resolver:rejecter:)
+    func casting(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) -> Void {
+        if DEBUG_CAST_API { print(ERROR_MESSAGE_CASTING_UNSUPPORTED_FEATURE) }
+        resolve(false)
+    }
+    
+#endif
+    
+    
+    
+    // MARK: CHROMECAST SPECIFIC
+
+#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
+    
+    
+    
+    // MARK: AIRPLAY SPECIFIC
+
+#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/THEOplayerRCTDebug.swift

@@ -23,3 +23,6 @@ let DEBUG_SOURCE_DESCRIPTION_BUIDER = DEBUG && false
 
 // Debug flag to monitor ads API usage
 let DEBUG_ADS_API = DEBUG && false
+
+// Debug flag to monitor cast API usage
+let DEBUG_CAST_API = DEBUG && false

package/ios/THEOplayerRCTSourceDescriptionBuilder.swift

@@ -8,6 +8,7 @@ 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_METADATA: String = "metadata"
 let SD_PROP_SRC: String = "src"
 let SD_PROP_TYPE: String = "type"
 let SD_PROP_SSAI: String = "ssai"
@@ -35,6 +36,13 @@ 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 SD_PROP_METADATA_IMAGES: String = "images"
+let SD_PROP_METADATA_IMAGE_HEIGHT: String = "height"
+let SD_PROP_METADATA_IMAGE_WIDTH: String = "width"
+let SD_PROP_METADATA_RELEASE_DATE: String = "releaseDate"
+let SD_PROP_METADATA_RELEASE_YEAR: String = "releaseYear"
+let SD_PROP_METADATA_TITLE: String = "title"
+let SD_PROP_METADATA_SUBTITLE: String = "subtitle"
 
 let EXTENSION_HLS: String = ".m3u8"
 let EXTENSION_MP4: String = ".mp4"
@@ -138,13 +146,19 @@ class THEOplayerRCTSourceDescriptionBuilder {
             }
         }
 #endif
+        
+        // 5. extract metadata
+        var metadataDescription: MetadataDescription?
+        if let metadataData = sourceData[SD_PROP_METADATA] as? [String:Any] {
+            metadataDescription = THEOplayerRCTSourceDescriptionBuilder.buildMetaDataDescription(metadataData)
+        }
 
-        // 5. construct and return SourceDescription
+        // 6. construct and return SourceDescription
         return SourceDescription(sources: typedSources,
                                  textTracks: textTrackDescriptions,
                                  ads: adsDescriptions,
                                  poster: poster,
-                                 metadata: nil)     // TODO
+                                 metadata: metadataDescription)
     }
 
     // MARK: Private build methods
@@ -169,7 +183,7 @@ class THEOplayerRCTSourceDescriptionBuilder {
                                drm: contentProtection)
         }
 
-#if ADS && GOOGLE_DAI
+#if os(iOS) && 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,
@@ -206,7 +220,7 @@ class THEOplayerRCTSourceDescriptionBuilder {
                         }
                         return nil
                     }
-                    // when valid, create a GoolgeDAITypedSource from the GoogleDAIConfiguration
+                    // when valid, create a GoogleDAITypedSource from the GoogleDAIConfiguration
                     if let config = googleDaiConfig {
                         return GoogleDAITypedSource(ssai: config)
                     }
@@ -267,31 +281,89 @@ class THEOplayerRCTSourceDescriptionBuilder {
         return nil
     }
 #endif
+    
+    /**
+     Creates a THEOplayer MetadataDescription. This requires a metadata property in the RN source description.
+     - returns: a THEOplayer MetadataDescription
+     */
+    static func buildMetaDataDescription(_ metadataData: [String:Any]) -> MetadataDescription? {
+        // first extract explicit casting metadata:
+#if os(iOS)
+        var images: [ChromecastMetadataImage]?
+        if let metadataImagesArrayData = metadataData[SD_PROP_METADATA_IMAGES] as? [[String:Any]] {
+            images = THEOplayerRCTSourceDescriptionBuilder.buildChromecastMetaDataImagesArray(metadataImagesArrayData)
+        }
+        let type = THEOplayerRCTSourceDescriptionBuilder.buildChromecastMetadataType(metadataData[SD_PROP_TYPE] as? String)
+        let releaseDate = metadataData[SD_PROP_METADATA_RELEASE_DATE] as? String
+        let releaseYear = metadataData[SD_PROP_METADATA_RELEASE_YEAR] as? Int
+        let title = metadataData[SD_PROP_METADATA_TITLE] as? String
+        let subtitle = metadataData[SD_PROP_METADATA_SUBTITLE] as? String
+        // all the non-casting related metadata goes in the metadataKeys:
+        let metadataKeys = metadataData.filter { metadataElement in
+            !(metadataElement.key == SD_PROP_TYPE || metadataElement.key == SD_PROP_METADATA_IMAGES)
+        }
+        return ChromecastMetadataDescription(images: images,
+                                             releaseDate: releaseDate,
+                                             releaseYear: releaseYear,
+                                             title: title,
+                                             subtitle: subtitle,
+                                             type: type,
+                                             metadataKeys: metadataKeys)
+#else
+        let title = metadataData[SD_PROP_METADATA_TITLE] as? String
+        return MetadataDescription(metadataKeys: metadataData, title: title)
+#endif
+    }
+    
+#if os(iOS)
+    static func buildChromecastMetadataType(_ metadataType: String?) -> ChromecastMetadataType {
+        guard let typeString = metadataType else {
+            return ChromecastMetadataType.GENERIC
+        }
+        switch typeString {
+        case "none": return ChromecastMetadataType.NONE
+        case "audio": return ChromecastMetadataType.AUDIO
+        case "tv-show": return ChromecastMetadataType.TV_SHOW
+        case "generic": return ChromecastMetadataType.GENERIC
+        case "movie": return ChromecastMetadataType.MOVIE
+        default: return ChromecastMetadataType.GENERIC
+        }
+    }
+    
+    static func buildChromecastMetaDataImagesArray(_ metadataImagesArrayData: [[String:Any]]) -> [ChromecastMetadataImage]? {
+        var images: [ChromecastMetadataImage] = []
+        for metadataImageData in metadataImagesArrayData {
+            if let image: ChromecastMetadataImage = THEOplayerRCTSourceDescriptionBuilder.buildChromecastMetaDataImage(metadataImageData) {
+                images.append(image)
+            }
+        }
+        return images.count > 0 ? images : nil
+    }
+    
+    static func buildChromecastMetaDataImage(_ metadataImageData: [String:Any]) -> ChromecastMetadataImage? {
+        if let src = metadataImageData[SD_PROP_SRC] as? String,
+           let width = metadataImageData[SD_PROP_METADATA_IMAGE_WIDTH] as? Int,
+           let height = metadataImageData[SD_PROP_METADATA_IMAGE_HEIGHT] as? Int {
+            return ChromecastMetadataImage(src: src, width: width, height: height)
+        }
+        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
+        var sanitisedContentProtectionData: [String:Any] = contentProtectionData
+        // fairplay update
         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
+            // convert certificate into certificateUrl 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)"
             }
@@ -309,14 +381,14 @@ class THEOplayerRCTSourceDescriptionBuilder {
             }
             sanitisedContentProtectionData[SD_PROP_FAIRPLAY] = sanitisedFairplayData
         }
-        // widevine
+        // widevine update
         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
+            // convert certificate into certificateUrl 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)"
             }

package/ios/THEOplayerRCTTrackEventTypes.swift

@@ -0,0 +1,17 @@
+// THEOplayerRCTTrackEventTypes.swift
+
+enum MediaTrackType: Int {
+    case AUDIO = 0
+    case VIDEO = 1
+}
+
+enum TrackListEventType: Int {
+    case ADD_TRACK = 0
+    case REMOVE_TRACK = 1
+    case CHANGE_TRACK = 2
+}
+
+enum TrackCueEventType: Int {
+    case ADD_CUE = 0
+    case REMOVE_CUE = 1
+}

package/ios/{THEOplayerRCTMetadataAggregator.swift → THEOplayerRCTTrackMetadataAggregator.swift}

@@ -26,23 +26,24 @@ let PROP_CUES: String = "cues"
 let PROP_CUE_CONTENT: String = "content"
 let PROP_SRC: String = "src"
 
-class THEOplayerRCTMetadataAggregator {
+class THEOplayerRCTTrackMetadataAggregator {
 
-    class func aggregateMetadata(player: THEOplayer) -> [String:Any] {
+    class func aggregateTrackMetadata(player: THEOplayer) -> [String:Any] {
         let textTracks: TextTrackList = player.textTracks
         let audioTracks: AudioTrackList = player.audioTracks
         let videoTracks: VideoTrackList = player.videoTracks
         return [
-            EVENT_PROP_TEXT_TRACKS : THEOplayerRCTMetadataAggregator.aggregatedTextTrackListInfo(textTracks: textTracks),
-            EVENT_PROP_AUDIO_TRACKS : THEOplayerRCTMetadataAggregator.aggregatedAudioTrackListInfo(audioTracks: audioTracks),
-            EVENT_PROP_VIDEO_TRACKS : THEOplayerRCTMetadataAggregator.aggregatedVideoTrackListInfo(videoTracks: videoTracks),
-            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_TEXT_TRACKS : THEOplayerRCTTrackMetadataAggregator.aggregatedTextTrackListInfo(textTracks: textTracks),
+            EVENT_PROP_AUDIO_TRACKS : THEOplayerRCTTrackMetadataAggregator.aggregatedAudioTrackListInfo(audioTracks: audioTracks),
+            EVENT_PROP_VIDEO_TRACKS : THEOplayerRCTTrackMetadataAggregator.aggregatedVideoTrackListInfo(videoTracks: videoTracks),
+            EVENT_PROP_SELECTED_TEXT_TRACK: THEOplayerRCTTrackMetadataAggregator.selectedTextTrack(textTracks: textTracks),
+            EVENT_PROP_SELECTED_AUDIO_TRACK: THEOplayerRCTTrackMetadataAggregator.selectedAudioTrack(audioTracks: audioTracks),
+            EVENT_PROP_SELECTED_VIDEO_TRACK: THEOplayerRCTTrackMetadataAggregator.selectedVideoTrack(videoTracks: videoTracks),
             EVENT_PROP_DURATION: THEOplayerRCTTypeUtils.encodeInfNan((player.duration ?? Double.nan) * 1000)
         ]
     }
 
+    // MARK: TEXTTRACKS
     class func aggregatedTextTrackListInfo(textTracks: TextTrackList) -> [[String:Any]] {
         var textTrackEntries:[[String:Any]] = []
         guard textTracks.count > 0 else {
@@ -50,7 +51,7 @@ class THEOplayerRCTMetadataAggregator {
         }
         for i in 0...textTracks.count-1 {
             let textTrack: TextTrack = textTracks.get(i)
-            textTrackEntries.append(THEOplayerRCTMetadataAggregator.aggregatedTextTrackInfo(textTrack: textTrack))
+            textTrackEntries.append(THEOplayerRCTTrackMetadataAggregator.aggregatedTextTrackInfo(textTrack: textTrack))
         }
         return textTrackEntries
     }
@@ -69,13 +70,27 @@ class THEOplayerRCTMetadataAggregator {
         if !textTrack.cues.isEmpty {
             var cueList: [[String:Any]] = []
             for cue in textTrack.cues {
-                cueList.append(THEOplayerRCTMetadataAggregator.aggregatedTextTrackCueInfo(textTrackCue: cue))
+                cueList.append(THEOplayerRCTTrackMetadataAggregator.aggregatedTextTrackCueInfo(textTrackCue: cue))
             }
             entry[PROP_CUES] = cueList
         }
         return entry
     }
     
+    private class func selectedTextTrack(textTracks: TextTrackList) -> Int {
+        guard textTracks.count > 0 else {
+            return 0
+        }
+        for i in 0...textTracks.count-1 {
+            let textTrack: TextTrack = textTracks.get(i)
+            if textTrack.mode == TextTrackMode.showing {
+                return textTrack.uid
+            }
+        }
+        return 0
+    }
+    
+    // MARK: TEXTTRACK CUES
     class func aggregatedTextTrackCueInfo(textTrackCue: TextTrackCue) -> [String:Any] {
         var entry: [String:Any] = [:]
         entry[PROP_ID] = textTrackCue.id
@@ -86,61 +101,33 @@ class THEOplayerRCTMetadataAggregator {
         return entry
     }
 
+    // MARK: AUDIOTRACKS
     private class func aggregatedAudioTrackListInfo(audioTracks: AudioTrackList) -> [[String:Any]] {
         var audioTrackEntries:[[String:Any]] = []
         guard audioTracks.count > 0 else {
             return audioTrackEntries
         }
         for i in 0...audioTracks.count-1 {
-            let audioTrack: MediaTrack = audioTracks.get(i)
-            var entry: [String:Any] = [:]
-            entry[PROP_ID] = audioTrack.id
-            entry[PROP_UID] = audioTrack.uid
-            entry[PROP_KIND] = audioTrack.kind
-            entry[PROP_LANGUAGE] = audioTrack.language
-            entry[PROP_LABEL] = audioTrack.label
-            entry[PROP_QUALITIES] = []          // empty: qualities are not being exposed on iOS
-            //entry[PROP_ACTIVE_QUALITY] =      // undefined: qualities are not being exposed on iOS
-            //entry[PROP_TARGET_QUALITY] =      // undefined: qualities are not being exposed on iOS
-            audioTrackEntries.append(entry)
+            if let audioTrack: AudioTrack = audioTracks.get(i) as? AudioTrack {
+                audioTrackEntries.append(THEOplayerRCTTrackMetadataAggregator.aggregatedAudioTrackInfo(audioTrack: audioTrack))
+            }
         }
         return audioTrackEntries
     }
-
-    private class func aggregatedVideoTrackListInfo(videoTracks: VideoTrackList) -> [[String:Any]] {
-        var videoTrackEntries:[[String:Any]] = []
-        guard videoTracks.count > 0 else {
-            return videoTrackEntries
-        }
-        for i in 0...videoTracks.count-1 {
-            let videoTrack: MediaTrack = videoTracks.get(i)
-            var entry: [String:Any] = [:]
-            entry[PROP_ID] = videoTrack.id
-            entry[PROP_UID] = videoTrack.uid
-            entry[PROP_KIND] = videoTrack.kind
-            entry[PROP_LANGUAGE] = videoTrack.language
-            entry[PROP_LABEL] = videoTrack.label
-            entry[PROP_QUALITIES] = []          // empty: qualities are not being exposed on iOS
-            //entry[PROP_ACTIVE_QUALITY] =      // undefined: qualities are not being exposed on iOS
-            //entry[PROP_TARGET_QUALITY] =      // undefined: qualities are not being exposed on iOS
-            videoTrackEntries.append(entry)
-        }
-        return videoTrackEntries
-    }
-
-    private class func selectedTextTrack(textTracks: TextTrackList) -> Int {
-        guard textTracks.count > 0 else {
-            return 0
-        }
-        for i in 0...textTracks.count-1 {
-            let textTrack: TextTrack = textTracks.get(i)
-            if textTrack.mode == TextTrackMode.showing {
-                return textTrack.uid
-            }
-        }
-        return 0
+    
+    class func aggregatedAudioTrackInfo(audioTrack: AudioTrack) -> [String:Any] {
+        var entry: [String:Any] = [:]
+        entry[PROP_ID] = audioTrack.id
+        entry[PROP_UID] = audioTrack.uid
+        entry[PROP_KIND] = audioTrack.kind
+        entry[PROP_LANGUAGE] = audioTrack.language
+        entry[PROP_LABEL] = audioTrack.label
+        entry[PROP_QUALITIES] = []          // empty: qualities are not being exposed on iOS
+        //entry[PROP_ACTIVE_QUALITY] =      // undefined: qualities are not being exposed on iOS
+        //entry[PROP_TARGET_QUALITY] =      // undefined: qualities are not being exposed on iOS
+        return entry
     }
-
+    
     private class func selectedAudioTrack(audioTracks: AudioTrackList) -> Int {
         guard audioTracks.count > 0 else {
             return 0
@@ -154,6 +141,33 @@ class THEOplayerRCTMetadataAggregator {
         return 0
     }
 
+    // MARK: VIDEOTRACKS
+    private class func aggregatedVideoTrackListInfo(videoTracks: VideoTrackList) -> [[String:Any]] {
+        var videoTrackEntries:[[String:Any]] = []
+        guard videoTracks.count > 0 else {
+            return videoTrackEntries
+        }
+        for i in 0...videoTracks.count-1 {
+            if let videoTrack: VideoTrack = videoTracks.get(i) as? VideoTrack {
+                videoTrackEntries.append(THEOplayerRCTTrackMetadataAggregator.aggregatedVideoTrackInfo(videoTrack: videoTrack))
+            }
+        }
+        return videoTrackEntries
+    }
+    
+    class func aggregatedVideoTrackInfo(videoTrack: VideoTrack) -> [String:Any] {
+        var entry: [String:Any] = [:]
+        entry[PROP_ID] = videoTrack.id
+        entry[PROP_UID] = videoTrack.uid
+        entry[PROP_KIND] = videoTrack.kind
+        entry[PROP_LANGUAGE] = videoTrack.language
+        entry[PROP_LABEL] = videoTrack.label
+        entry[PROP_QUALITIES] = []          // empty: qualities are not being exposed on iOS
+        //entry[PROP_ACTIVE_QUALITY] =      // undefined: qualities are not being exposed on iOS
+        //entry[PROP_TARGET_QUALITY] =      // undefined: qualities are not being exposed on iOS
+        return entry
+    }
+
     private class func selectedVideoTrack(videoTracks: VideoTrackList) -> Int {
         guard videoTracks.count > 0 else {
             return 0