@jwplayer/jwplayer-react-native 1.0.0

package/ios/RNJWPlayer/RNJWPlayerView.swift

@@ -0,0 +1,1837 @@
+//
+//  RNJWPlayerViewController.m
+//  RNJWPlayer
+//
+//  Created by Chaim Paneth on 3/30/22.
+//
+
+import UIKit
+import AVFoundation
+import AVKit
+import MediaPlayer
+import React
+import GoogleCast
+import JWPlayerKit
+
+class RNJWPlayerView : UIView, JWPlayerDelegate, JWPlayerStateDelegate, JWAdDelegate, JWCastDelegate, JWAVDelegate, JWPlayerViewDelegate, JWPlayerViewControllerDelegate, JWDRMContentKeyDataSource, AVPictureInPictureControllerDelegate {
+    
+    // MARK: - RNJWPlayer allocation
+
+    var playerViewController:RNJWPlayerViewController!
+    var playerView: JWPlayerView!
+    var audioSession: AVAudioSession!
+    var pipEnabled: Bool = true
+    var backgroundAudioEnabled: Bool = true
+    var userPaused: Bool = false
+    var wasInterrupted: Bool = false
+    var interfaceBehavior: JWInterfaceBehavior!
+    var fairplayCertUrl: String!
+    var processSpcUrl: String!
+    var contentUUID: String!
+    var audioCategory: String!
+    var audioMode: String!
+    var audioCategoryOptions: [String]!
+    var settingConfig: Bool = false
+    var pendingConfig: Bool = false
+    var currentConfig: [String : Any]!
+    var playerFailed = false
+    var castController: JWCastController!
+    var isCasting: Bool = false
+    var availableDevices: [AnyObject]!
+    
+    @objc var onBuffer:RCTDirectEventBlock?
+    @objc var onUpdateBuffer:RCTDirectEventBlock?
+    @objc var onPlay:RCTDirectEventBlock?
+    @objc var onBeforePlay:RCTDirectEventBlock?
+    @objc var onAttemptPlay:RCTDirectEventBlock?
+    @objc var onPause:RCTDirectEventBlock?
+    @objc var onIdle:RCTDirectEventBlock?
+    @objc var onPlaylistItem:RCTDirectEventBlock?
+    @objc var onLoaded:RCTDirectEventBlock?
+    @objc var onVisible:RCTDirectEventBlock?
+    @objc var onTime:RCTDirectEventBlock?
+    @objc var onSeek:RCTDirectEventBlock?
+    @objc var onSeeked:RCTDirectEventBlock?
+    @objc var onRateChanged:RCTDirectEventBlock?
+    @objc var onPlaylist:RCTDirectEventBlock?
+    @objc var onPlaylistComplete:RCTDirectEventBlock?
+    @objc var onBeforeComplete:RCTDirectEventBlock?
+    @objc var onComplete:RCTDirectEventBlock?
+    @objc var onAudioTracks:RCTDirectEventBlock?
+    @objc var onPlayerReady:RCTDirectEventBlock?
+    @objc var onSetupPlayerError:RCTDirectEventBlock?
+    @objc var onPlayerError:RCTDirectEventBlock?
+    @objc var onPlayerWarning:RCTDirectEventBlock?
+    @objc var onPlayerAdWarning:RCTDirectEventBlock?
+    @objc var onPlayerAdError:RCTDirectEventBlock?
+    @objc var onAdEvent:RCTDirectEventBlock?
+    @objc var onAdTime:RCTDirectEventBlock?
+    @objc var onScreenTapped:RCTDirectEventBlock?
+    @objc var onControlBarVisible:RCTDirectEventBlock?
+    @objc var onFullScreen:RCTDirectEventBlock?
+    @objc var onFullScreenRequested:RCTDirectEventBlock?
+    @objc var onFullScreenExit:RCTDirectEventBlock?
+    @objc var onFullScreenExitRequested:RCTDirectEventBlock?
+    @objc var onPlayerSizeChange:RCTDirectEventBlock?
+    @objc var onCastingDevicesAvailable:RCTDirectEventBlock?
+    @objc var onConnectedToCastingDevice:RCTDirectEventBlock?
+    @objc var onDisconnectedFromCastingDevice:RCTDirectEventBlock?
+    @objc var onConnectionTemporarilySuspended:RCTDirectEventBlock?
+    @objc var onConnectionRecovered:RCTDirectEventBlock?
+    @objc var onConnectionFailed:RCTDirectEventBlock?
+    @objc var onCasting:RCTDirectEventBlock?
+    @objc var onCastingEnded:RCTDirectEventBlock?
+    @objc var onCastingFailed:RCTDirectEventBlock?
+    
+    init() {
+        super.init(frame: CGRect(x: 20, y: 0, width: UIScreen.main.bounds.width - 40, height: 300))
+    }
+    
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        NotificationCenter.default.addObserver(self, selector: #selector(rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
+    }
+    
+    deinit {
+        self.startDeinitProcess()
+    }
+    
+    override func removeFromSuperview() {
+        self.startDeinitProcess()
+    }
+
+    func startDeinitProcess() {
+        NotificationCenter.default.removeObserver(self, name:UIDevice.orientationDidChangeNotification, object:nil)
+
+        self.reset()
+        super.removeFromSuperview()
+    }
+
+    func reset() {
+        NotificationCenter.default.removeObserver(self, name:AVAudioSession.mediaServicesWereResetNotification, object:audioSession)
+        NotificationCenter.default.removeObserver(self, name:AVAudioSession.interruptionNotification, object:audioSession)
+
+        NotificationCenter.default.removeObserver(self, name:UIApplication.willResignActiveNotification, object:nil)
+        NotificationCenter.default.removeObserver(self, name:UIApplication.didEnterBackgroundNotification, object:nil)
+        NotificationCenter.default.removeObserver(self, name:UIApplication.willEnterForegroundNotification, object:nil)
+        NotificationCenter.default.removeObserver(self, name:AVAudioSession.routeChangeNotification, object:nil)
+
+        if (playerViewController != nil) || (playerView != nil) {
+//            playerViewController.player.currentItem!.removeObserver(self, forKeyPath:"playbackLikelyToKeepUp", context:nil)
+            if (playerView != nil) {
+                NotificationCenter.default.removeObserver(self, forKeyPath:"isPictureInPicturePossible", context:nil)
+            }
+        }
+
+        self.removePlayerView()
+        self.dismissPlayerViewController()
+
+        self.deinitAudioSession()
+
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+
+        if self.playerView != nil {
+            self.playerView.frame = self.frame
+        }
+
+        if self.playerViewController != nil {
+            self.playerViewController.view.frame = self.frame
+        }
+    }
+
+    @objc func rotated(notification: Notification) {
+        if UIDevice.current.orientation.isLandscape {
+            print("Landscape")
+        }
+
+        if UIDevice.current.orientation.isPortrait {
+            print("Portrait")
+        }
+
+        self.layoutSubviews()
+    }
+
+    func shouldAutorotate() -> Bool {
+        return false
+    }
+
+    // MARK: - RNJWPlayer props
+
+    func setLicense(license:String?) {
+        if (license != nil) {
+            JWPlayerKitLicense.setLicenseKey(license!)
+        } else {
+            print("JW SDK License key not set.")
+        }
+    }
+
+    func keysForDifferingValues(in dict1: [String: Any], and dict2: [String: Any]) -> [String] {
+        var diffKeys = [String]()
+
+        for key in dict1.keys {
+            if let value1 = dict1[key], let value2 = dict2[key] {
+                if !areEqual(value1, value2) {
+                    diffKeys.append(key)
+                }
+            } else {
+                // One of the dictionaries does not contain the key
+                diffKeys.append(key)
+            }
+        }
+
+        return diffKeys
+    }
+
+    func areEqual(_ value1: Any, _ value2: Any) -> Bool {
+        let mirror1 = Mirror(reflecting: value1)
+        let mirror2 = Mirror(reflecting: value2)
+
+        if mirror1.displayStyle != mirror2.displayStyle {
+            // Different types
+            return false
+        }
+
+        switch (value1, value2) {
+        case let (dict1 as [String: Any], dict2 as [String: Any]):
+            // Both are dictionaries, recursively compare
+            return keysForDifferingValues(in: dict1, and: dict2).isEmpty
+        case let (array1 as [Any], array2 as [Any]):
+            // Both are arrays, compare elements
+            return array1.count == array2.count && zip(array1, array2).allSatisfy(areEqual)
+        default:
+            // Use default String description for comparison
+            return String(describing: value1) == String(describing: value2)
+        }
+    }
+
+    
+    func dictionariesAreEqual(_ dict1: [String: Any]?, _ dict2: [String: Any]?) -> Bool {
+        return NSDictionary(dictionary: dict1 ?? [:]).isEqual(to: dict2 ?? [:])
+    }
+    
+    @objc func setJsonConfig(_ config: JSONObject) {
+        do {
+            let configuration = try JWPlayerConfigurationBuilder().configuration(json: config).build()
+            playerViewController.player.configurePlayer(with: configuration)
+        } catch {
+            print(error)
+        }
+    }
+
+    @objc func setConfig(_ config: [String: Any]) {
+        if (playerFailed) {
+            playerFailed = false
+            setNewConfig(config: config)
+            return
+        }
+        
+        // Create mutable copies of the dictionaries
+        var configCopy = config
+        var currentConfigCopy = currentConfig
+
+        // Remove the playlist key
+        configCopy.removeValue(forKey: "playlist")
+        currentConfigCopy?.removeValue(forKey: "playlist")
+
+        // Compare dictionaries without the playlist key
+        if (currentConfigCopy == nil) || !dictionariesAreEqual(configCopy, currentConfigCopy!) {
+            print("There are differences other than the 'playlist' key.")
+
+            if (currentConfigCopy != nil) {
+                let diffKeys = keysForDifferingValues(in: configCopy, and: currentConfigCopy!)
+                print("There are differences in these keys: \(diffKeys)")
+            } else {
+                print("It's a new config")
+            }
+
+            setNewConfig(config: config)
+        } else {
+            // Compare original dictionaries
+            if !dictionariesAreEqual(currentConfig, config) {
+                print("The only difference is the 'playlist' key.")
+
+                var playlistArray = [JWPlayerItem]()
+
+                if let playlist = config["playlist"] as? [AnyObject] {
+                    for item in playlist {
+                        if let playerItem = try? getPlayerItem(item: item as! [String: Any]) {
+                            playlistArray.append(playerItem)
+                        }
+                    }
+                }
+
+                if let playerViewController = playerViewController {
+                    playerViewController.player.loadPlaylist(items: playlistArray)
+                } else if let playerView = playerView {
+                    playerView.player.loadPlaylist(items: playlistArray)
+                } else {
+                    setNewConfig(config: config)
+                }
+            } else {
+                print("There are no differences.")
+            }
+        }
+    }
+
+    func setNewConfig(config: [String : Any]) {
+        let forceLegacyConfig = config["forceLegacyConfig"] as? Bool?
+        let data:Data! = try? JSONSerialization.data(withJSONObject: config, options:.prettyPrinted)
+        let jwConfig = try? JWJSONParser.configFromJSON(data)
+        
+        currentConfig = config
+
+        if !settingConfig {
+            pendingConfig = false
+            settingConfig = true
+
+            let license = config["license"] as? String
+            self.setLicense(license: license)
+            
+            if let bae = config["backgroundAudioEnabled"] as? Bool, let pe = config["pipEnabled"] as? Bool {
+                backgroundAudioEnabled = bae
+                pipEnabled = pe
+            }
+            
+            if backgroundAudioEnabled || pipEnabled {
+                let category = config["category"] as? String
+                let categoryOptions = config["categoryOptions"] as? [String]
+                let mode = config["mode"] as? String
+
+                self.initAudioSession(category: category, categoryOptions: categoryOptions, mode: mode)
+            } else {
+                self.deinitAudioSession()
+            }
+            
+            if forceLegacyConfig == true {
+                // Pull from top level of config
+                processSpcUrl = config["processSpcUrl"] as? String
+                fairplayCertUrl = config["certificateUrl"] as? String
+                contentUUID = config["contentUUID"] as? String
+
+                // Dangerous: check playlist for processSpcUrl / fairplayCertUrl in playlist
+                // Only checks first playlist item as multi-item DRM playlists are ill advised
+                if let playlist = config["playlist"] as? [AnyObject] {
+                    let item = playlist.first
+                    if let itemMap = item as? [String: Any] {
+                        if itemMap["processSpcUrl"] != nil {
+                            processSpcUrl = itemMap["processSpcUrl"] as? String
+                        }
+                        if itemMap["certificateUrl"] != nil {
+                            fairplayCertUrl = itemMap["certificateUrl"] as? String
+                        }
+                    }
+                }
+            } else {
+                // TODO -- Ensure JWJSONParser pulls out cert/spc for sources (Expected in JW iOS SDK v4.19.0)
+            }
+
+            do {
+                let viewOnly = config["viewOnly"] as? Bool
+                if viewOnly == true {
+                    if forceLegacyConfig == true {
+                        self.setupPlayerView(config: config, playerConfig: try self.getPlayerConfiguration(config: config))
+                    } else {
+                        self.setupPlayerView(config: config, playerConfig: jwConfig!)
+                    }
+                } else {
+                    if forceLegacyConfig == true {
+                        self.setupPlayerViewController(config: config, playerConfig: try self.getPlayerConfiguration(config: config))
+                    } else {
+                        self.setupPlayerViewController(config: config, playerConfig: jwConfig!)
+                    }
+                }
+            } catch {
+                print(error)
+            }
+        } else {
+            pendingConfig = true
+        }
+    }
+
+    @objc func setControls(_ controls:Bool) {
+        if let playerViewControllerView = playerViewController?.view {
+            self.toggleUIGroup(view: playerViewControllerView, name: "JWPlayerKit.InterfaceView", ofSubview: nil, show: controls)
+        }
+    }
+
+    // MARK: - RNJWPlayer styling
+
+    func colorWithHexString(hex:String!) -> UIColor! {
+        var cString = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+
+        // String should be 6 or 8 characters
+        if cString.count < 6 {
+            return UIColor.gray
+        }
+
+        // Strip 0X if it appears
+        if cString.hasPrefix("0X") {
+            cString = String(cString.dropFirst(2))
+        }
+
+        if cString.count != 6 {
+            return UIColor.gray
+        }
+
+        // Separate into r, g, b substrings
+        let startIndex = cString.startIndex
+        let endIndex = cString.index(startIndex, offsetBy: 2)
+        let rString = String(cString[startIndex..<endIndex])
+
+        let startIndexG = cString.index(startIndex, offsetBy: 2)
+        let endIndexG = cString.index(startIndexG, offsetBy: 2)
+        let gString = String(cString[startIndexG..<endIndexG])
+
+        let startIndexB = cString.index(startIndexG, offsetBy: 2)
+        let endIndexB = cString.index(startIndexB, offsetBy: 2)
+        let bString = String(cString[startIndexB..<endIndexB])
+
+        // Scan values
+        var r: UInt64 = 0, g: UInt64 = 0, b: UInt64 = 0
+        Scanner(string: rString).scanHexInt64(&r)
+        Scanner(string: gString).scanHexInt64(&g)
+        Scanner(string: bString).scanHexInt64(&b)
+
+        return UIColor(
+            red: CGFloat(r) / 255.0,
+            green: CGFloat(g) / 255.0,
+            blue: CGFloat(b) / 255.0,
+            alpha: 1.0
+        )
+    }
+
+    func setStyling(styling: [String: Any]) {
+        let skinStylingBuilder = JWPlayerSkinBuilder()
+
+        let colors: AnyObject! = styling["colors"] as AnyObject
+        if let colorsDict = colors as? [String: AnyObject] {
+            let timeSlider: AnyObject! = colorsDict["timeslider"] as AnyObject
+            if let timeSliderDict = timeSlider as? [String: AnyObject] {
+                let timeSliderStyleBuilder = JWTimeSliderStyleBuilder()
+
+                if let progress = timeSliderDict["progress"] as? String {
+                    timeSliderStyleBuilder.minimumTrackColor(self.colorWithHexString(hex: progress))
+                }
+
+                if let rail = timeSliderDict["rail"] as? String {
+                    timeSliderStyleBuilder.maximumTrackColor(self.colorWithHexString(hex: rail))
+                }
+
+                if let thumb = timeSliderDict["thumb"] as? String {
+                    timeSliderStyleBuilder.thumbColor(self.colorWithHexString(hex: thumb))
+                }
+
+                // Build the time slider style and set it in the skin styling builder
+                do {
+                    let timeSliderStyle: JWTimeSliderStyle = try timeSliderStyleBuilder.build()
+                    skinStylingBuilder.timeSliderStyle(timeSliderStyle)
+                } catch let error {
+                    // Handle error when building time slider style
+                    print("Error building time slider style: \(error.localizedDescription)")
+                }
+
+                let buttons: AnyObject! = colorsDict["buttons"] as AnyObject
+                if let buttonsColor = buttons as? String {
+                    skinStylingBuilder.buttonsColor(self.colorWithHexString(hex: buttonsColor))
+                }
+
+                let backgroundColor: AnyObject! = colorsDict["backgroundColor"] as AnyObject
+                if let bgColor = backgroundColor as? String {
+                    skinStylingBuilder.backgroundColor(self.colorWithHexString(hex: bgColor))
+                }
+
+                let fontColor: AnyObject! = colorsDict["fontColor"] as AnyObject
+                if let fontColorValue = fontColor as? String {
+                    skinStylingBuilder.fontColor(self.colorWithHexString(hex: fontColorValue))
+                }
+            }
+        }
+
+        let font: AnyObject! = styling["font"] as AnyObject
+        if let fontDict = font as? [String: AnyObject] {
+            let name: AnyObject! = fontDict["name"] as AnyObject
+            let size: AnyObject! = fontDict["size"] as AnyObject
+
+            if let fontName = name as? String, let fontSize = size as? CGFloat {
+                skinStylingBuilder.font(UIFont(name: fontName, size: fontSize)!)
+            }
+        }
+
+        let showTitle: AnyObject! = styling["displayTitle"] as AnyObject
+        if let titleVisible = showTitle as? Bool {
+            skinStylingBuilder.titleIsVisible(titleVisible)
+        }
+
+        let showDesc: AnyObject! = styling["displayDescription"] as AnyObject
+        if let descVisible = showDesc as? Bool {
+            skinStylingBuilder.descriptionIsVisible(descVisible)
+        }
+
+        let capStyle: AnyObject! = styling["captionsStyle"] as AnyObject
+        if let capStyleDict = capStyle as? [String: AnyObject] {
+            let capStyleBuilder: JWCaptionStyleBuilder! = JWCaptionStyleBuilder()
+
+            let font: AnyObject! = capStyleDict["font"] as AnyObject
+            if let fontDict = font as? [String: AnyObject] {
+                let name: AnyObject! = fontDict["name"] as AnyObject
+                let size: AnyObject! = fontDict["size"] as AnyObject
+                if let fontName = name as? String, let fontSize = size as? CGFloat {
+                    capStyleBuilder.font(UIFont(name: fontName, size: fontSize)!)
+                }
+            }
+
+            let fontColor: AnyObject! = capStyleDict["fontColor"] as AnyObject
+            if let fontColorString = fontColor as? String {
+                capStyleBuilder.fontColor(self.colorWithHexString(hex: fontColorString))
+            }
+
+            let backgroundColor: AnyObject! = capStyleDict["backgroundColor"] as AnyObject
+            if let bgColorString = backgroundColor as? String {
+                capStyleBuilder.backgroundColor(self.colorWithHexString(hex: bgColorString))
+            }
+
+            let highlightColor: AnyObject! = capStyleDict["highlightColor"] as AnyObject
+            if let highlightColorString = highlightColor as? String {
+                capStyleBuilder.highlightColor(self.colorWithHexString(hex: highlightColorString))
+            }
+
+            let edgeStyle: AnyObject! = capStyleDict["edgeStyle"] as AnyObject
+            if let edgeStyleString = edgeStyle as? String {
+                capStyleBuilder.edgeStyle(RCTConvert.JWCaptionEdgeStyle(edgeStyleString))
+            }
+            
+            do {
+                let captionStyle = try capStyleBuilder.build()
+                skinStylingBuilder.captionStyle(captionStyle)
+            } catch let error {
+                // Handle error when building time slider style
+                print("Error building caption style: \(error.localizedDescription)")
+            }
+        }
+
+        let menuStyle: AnyObject! = styling["menuStyle"] as AnyObject
+        if let menuStyleDict = menuStyle as? [String: AnyObject] {
+            let menuStyleBuilder: JWMenuStyleBuilder! = JWMenuStyleBuilder()
+
+            if let font = menuStyleDict["font"] as? [String: AnyObject],
+                let name = font["name"] as? String,
+                let size = font["size"] as? CGFloat {
+                menuStyleBuilder.font(UIFont(name: name, size: size)!)
+            }
+
+            if let fontColorString = menuStyleDict["fontColor"] as? String {
+                menuStyleBuilder.fontColor(self.colorWithHexString(hex: fontColorString))
+            }
+
+            if let backgroundColorString = menuStyleDict["backgroundColor"] as? String {
+                menuStyleBuilder.backgroundColor(self.colorWithHexString(hex: backgroundColorString))
+            }
+            
+            do {
+                let jwMenuStyle = try menuStyleBuilder.build()
+                skinStylingBuilder.menuStyle(jwMenuStyle)
+            } catch let error {
+                // Handle error when building time slider style
+                print("Error building menu style: \(error.localizedDescription)")
+            }
+        }
+
+        // TODO this was broken when using `.playlist(string)`
+        do {
+            let skinStyling = try skinStylingBuilder.build()
+            DispatchQueue.main.async { [self] in
+                playerViewController.styling = skinStyling
+            }
+        } catch {
+            print(error)
+        }
+    }
+
+    // MARK: - RNJWPlayer config helpers
+
+    func getPlayerItem(item: [String: Any]) throws -> JWPlayerItem {
+        let itemBuilder = JWPlayerItemBuilder()
+
+        if let newFile = item["file"] as? String,
+           let url = URL(string: newFile) {
+
+            if url.scheme != nil && url.host != nil {
+                itemBuilder.file(url)
+            } else {
+                if let encodedString = newFile.addingPercentEncoding(withAllowedCharacters: .urlFragmentAllowed),
+                   let encodedUrl = URL(string: encodedString) {
+                    itemBuilder.file(encodedUrl)
+                }
+            }
+        }
+
+        // Process sources
+        if let itemSources = item["sources"] as? [AnyObject], !itemSources.isEmpty {
+            var sourcesArray = [JWVideoSource]()
+            
+            for source in itemSources.compactMap({ $0 as? [String: Any] }) {
+                if let file = source["file"] as? String,
+                   let fileURL = URL(string: file),
+                   let label = source["label"] as? String,
+                   let isDefault = source["default"] as? Bool {
+                    
+                    let sourceBuilder = JWVideoSourceBuilder()
+                    sourceBuilder.file(fileURL)
+                    sourceBuilder.label(label)
+                    sourceBuilder.defaultVideo(isDefault)
+                    
+                    if let sourceItem = try? sourceBuilder.build() {
+                        sourcesArray.append(sourceItem)
+                    }
+                }
+            }
+            
+            itemBuilder.videoSources(sourcesArray)
+        }
+
+        // Process other properties
+        if let mediaId = item["mediaId"] as? String {
+            itemBuilder.mediaId(mediaId)
+        }
+
+        if let title = item["title"] as? String {
+            itemBuilder.title(title)
+        }
+
+        if let description = item["description"] as? String {
+            itemBuilder.description(description)
+        }
+
+        if let image = item["image"] as? String, let imageURL = URL(string: image) {
+            itemBuilder.posterImage(imageURL)
+        }
+
+        if let startTime = item["startTime"] as? Double {
+            itemBuilder.startTime(startTime)
+        }
+
+        if let recommendations = item["recommendations"] as? String, let recURL = URL(string: recommendations) {
+            itemBuilder.recommendations(recURL)
+        }
+
+        // Process tracks
+        if let tracksItem = item["tracks"] as? [AnyObject], !tracksItem.isEmpty {
+            var tracksArray = [JWMediaTrack]()
+            
+            for trackItem in tracksItem.compactMap({ $0 as? [String: Any] }) {
+                if let file = trackItem["file"] as? String,
+                   let fileURL = URL(string: file),
+                   let label = trackItem["label"] as? String,
+                   let isDefault = trackItem["default"] as? Bool {
+                    
+                    let trackBuilder = JWCaptionTrackBuilder()
+                    trackBuilder.file(fileURL)
+                    trackBuilder.label(label)
+                    trackBuilder.defaultTrack(isDefault)
+                    
+                    if let track = try? trackBuilder.build() {
+                        tracksArray.append(track)
+                    }
+                }
+            }
+            
+            itemBuilder.mediaTracks(tracksArray)
+        }
+
+        // Process adSchedule
+        if let adsItem = item["adSchedule"] as? [AnyObject], !adsItem.isEmpty {
+            var adsArray = [JWAdBreak]()
+
+            for adItem in adsItem.compactMap({ $0 as? [String: Any] }) {
+                if let offsetString = adItem["offset"] as? String,
+                   let tag = adItem["tag"] as? String,
+                   let encodedString = tag.addingPercentEncoding(withAllowedCharacters: .urlFragmentAllowed),
+                   let tagURL = URL(string: encodedString),
+                   let offset = JWAdOffset.from(string: offsetString) {
+                    let adBreakBuilder = JWAdBreakBuilder()
+                    adBreakBuilder.offset(offset)
+                    adBreakBuilder.tags([tagURL])
+
+                    if let adBreak = try? adBreakBuilder.build() {
+                        adsArray.append(adBreak)
+                    }
+                }
+            }
+
+            if !adsArray.isEmpty {
+                itemBuilder.adSchedule(breaks: adsArray)
+            }
+        }
+
+        // Process adVmap
+        if let adVmap = item["adVmap"] as? String, let adVmapURL = URL(string: adVmap) {
+            itemBuilder.adSchedule(vmapURL: adVmapURL)
+        }
+
+        let playerItem = try itemBuilder.build()
+
+        return playerItem
+
+    }
+
+    func getPlayerConfiguration(config: [String: Any]) throws -> JWPlayerConfiguration {
+        let configBuilder:JWPlayerConfigurationBuilder! = JWPlayerConfigurationBuilder()
+
+        var playlistArray = [JWPlayerItem]()
+
+        if let playlist = config["playlist"] as? [[String: Any]] {
+            for item in playlist {
+                if let playerItem = try? self.getPlayerItem(item: item) {
+                    playlistArray.append(playerItem)
+                }
+            }
+            configBuilder.playlist(items: playlistArray)
+        }
+
+        if let autostart = config["autostart"] as? Bool {
+            configBuilder.autostart(autostart)
+        }
+
+        if let repeatContent = config["repeat"] as? Bool, repeatContent {
+            configBuilder.repeatContent(repeatContent)
+        }
+
+        if let preload = config["preload"] as? String {
+            configBuilder.preload(RCTConvert.JWPreload(preload))
+        }
+
+        if let related = config["related"] as? [String: Any] {
+            let relatedBuilder = JWRelatedContentConfigurationBuilder()
+
+            relatedBuilder.onClick(RCTConvert.JWRelatedOnClick(related["onClick"] as! String))
+            relatedBuilder.onComplete(RCTConvert.JWRelatedOnComplete(related["onComplete"] as! String))
+            relatedBuilder.heading(related["heading"] as! String)
+            relatedBuilder.url(URL(string: related["url"] as? String ?? "")!)
+            relatedBuilder.autoplayMessage(related["autoplayMessage"] as! String)
+            relatedBuilder.autoplayTimer(related["autoplayTimer"] as? Int ?? 0)
+
+            let relatedContent = relatedBuilder.build()
+            configBuilder.related(relatedContent)
+        }
+
+        if let ads = config["advertising"] as? [String: Any] {
+            var advertisingConfig: JWAdvertisingConfig?
+
+            var jwAdClient = JWAdClient.unknown
+            if let adClientString = ads["adClient"] as? String {
+                jwAdClient = RCTConvert.JWAdClient(adClientString)
+            }
+
+            switch jwAdClient {
+            case .JWPlayer:
+                advertisingConfig = RNJWPlayerAds.configureVAST(with: ads)
+            case .GoogleIMA:
+                advertisingConfig = RNJWPlayerAds.configureIMA(with: ads)
+            case .GoogleIMADAI:
+                advertisingConfig = RNJWPlayerAds.configureIMADAI(with: ads)
+            default:
+                advertisingConfig = RNJWPlayerAds.configureVAST(with: ads)
+                break
+            }
+
+            if (advertisingConfig != nil) {
+                configBuilder.advertising(advertisingConfig!)
+            }
+        }
+
+        let playerConfig = try configBuilder.build()
+
+        return playerConfig
+    }
+
+    // MARK: - JWPlayer View Controller helpers
+
+    func setupPlayerViewController(config: [String: Any], playerConfig: JWPlayerConfiguration) {
+        if playerViewController == nil {
+            playerViewController = RNJWPlayerViewController()
+            playerViewController.parentView = self
+            
+            DispatchQueue.main.async { [self] in
+                if self.reactViewController() != nil {
+                    self.reactViewController()!.addChild(self.playerViewController)
+                    self.playerViewController.didMove(toParent: self.reactViewController())
+                } else {
+                    self.reactAddController(toClosestParent: self.playerViewController)
+                }
+            }
+            
+            playerViewController.view.frame = self.frame
+            self.addSubview(playerViewController.view)
+            playerViewController.setDelegates()
+        }
+
+        if let ib = config["interfaceBehavior"] as? String {
+            interfaceBehavior = RCTConvert.JWInterfaceBehavior(ib)
+        }
+
+        if let interfaceFadeDelay = config["interfaceFadeDelay"] as? NSNumber {
+            playerViewController.interfaceFadeDelay = interfaceFadeDelay.doubleValue
+        }
+
+        if let forceFullScreenOnLandscape = config["fullScreenOnLandscape"] as? Bool {
+            playerViewController.forceFullScreenOnLandscape = forceFullScreenOnLandscape
+        }
+
+        if let forceLandscapeOnFullScreen = config["landscapeOnFullScreen"] as? Bool {
+            playerViewController.forceLandscapeOnFullScreen = forceLandscapeOnFullScreen
+        }
+
+        if let enableLockScreenControls = config["enableLockScreenControls"] as? Bool {
+            playerViewController.enableLockScreenControls = enableLockScreenControls && backgroundAudioEnabled
+        }
+
+        if let allowsPictureInPicturePlayback = config["allowsPictureInPicturePlayback"] as? Bool {
+            playerViewController.allowsPictureInPicturePlayback = allowsPictureInPicturePlayback
+        }
+
+        if let styling = config["styling"] as? [String: Any] {
+            self.setStyling(styling: styling)
+        }
+
+        if let nextUpStyle = config["nextUpStyle"] as? [String: Any] {
+            let nextUpBuilder = JWNextUpStyleBuilder()
+
+            if let offsetSeconds = nextUpStyle["offsetSeconds"] as? Double {
+                nextUpBuilder.timeOffset(seconds: offsetSeconds)
+            }
+
+            if let offsetPercentage = nextUpStyle["offsetPercentage"] as? Double {
+                nextUpBuilder.timeOffset(seconds: offsetPercentage)
+            }
+
+            do {
+                playerViewController.nextUpStyle = try nextUpBuilder.build()
+            } catch {
+                print(error)
+            }
+        }
+
+    //    playerViewController.adInterfaceStyle
+    //    playerViewController.logo
+    //    playerView.videoGravity = 0;
+    //    playerView.captionStyle
+
+        if let offlineMsg = config["offlineMessage"] as? String {
+            playerViewController.offlineMessage = offlineMsg
+        }
+
+        if let offlineImg = config["offlineImage"] as? String {
+            if let imageUrl = URL(string: offlineImg), imageUrl.isFileURL {
+                if let imageData = try? Data(contentsOf: imageUrl),
+                   let image = UIImage(data: imageData) {
+                    playerViewController.offlinePosterImage = image
+                }
+            }
+        }
+
+        self.presentPlayerViewController(configuration: playerConfig)
+    }
+
+    func dismissPlayerViewController() {
+        if (playerViewController != nil) {
+            playerViewController.player.pause() // hack for stop not always stopping on unmount
+            playerViewController.player.stop()
+            playerViewController.enableLockScreenControls = false
+
+            // hack for stop not always stopping on unmount
+            let configBuilder:JWPlayerConfigurationBuilder! = JWPlayerConfigurationBuilder()
+            configBuilder.playlist(items: [])
+            
+            do {
+                let configuration: JWPlayerConfiguration = try configBuilder.build()
+                playerViewController.player.configurePlayer(with: configuration)
+            } catch {
+                print(error)
+            }
+            
+
+            playerViewController.parentView = nil
+            playerViewController.setVisibility(.hidden, for:[.pictureInPictureButton])
+            playerViewController.view.removeFromSuperview()
+            playerViewController.removeFromParent()
+            playerViewController.willMove(toParent: nil)
+            playerViewController.removeDelegates()
+            playerViewController = nil
+        }
+    }
+
+    func presentPlayerViewController(configuration: JWPlayerConfiguration!) {
+        if configuration != nil {
+            playerViewController.player.configurePlayer(with: configuration)
+            if (interfaceBehavior != nil) {
+                playerViewController.interfaceBehavior = interfaceBehavior
+            }
+        }
+    }
+
+    // MARK: - JWPlayer View helpers
+
+    func setupPlayerView(config: [String: Any], playerConfig: JWPlayerConfiguration) {
+        playerView = JWPlayerView(frame:self.superview!.frame)
+
+        playerView.delegate = self
+        playerView.player.delegate = self
+        playerView.player.playbackStateDelegate = self
+        playerView.player.adDelegate = self
+        playerView.player.avDelegate = self
+        playerView.player.contentKeyDataSource = self
+
+        playerView.player.configurePlayer(with: playerConfig)
+
+        if pipEnabled {
+            let pipController:AVPictureInPictureController! = playerView.pictureInPictureController
+            pipController.delegate = self
+
+            pipController.addObserver(self, forKeyPath:"isPictureInPicturePossible", options:[.new, .initial], context:nil)
+        }
+
+        self.addSubview(self.playerView)
+
+        if let autostart = config["autostart"] as? Bool, autostart {
+            playerView.player.play()
+        }
+
+        // Time observers
+        weak var weakSelf:RNJWPlayerView! = self
+        playerView.player.adTimeObserver = { (time:JWTimeData!) in
+            weakSelf.onAdTime?(["position": time.position, "duration": time.duration])
+        }
+
+        playerView.player.mediaTimeObserver = { (time:JWTimeData!) in
+            weakSelf.onTime?(["position": time.position, "duration": time.duration])
+        }
+    }
+
+    func removePlayerView() {
+        if (playerView != nil) {
+            playerView.player.stop()
+            playerView.removeFromSuperview()
+            playerView = nil
+        }
+    }
+
+    func toggleUIGroup(view: UIView, name: String, ofSubview: String?, show: Bool) {
+        let subviews = view.subviews
+
+        for subview in subviews {
+            if NSStringFromClass(subview.classForCoder) == name && (ofSubview == nil || NSStringFromClass(subview.superview!.classForCoder) == name) {
+                subview.isHidden = !show
+            } else {
+                toggleUIGroup(view: subview, name: name, ofSubview: ofSubview, show: show)
+            }
+        }
+    }
+
+    func setVisibility(isVisible:Bool, forControls controls:[String]) {
+        var _controls:[JWControlType]! = [JWControlType]()
+
+        for control:String? in controls {
+            if (control != nil && !control!.isEmpty) {
+                let type:JWControlType = RCTConvert.JWControlType(control!)
+                _controls.append(type)
+            }
+         }
+
+        if (_controls.count > 0) {
+            playerViewController.setVisibility(isVisible ? .visible : .hidden, for: _controls!)
+        }
+    }
+
+    // MARK: - JWPlayer Delegate
+
+    func jwplayerIsReady(_ player:JWPlayer) {
+        settingConfig = false
+        self.onPlayerReady?([:])
+
+        if pendingConfig && currentConfig != nil {
+            self.setConfig(currentConfig)
+        }
+    }
+
+    func jwplayer(_ player:JWPlayer, failedWithError code:UInt, message:String) {
+        self.onPlayerError?(["error": message])
+        playerFailed = true
+    }
+
+    func jwplayer(_ player:JWPlayer, failedWithSetupError code:UInt, message:String) {
+        self.onSetupPlayerError?(["error": message])
+        playerFailed = true
+    }
+
+    func jwplayer(_ player:JWPlayer, encounteredWarning code:UInt, message:String) {
+        self.onPlayerWarning?(["warning": message])
+    }
+
+    func jwplayer(_ player:JWPlayer, encounteredAdError code:UInt, message:String) {
+        self.onPlayerAdError?(["error": message])
+    }
+
+
+    func jwplayer(_ player:JWPlayer, encounteredAdWarning code:UInt, message:String) {
+        self.onPlayerAdWarning?(["warning": message])
+    }
+
+
+    // MARK: - JWPlayer View Delegate
+
+    func playerView(_ view:JWPlayerView, sizeChangedFrom oldSize:CGSize, to newSize:CGSize) {
+        let oldSizeDict: [String: Any] = [
+            "width": oldSize.width,
+            "height": oldSize.height
+        ]
+
+        let newSizeDict: [String: Any] = [
+            "width": newSize.width,
+            "height": newSize.height
+        ]
+
+        let sizesDict: [String: Any] = [
+            "oldSize": oldSizeDict,
+            "newSize": newSizeDict
+        ]
+
+        do {
+            let data = try JSONSerialization.data(withJSONObject: sizesDict, options: .prettyPrinted)
+            self.onPlayerSizeChange?(["sizes": data])
+        } catch {
+            print("Error converting dictionary to JSON data: \(error)")
+        }
+    }
+
+    // MARK: - JWPlayer View Controller Delegate
+
+    func playerViewController(_ controller:JWPlayerViewController, sizeChangedFrom oldSize:CGSize, to newSize:CGSize) {
+        let oldSizeDict: [String: Any] = [
+            "width": oldSize.width,
+            "height": oldSize.height
+        ]
+
+        let newSizeDict: [String: Any] = [
+            "width": newSize.width,
+            "height": newSize.height
+        ]
+
+        let sizesDict: [String: Any] = [
+            "oldSize": oldSizeDict,
+            "newSize": newSizeDict
+        ]
+
+        do {
+            let data = try JSONSerialization.data(withJSONObject: sizesDict, options: .prettyPrinted)
+            self.onPlayerSizeChange?(["sizes": data])
+        } catch {
+            print("Error converting dictionary to JSON data: \(error)")
+        }
+    }
+
+    func playerViewController(_ controller:JWPlayerViewController, screenTappedAt position:CGPoint) {
+        self.onScreenTapped?(["x": position.x, "y": position.y])
+    }
+
+    func playerViewController(_ controller:JWPlayerViewController, controlBarVisibilityChanged isVisible:Bool, frame:CGRect) {
+        self.onControlBarVisible?(["visible": isVisible])
+    }
+
+    func playerViewControllerWillGoFullScreen(_ controller:JWPlayerViewController) -> JWFullScreenViewController? {
+        self.onFullScreenRequested?([:])
+        return nil
+    }
+
+    func playerViewControllerDidGoFullScreen(_ controller:JWPlayerViewController) {
+        self.onFullScreen?([:])
+    }
+
+    func playerViewControllerWillDismissFullScreen(_ controller:JWPlayerViewController) {
+        self.onFullScreenExitRequested?([:])
+    }
+
+    func playerViewControllerDidDismissFullScreen(_ controller:JWPlayerViewController) {
+        self.onFullScreenExit?([:])
+    }
+
+    func playerViewController(_ controller:JWPlayerViewController, relatedMenuClosedWithMethod method: JWRelatedInteraction) {
+
+    }
+
+    func playerViewController(_ controller: JWPlayerViewController, relatedMenuOpenedWithItems items: [JWPlayerItem], withMethod method: JWRelatedInteraction) {
+        
+    }
+    
+    func playerViewController(_ controller: JWPlayerViewController, relatedItemBeganPlaying item: JWPlayerItem, atIndex index: Int, withMethod method: JWRelatedMethod) {
+        
+    }
+    
+    // MARK: Time events
+
+    func onAdTimeEvent(time:JWTimeData) {
+        self.onAdTime?(["position": time.position, "duration": time.duration])
+    }
+
+    func onMediaTimeEvent(time:JWTimeData) {
+        self.onTime?(["position": time.position, "duration": time.duration])
+    }
+
+    // MARK: - DRM Delegate
+
+    func contentIdentifierForURL(_ url: URL, completionHandler handler: @escaping (Data?) -> Void) {
+        let data:Data! = url.host?.data(using: String.Encoding.utf8)
+        handler(data)
+    }
+
+    func appIdentifierForURL(_ url: URL, completionHandler handler: @escaping (Data?) -> Void) {
+        guard let fairplayCertUrlString = fairplayCertUrl, let finalUrl = URL(string: fairplayCertUrlString) else {
+            return
+        }
+        
+        let request = URLRequest(url: finalUrl)
+        let task = URLSession.shared.dataTask(with: request) { (data, response, error) in
+            if let error = error {
+                print("DRM cert request error - \(error.localizedDescription)")
+            }
+            handler(data)
+        }
+        task.resume()
+    }
+
+    func contentKeyWithSPCData(_ spcData: Data, completionHandler handler: @escaping (Data?, Date?, String?) -> Void) {
+        if processSpcUrl == nil {
+            return
+        }
+
+        guard let processSpcUrl = URL(string: processSpcUrl) else {
+            print("Invalid processSpcUrl")
+            handler(nil, nil, nil)
+            return
+        }
+
+        var ckcRequest = URLRequest(url: processSpcUrl)
+        ckcRequest.httpMethod = "POST"
+        ckcRequest.httpBody = spcData
+        ckcRequest.addValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
+
+        URLSession.shared.dataTask(with: ckcRequest) { (data, response, error) in
+            if let httpResponse = response as? HTTPURLResponse, (error != nil || httpResponse.statusCode != 200) {
+                print("DRM ckc request error - %@", error?.localizedDescription ?? "Unknown error")
+                handler(nil, nil, nil)
+                return
+            }
+
+            handler(data, nil, "application/octet-stream")
+        }.resume()
+    }
+
+    // MARK: - AV Picture In Picture Delegate
+
+    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
+//        if let playerView = playerView {
+//            if keyPath == "playbackLikelyToKeepUp" {
+//                playerView.player.play()
+//            }
+//        } else if let playerViewController = playerViewController {
+//            if keyPath == "playbackLikelyToKeepUp" {
+//                playerViewController.player.play()
+//            }
+//        }
+//
+        if let keyPath = keyPath, keyPath == "isPictureInPicturePossible", let playerView = playerView, object as? AVPictureInPictureController == playerView.pictureInPictureController {
+            // Your code here for handling isPictureInPicturePossible
+        }
+    }
+
+    func pictureInPictureControllerDidStopPictureInPicture(_ pictureInPictureController:AVPictureInPictureController) {
+
+    }
+
+    func pictureInPictureControllerDidStartPictureInPicture(_ pictureInPictureController:AVPictureInPictureController) {
+
+    }
+
+    func pictureInPictureControllerWillStopPictureInPicture(_ pictureInPictureController:AVPictureInPictureController) {
+
+    }
+
+    func pictureInPictureController(pictureInPictureController:AVPictureInPictureController!, failedToStartPictureInPictureWithError error:NSError!) {
+
+    }
+
+    func pictureInPictureControllerWillStartPictureInPicture(_ pictureInPictureController:AVPictureInPictureController) {
+
+    }
+
+    func pictureInPictureController(_ pictureInPictureController:AVPictureInPictureController, restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler:@escaping (Bool) -> Void) {
+
+    }
+    
+    func pictureInPictureController(_ pictureInPictureController: AVPictureInPictureController, failedToStartPictureInPictureWithError error: Error) {
+        
+    }
+
+    // MARK: - JWPlayer State Delegate
+
+    func jwplayerContentIsBuffering(_ player:JWPlayer) {
+        self.onBuffer?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, isBufferingWithReason reason:JWBufferReason) {
+        self.onBuffer?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, updatedBuffer percent:Double, position time:JWTimeData) {
+        self.onUpdateBuffer?(["percent": percent, "position": time])
+    }
+
+    func jwplayer(_ player:JWPlayer, didFinishLoadingWithTime loadTime:TimeInterval) {
+        self.onLoaded?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, isAttemptingToPlay playlistItem:JWPlayerItem, reason:JWPlayReason) {
+        self.onAttemptPlay?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, isPlayingWithReason reason:JWPlayReason) {
+        self.onPlay?([:])
+
+        userPaused = false
+        wasInterrupted = false
+    }
+
+    func jwplayer(_ player:JWPlayer, willPlayWithReason reason:JWPlayReason) {
+        self.onBeforePlay?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, didPauseWithReason reason:JWPauseReason) {
+        self.onPause?([:])
+
+        if !wasInterrupted {
+            userPaused = true
+        }
+    }
+
+    func jwplayer(_ player:JWPlayer, didBecomeIdleWithReason reason:JWIdleReason) {
+        self.onIdle?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, isVisible:Bool) {
+        self.onVisible?(["visible": isVisible])
+    }
+
+    func jwplayerContentWillComplete(_ player:JWPlayer) {
+        self.onBeforeComplete?([:])
+    }
+
+    func jwplayerContentDidComplete(_ player:JWPlayer) {
+        self.onComplete?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, didLoadPlaylistItem item:JWPlayerItem, at index:UInt) {
+//        var sourceDict: [String: Any] = [:]
+//        var file: String?
+//
+//        for source in item.videoSources {
+//            sourceDict["file"] = source.file?.absoluteString
+//            sourceDict["label"] = source.label
+//            sourceDict["default"] = source.defaultVideo
+//
+//            if source.defaultVideo {
+//                file = source.file?.absoluteString
+//            }
+//        }
+
+//        var schedDict: [String: Any] = [:]
+//
+//        if let schedules = item.adSchedule {
+//            for sched in schedules {
+//                schedDict["offset"] = sched.offset
+//                schedDict["tags"] = sched.tags
+//                schedDict["type"] = sched.type
+//            }
+//        }
+        
+//        var trackDict: [String: Any] = [:]
+
+//        if let tracks = item.mediaTracks {
+//            for track in tracks {
+//                trackDict["file"] = track.file?.absoluteString
+//                trackDict["label"] = track.label
+//                trackDict["default"] = track.defaultTrack
+//            }
+//        }
+
+//        let itemDict: [String: Any] = [
+//            "file": file ?? "",
+//            "mediaId": item.mediaId as Any,
+//            "title": item.title as Any,
+//            "description": item.description,
+//            "image": item.posterImage?.absoluteString ?? "",
+//            "startTime": item.startTime,
+//            "adVmap": item.vmapURL?.absoluteString ?? "",
+//            "recommendations": item.recommendations?.absoluteString ?? "",
+//            "sources": sourceDict,
+//            "adSchedule": schedDict,
+//            "tracks": trackDict
+//        ]
+
+        do {
+            let data:Data! = try JSONSerialization.data(withJSONObject: item.toJSONObject(), options:.prettyPrinted)
+            self.onPlaylistItem?(["playlistItem": String(data:data, encoding:String.Encoding.utf8) as Any, "index": index])
+        } catch {
+            print("Error converting dictionary to JSON data: \(error)")
+        }
+
+//        item.addObserver(self, forKeyPath:"playbackLikelyToKeepUp", options:.new, context:nil)
+    }
+
+    func jwplayer(_ player:JWPlayer, didLoadPlaylist playlist:[JWPlayerItem]) {
+        let playlistArray:NSMutableArray! = NSMutableArray()
+
+        for item:JWPlayerItem? in playlist {
+//            var file:String!
+//
+//            var sourceDict: [String: Any] = [:]
+//
+//            for source in item?.videoSources ?? [] {
+//                sourceDict["file"] = source.file?.absoluteString
+//                sourceDict["label"] = source.label
+//                sourceDict["default"] = source.defaultVideo
+//
+//                if source.defaultVideo {
+//                    file = source.file?.absoluteString ?? ""
+//                }
+//            }
+//
+//            var schedDict: [String: Any] = [:]
+//            if let adSchedule = item?.adSchedule {
+//                for sched in adSchedule {
+//                    schedDict["offset"] = sched.offset
+//                    schedDict["tags"] = sched.tags
+//                    schedDict["type"] = sched.type
+//                }
+//            }
+//
+//            var trackDict: [String: Any] = [:]
+//
+//            if let mediaTracks = item?.mediaTracks {
+//                for track in mediaTracks {
+//                    trackDict["file"] = track.file?.absoluteString
+//                    trackDict["label"] = track.label
+//                    trackDict["default"] = track.defaultTrack
+//                }
+//            }
+//
+//            let itemDict: [String: Any] = [
+//                "file": file ?? "",
+//                "mediaId": item?.mediaId ?? "",
+//                "title": item?.title ?? "",
+//                "description": item?.description ?? "",
+//                "image": item?.posterImage?.absoluteString ?? "",
+//                "startTime": item?.startTime ?? 0,
+//                "adVmap": item?.vmapURL?.absoluteString ?? "",
+//                "recommendations": item?.recommendations?.absoluteString ?? "",
+//                "sources": sourceDict as Any,
+//                "adSchedule": trackDict,
+//                "tracks": schedDict
+//            ]
+
+            playlistArray.add(item?.toJSONObject() as Any)
+         }
+
+        do {
+            let data:Data! = try JSONSerialization.data(withJSONObject: playlistArray as Any, options:.prettyPrinted)
+
+            self.onPlaylist?(["playlist": String(data:data as Data, encoding:String.Encoding.utf8) as Any])
+        } catch {
+            print("Error converting dictionary to JSON data: \(error)")
+        }
+    }
+
+    func jwplayerPlaylistHasCompleted(_ player:JWPlayer) {
+        self.onPlaylistComplete?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, usesMediaType type:JWMediaType) {
+
+    }
+    
+    func jwplayer(_ player: JWPlayer, playbackRateChangedTo rate: Double, at time: TimeInterval) {
+        self.onRateChanged?(["rate": rate, "at": time])
+    }
+
+    func jwplayerHasSeeked(_ player:JWPlayer) {
+        self.onSeeked?([:])
+    }
+    
+    func jwplayer(_ player: JWPlayer, seekedFrom oldPosition: TimeInterval, to newPosition: TimeInterval) {
+        self.onSeek?(["from": oldPosition, "to": newPosition])
+    }
+
+    func jwplayer(_ player:JWPlayer, updatedCues cues:[JWCue]) {
+
+    }
+
+    // MARK: - JWPlayer Ad Delegate
+
+    func jwplayer(_ player:JWPlayer, adEvent event:JWAdEvent) {
+        self.onAdEvent?(["client": event.client, "type": event.type])
+    }
+
+// pragma Mark - Casting methods
+
+    func setUpCastController() {
+        if (playerView != nil) && playerView.player as! Bool && (castController == nil) {
+           castController = JWCastController(player:playerView.player)
+           castController.delegate = self
+       }
+
+       self.scanForDevices()
+    }
+
+    func scanForDevices() {
+       if castController != nil {
+           castController.startDiscovery()
+       }
+    }
+
+    func stopScanForDevices() {
+       if castController != nil {
+           castController.stopDiscovery()
+       }
+    }
+
+    func presentCastDialog() {
+        GCKCastContext.sharedInstance().presentCastDialog()
+    }
+
+    func startDiscovery() {
+        GCKCastContext.sharedInstance().discoveryManager.startDiscovery()
+    }
+
+    func stopDiscovery() {
+        GCKCastContext.sharedInstance().discoveryManager.stopDiscovery()
+    }
+
+    func discoveryActive() -> Bool {
+        return GCKCastContext.sharedInstance().discoveryManager.discoveryActive
+    }
+
+    func hasDiscoveredDevices() -> Bool {
+        return GCKCastContext.sharedInstance().discoveryManager.hasDiscoveredDevices
+    }
+
+    func discoveryState() -> GCKDiscoveryState {
+        return GCKCastContext.sharedInstance().discoveryManager.discoveryState
+    }
+
+    func setPassiveScan(passive:Bool) {
+        GCKCastContext.sharedInstance().discoveryManager.passiveScan = passive
+    }
+
+    func castState() -> GCKCastState {
+        return GCKCastContext.sharedInstance().castState
+    }
+
+    func deviceCount() -> UInt {
+        return GCKCastContext.sharedInstance().discoveryManager.deviceCount
+    }
+
+    func getAvailableDevices() -> [JWCastingDevice]! {
+        return castController.availableDevices
+    }
+
+    func connectedDevice() -> JWCastingDevice! {
+        return castController.connectedDevice
+    }
+
+    func connectToDevice(device:JWCastingDevice!) {
+        return castController.connectToDevice(device)
+    }
+
+    func cast() {
+        return castController.cast()
+    }
+
+    func stopCasting() {
+        return castController.stopCasting()
+    }
+
+    // MARK: - JWPlayer Cast Delegate
+    
+    func castController(_ controller: JWCastController, castingBeganWithDevice device: JWCastingDevice) {
+        self.onCasting?([:])
+    }
+    
+    func castController(_ controller:JWCastController, castingEndedWithError error: Error?) {
+        self.onCastingEnded?(["error": error as Any])
+    }
+
+    func castController(_ controller:JWCastController, castingFailedWithError error: Error) {
+        self.onCastingFailed?(["error": error as Any])
+    }
+
+    func castController(_ controller:JWCastController, connectedTo device: JWCastingDevice) {
+        let dict:NSMutableDictionary! = NSMutableDictionary()
+
+        dict.setObject(device.name, forKey:"name" as NSCopying)
+        dict.setObject(device.identifier, forKey:"identifier" as NSCopying)
+        
+        do {
+            let data:Data! = try JSONSerialization.data(withJSONObject: dict as Any, options:.prettyPrinted)
+
+            self.onConnectedToCastingDevice?(["device": String(data:data as Data, encoding:String.Encoding.utf8) as Any])
+        } catch {
+            print("Error converting dictionary to JSON data: \(error)")
+        }
+    }
+    
+    func castController(_ controller:JWCastController, connectionFailedWithError error: Error) {
+        self.onConnectionFailed?(["error": error as Any])
+    }
+
+    func castController(_ controller: JWCastController, connectionRecoveredWithDevice device:JWCastingDevice) {
+        self.onConnectionRecovered?([:])
+    }
+
+    func castController(_ controller: JWCastController, connectionSuspendedWithDevice device: JWCastingDevice) {
+        self.onConnectionTemporarilySuspended?([:])
+    }
+
+    func castController(_ controller: JWCastController, devicesAvailable devices:[JWCastingDevice]) {
+        self.availableDevices = devices
+
+        var devicesInfo: [[String: Any]] = []
+        for device in devices {
+            var dict: [String: Any] = [:]
+
+            dict["name"] = device.name
+            dict["identifier"] = device.identifier
+
+            devicesInfo.append(dict)
+        }
+
+        do {
+            let data:Data! = try JSONSerialization.data(withJSONObject: devicesInfo as Any, options:.prettyPrinted)
+
+            self.onCastingDevicesAvailable?(["devices": String(data:data as Data, encoding:String.Encoding.utf8) as Any])
+        } catch {
+            print("Error converting dictionary to JSON data: \(error)")
+        }
+    }
+    
+    func castController(_ controller: JWCastController, disconnectedWithError error: (Error)?) {
+        self.onDisconnectedFromCastingDevice?(["error": error as Any])
+    }
+
+    // MARK: - JWPlayer AV Delegate
+
+    func jwplayer(_ player:JWPlayer, audioTracksUpdated levels:[JWMediaSelectionOption]) {
+        self.onAudioTracks?([:])
+    }
+
+    func jwplayer(_ player:JWPlayer, audioTrackChanged currentLevel:Int) {
+
+    }
+    
+    func jwplayer(_ player: JWPlayer, captionPresented caption: [String], at time: JWTimeData) {
+        
+    }
+
+    func jwplayer(_ player:JWPlayer, captionTrackChanged index:Int) {
+
+    }
+
+    func jwplayer(_ player: JWPlayer, visualQualityChanged currentVisualQuality: JWVisualQuality) {
+        
+    }
+    
+    func jwplayer(_ player:JWPlayer, qualityLevelChanged currentLevel:Int) {
+
+    }
+    
+    func jwplayer(_ player:JWPlayer, qualityLevelsUpdated levels:[JWVideoSource]) {
+
+    }
+
+    func jwplayer(_ player:JWPlayer, updatedCaptionList options:[JWMediaSelectionOption]) {
+
+    }
+
+    // MARK: - JWPlayer audio session && interruption handling
+
+    func initAudioSession(category:String?, categoryOptions:[String]?, mode:String?) {
+        self.setObservers()
+
+        var somethingChanged:Bool = false
+
+        if !(category == audioCategory) || (categoryOptions != nil && !categoryOptions!.elementsEqual(audioCategoryOptions)) {
+            somethingChanged = true
+            audioCategory = category
+            audioCategoryOptions = categoryOptions
+            self.setCategory(categoryName: category, categoryOptions:categoryOptions)
+        }
+
+        if !(mode == audioMode) {
+            somethingChanged = true
+            audioMode = mode
+            self.setMode(modeName: mode)
+        }
+
+        if somethingChanged {
+            do {
+                try audioSession.setActive(true)
+                print("setActive - success")
+            } catch {
+                print("setActive - error: @%@", error)
+            }
+        }
+    }
+
+    func deinitAudioSession() {
+        do {
+            try audioSession?.setActive(false, options: .notifyOthersOnDeactivation)
+            print("setUnactive - success")
+        } catch {
+            print("setUnactive - error: @%@", error)
+        }
+        audioSession = nil
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = [:]
+        UIApplication.shared.endReceivingRemoteControlEvents()
+    }
+
+    func setObservers() {
+        if audioSession == nil {
+            audioSession = AVAudioSession.sharedInstance()
+
+            NotificationCenter.default.addObserver(self,
+                                                   selector:#selector(handleMediaServicesReset),
+                                                   name:AVAudioSession.mediaServicesWereResetNotification,
+                                                       object:audioSession)
+
+            NotificationCenter.default.addObserver(self,
+                                                   selector: #selector(audioSessionInterrupted(_:)),
+                                                   name: AVAudioSession.interruptionNotification,
+                                                       object: audioSession)
+
+            NotificationCenter.default.addObserver(self,
+                                                   selector:#selector(applicationWillResignActive(_:)),
+                                                   name:UIApplication.willResignActiveNotification, object:nil)
+
+            NotificationCenter.default.addObserver(self,
+                                                   selector:#selector(applicationDidEnterBackground(_:)),
+                                                   name:UIApplication.didEnterBackgroundNotification,
+                                                           object:nil)
+
+            NotificationCenter.default.addObserver(self,
+                                                   selector:#selector(applicationWillEnterForeground(_:)),
+                                                   name:UIApplication.willEnterForegroundNotification, object:nil)
+
+            NotificationCenter.default.addObserver(self,
+                                                   selector: #selector(audioRouteChanged(_:)),
+                                                   name: AVAudioSession.routeChangeNotification,
+                                                   object: nil)
+        }
+    }
+
+    func setCategory(categoryName:String!, categoryOptions:[String]!) {
+        if (audioSession == nil) {
+            audioSession = AVAudioSession.sharedInstance()
+        }
+
+        var category:AVAudioSession.Category! = nil
+        if categoryName.isEqual("Ambient") {
+            category = .ambient
+        } else if categoryName.isEqual("SoloAmbient") {
+            category = .soloAmbient
+        } else if categoryName.isEqual("Playback") {
+            category = .playback
+        } else if categoryName.isEqual("Record") {
+            category = .record
+        } else if categoryName.isEqual("PlayAndRecord") {
+            category = .playAndRecord
+        } else if categoryName.isEqual("MultiRoute") {
+            category = .multiRoute
+        } else {
+            category = .playback
+        }
+
+        var options: AVAudioSession.CategoryOptions = []
+        if categoryOptions.contains("MixWithOthers") {
+            options.insert(.mixWithOthers)
+        }
+        if categoryOptions.contains("DuckOthers") {
+            options.insert(.duckOthers)
+        }
+        if categoryOptions.contains("AllowBluetooth") {
+            options.insert(.allowBluetooth)
+        }
+        if categoryOptions.contains("InterruptSpokenAudioAndMix") {
+            options.insert(.interruptSpokenAudioAndMixWithOthers)
+        }
+        if categoryOptions.contains("AllowBluetoothA2DP") {
+            options.insert(.allowBluetoothA2DP)
+        }
+        if categoryOptions.contains("AllowAirPlay") {
+            options.insert(.allowAirPlay)
+        }
+        if categoryOptions.contains("OverrideMutedMicrophone") {
+            if #available(iOS 14.5, *) {
+                options.insert(.overrideMutedMicrophoneInterruption)
+            } else {
+                // Handle the case for earlier versions if needed
+            }
+        }
+        
+        do {
+            try audioSession.setCategory(category, options: options)
+            print("setCategory - success")
+        } catch {
+            print("setCategory - error: @%@", error)
+        }
+    }
+
+    func setMode(modeName:String!) {
+        if (audioSession == nil) {
+            audioSession = AVAudioSession.sharedInstance()
+        }
+
+        var mode:AVAudioSession.Mode! = nil
+
+        if modeName.isEqual("Default") {
+            mode = .default
+        } else if modeName.isEqual("VoiceChat") {
+            mode = .voiceChat
+        } else if modeName.isEqual("VideoChat") {
+            mode = .videoChat
+        } else if modeName.isEqual("GameChat") {
+            mode = .gameChat
+        } else if modeName.isEqual("VideoRecording") {
+            mode = .videoRecording
+        } else if modeName.isEqual("Measurement") {
+            mode = .measurement
+        } else if modeName.isEqual("MoviePlayback") {
+            mode = .moviePlayback
+        } else if modeName.isEqual("SpokenAudio") {
+            mode = .spokenAudio
+        } else if modeName.isEqual("VoicePrompt") {
+            if #available(iOS 12.0, *) {
+                mode = .voicePrompt
+            } else {
+                // Fallback on earlier versions
+            }
+        }
+
+        if (mode != nil) {
+            do {
+                try audioSession.setMode(mode)
+                print("setMode - success")
+            } catch {
+                print("setMode - error: @%@", error)
+            }
+        }
+    }
+    
+    @objc func audioSessionInterrupted(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+            let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
+            let type = AVAudioSession.InterruptionType(rawValue: typeValue) else {
+                return
+        }
+        
+        switch type {
+        case .began:
+            DispatchQueue.main.async { [self] in
+                wasInterrupted = true
+
+                if (playerView != nil) {
+                    playerView.player.pause()
+                } else if (playerViewController != nil) {
+                    playerViewController.player.pause()
+                }
+                print("handleInterruption :- Pause")
+            }
+        case .ended:
+            guard let optionsValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt else { return }
+            let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
+            if options.contains(.shouldResume) && !userPaused && backgroundAudioEnabled {
+                // Interruption ended. Playback should resume.
+                DispatchQueue.main.async { [self] in
+                    if (playerView != nil) {
+                        playerView.player.play()
+                    } else if (playerViewController != nil) {
+                        playerViewController.player.play()
+                    }
+                    print("handleInterruption :- Play")
+                }
+            }
+            else {
+                // Interruption ended. Playback should not resume.
+                DispatchQueue.main.async { [self] in
+                    wasInterrupted = true
+
+                    if (playerView != nil) {
+                        playerView.player.pause()
+                    } else if (playerViewController != nil) {
+                        playerViewController.player.pause()
+                    }
+                    print("handleInterruption :- Pause")
+                }
+            }
+        @unknown default:
+            break
+        }
+    }
+
+    // Service reset
+    @objc func handleMediaServicesReset() {
+        // • Handle this notification by fully reconfiguring audio
+    }
+
+    // Inactive
+    // Hack for ios 14 stopping audio when going to background
+    @objc func applicationWillResignActive(_ notification: Notification) {
+        if !userPaused && backgroundAudioEnabled {
+            if (playerView != nil) && playerView.player.getState() == .playing {
+                playerView.player.play()
+            } else if (playerViewController != nil) && playerViewController.player.getState() == .playing {
+                playerViewController.player.play()
+            }
+        }
+    }
+
+    // Background
+    @objc func applicationDidEnterBackground(_ notification: Notification) {
+
+    }
+
+    // Active
+    @objc func applicationWillEnterForeground(_ notification: Notification) {
+        if !userPaused && backgroundAudioEnabled {
+            if (playerView != nil) && playerView.player.getState() == .playing {
+                playerView.player.play()
+            } else if (playerViewController != nil) && playerViewController.player.getState() == .playing {
+                playerViewController.player.play()
+            }
+        }
+    }
+
+    // Route change
+    @objc func audioRouteChanged(_ notification: Notification) {
+        guard let userInfo = notification.userInfo else { return }
+        guard let reason = userInfo[AVAudioSessionRouteChangeReasonKey] as? Int else { return }
+
+        if reason == AVAudioSession.RouteChangeReason.oldDeviceUnavailable.hashValue {
+            if (playerView != nil) {
+                playerView.player.pause()
+            } else if (playerViewController != nil) {
+                playerViewController.player.pause()
+            }
+        }
+    }
+
+}