VEX-5682: iOS Swift Conversion (#11)

Converts ios implementation from objective-c to swift.

ios/Video/Features/RCTPictureInPicture.swift

@@ -0,0 +1,75 @@
+import AVFoundation
+import AVKit
+import MediaAccessibility
+import React
+import Foundation
+
+#if TARGET_OS_IOS
+class RCTPictureInPicture: NSObject, AVPictureInPictureControllerDelegate {
+    private var _onPictureInPictureStatusChanged: RCTDirectEventBlock?
+    private var _onRestoreUserInterfaceForPictureInPictureStop: RCTDirectEventBlock?
+    private var _restoreUserInterfaceForPIPStopCompletionHandler:((Bool) -> Void)? = nil
+    private var _pipController:AVPictureInPictureController?
+    private var _isActive:Bool = false
+    
+    init(_ onPictureInPictureStatusChanged: @escaping RCTDirectEventBlock, _ onRestoreUserInterfaceForPictureInPictureStop: @escaping RCTDirectEventBlock) {
+        _onPictureInPictureStatusChanged = onPictureInPictureStatusChanged
+        _onRestoreUserInterfaceForPictureInPictureStop = onRestoreUserInterfaceForPictureInPictureStop
+    }
+    
+    func pictureInPictureControllerDidStartPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
+        guard let _onPictureInPictureStatusChanged = _onPictureInPictureStatusChanged else { return }
+        
+        _onPictureInPictureStatusChanged([ "isActive": NSNumber(value: true)])
+    }
+    
+    func pictureInPictureControllerDidStopPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
+        guard let _onPictureInPictureStatusChanged = _onPictureInPictureStatusChanged else { return }
+        
+        _onPictureInPictureStatusChanged([ "isActive": NSNumber(value: false)])
+    }
+    
+    func pictureInPictureController(_ pictureInPictureController: AVPictureInPictureController, restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void) {
+        
+        assert(_restoreUserInterfaceForPIPStopCompletionHandler == nil, "restoreUserInterfaceForPIPStopCompletionHandler was not called after picture in picture was exited.")
+        
+        guard let _onRestoreUserInterfaceForPictureInPictureStop = _onRestoreUserInterfaceForPictureInPictureStop else { return }
+        
+        _onRestoreUserInterfaceForPictureInPictureStop([:])
+        
+        _restoreUserInterfaceForPIPStopCompletionHandler = completionHandler
+    }
+    
+    func setRestoreUserInterfaceForPIPStopCompletionHandler(_ restore:Bool) {
+        guard let _restoreUserInterfaceForPIPStopCompletionHandler = _restoreUserInterfaceForPIPStopCompletionHandler else { return }
+        _restoreUserInterfaceForPIPStopCompletionHandler(restore)
+        self._restoreUserInterfaceForPIPStopCompletionHandler = nil
+    }
+    
+    func setupPipController(_ playerLayer: AVPlayerLayer?) {
+        guard playerLayer != nil && AVPictureInPictureController.isPictureInPictureSupported() else { return }
+        // Create new controller passing reference to the AVPlayerLayer
+        _pipController = AVPictureInPictureController(playerLayer:playerLayer!)
+        _pipController?.delegate = self
+    }
+    
+    func setPictureInPicture(_ isActive:Bool) {
+        if _isActive == isActive {
+            return
+        }
+        _isActive = isActive
+        
+        guard let _pipController = _pipController else { return }
+        
+        if _isActive && !_pipController.isPictureInPictureActive {
+            DispatchQueue.main.async(execute: {
+                _pipController.startPictureInPicture()
+            })
+        } else if !_isActive && _pipController.isPictureInPictureActive {
+            DispatchQueue.main.async(execute: {
+                _pipController.stopPictureInPicture()
+            })
+        }
+    }
+}
+#endif

ios/Video/Features/RCTPlayerObserver.swift

@@ -0,0 +1,212 @@
+import AVFoundation
+import AVKit
+import Foundation
+
+@objc
+protocol RCTPlayerObserverHandlerObjc {
+    func handleDidFailToFinishPlaying(notification:NSNotification!)
+    func handlePlaybackStalled(notification:NSNotification!)
+    func handlePlayerItemDidReachEnd(notification:NSNotification!)
+    // unused
+//    func handleAVPlayerAccess(notification:NSNotification!)
+}
+
+protocol RCTPlayerObserverHandler: RCTPlayerObserverHandlerObjc {
+    func handleTimeUpdate(time:CMTime)
+    func handleReadyForDisplay(changeObject: Any, change:NSKeyValueObservedChange<Bool>)
+    func handleTimeMetadataChange(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<[AVMetadataItem]?>)
+    func handlePlayerItemStatusChange(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<AVPlayerItem.Status>)
+    func handlePlaybackBufferKeyEmpty(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<Bool>)
+    func handlePlaybackLikelyToKeepUp(playerItem:AVPlayerItem, change:NSKeyValueObservedChange<Bool>)
+    func handlePlaybackRateChange(player: AVPlayer, change: NSKeyValueObservedChange<Float>)
+    func handleExternalPlaybackActiveChange(player: AVPlayer, change: NSKeyValueObservedChange<Bool>)
+    func handleViewControllerOverlayViewFrameChange(overlayView:UIView, change:NSKeyValueObservedChange<CGRect>)
+}
+
+class RCTPlayerObserver: NSObject {
+
+    var _handlers: RCTPlayerObserverHandler!
+    
+    var player:AVPlayer? {
+        didSet {
+            if player == nil {
+                removePlayerObservers()
+                removePlayerTimeObserver()
+            } else {
+                addPlayerObservers()
+                addPlayerTimeObserver()
+            }
+        }
+    }
+    var playerItem:AVPlayerItem? {
+        didSet {
+            if playerItem == nil {
+                removePlayerItemObservers()
+            } else {
+                addPlayerItemObservers()
+            }
+        }
+    }
+    var playerViewController:AVPlayerViewController? {
+        didSet {
+            if playerViewController == nil {
+                removePlayerViewControllerObservers()
+            } else {
+                addPlayerViewControllerObservers()
+            }
+        }
+    }
+    var playerLayer:AVPlayerLayer? {
+        didSet {
+            if playerLayer == nil {
+                removePlayerLayerObserver()
+            } else {
+                addPlayerLayerObserver()
+            }
+        }
+    }
+    
+    private var _progressUpdateInterval:TimeInterval = 250
+    private var _timeObserver:Any?
+    
+    private var _playerRateChangeObserver:NSKeyValueObservation?
+    private var _playerExpernalPlaybackActiveObserver:NSKeyValueObservation?
+    private var _playerItemStatusObserver:NSKeyValueObservation?
+    private var _playerPlaybackBufferEmptyObserver:NSKeyValueObservation?
+    private var _playerPlaybackLikelyToKeepUpObserver:NSKeyValueObservation?
+    private var _playerTimedMetadataObserver:NSKeyValueObservation?
+    private var _playerViewControllerReadyForDisplayObserver:NSKeyValueObservation?
+    private var _playerLayerReadyForDisplayObserver:NSKeyValueObservation?
+    private var _playerViewControllerOverlayFrameObserver:NSKeyValueObservation?
+    
+    deinit {
+        NotificationCenter.default.removeObserver(_handlers)
+    }
+    
+    func addPlayerObservers() {
+        guard let player = player else {
+            return
+        }
+        
+        _playerRateChangeObserver = player.observe(\.rate, changeHandler: _handlers.handlePlaybackRateChange)
+        _playerExpernalPlaybackActiveObserver = player.observe(\.isExternalPlaybackActive, changeHandler: _handlers.handleExternalPlaybackActiveChange)
+    }
+    
+    func removePlayerObservers() {
+        _playerRateChangeObserver?.invalidate()
+        _playerExpernalPlaybackActiveObserver?.invalidate()
+    }
+    
+    func addPlayerItemObservers() {
+        guard let playerItem = playerItem else { return }
+
+        _playerItemStatusObserver = playerItem.observe(\.status, options:  [.new, .old], changeHandler: _handlers.handlePlayerItemStatusChange)
+        _playerPlaybackBufferEmptyObserver = playerItem.observe(\.isPlaybackBufferEmpty, options:  [.new, .old], changeHandler: _handlers.handlePlaybackBufferKeyEmpty)
+        _playerPlaybackLikelyToKeepUpObserver = playerItem.observe(\.isPlaybackLikelyToKeepUp, options:  [.new, .old], changeHandler: _handlers.handlePlaybackLikelyToKeepUp)
+        _playerTimedMetadataObserver = playerItem.observe(\.timedMetadata, options:  [.new], changeHandler: _handlers.handleTimeMetadataChange)
+    }
+    
+    func removePlayerItemObservers() {
+        _playerItemStatusObserver?.invalidate()
+        _playerPlaybackBufferEmptyObserver?.invalidate()
+        _playerPlaybackLikelyToKeepUpObserver?.invalidate()
+        _playerTimedMetadataObserver?.invalidate()
+    }
+
+    func addPlayerViewControllerObservers() {
+        guard let playerViewController = playerViewController else { return }
+        
+        _playerViewControllerReadyForDisplayObserver = playerViewController.observe(\.isReadyForDisplay, options:  [.new], changeHandler: _handlers.handleReadyForDisplay)
+        
+        _playerViewControllerOverlayFrameObserver = playerViewController.contentOverlayView?.observe(\.frame, options:  [.new, .old], changeHandler: _handlers.handleViewControllerOverlayViewFrameChange)
+    }
+    
+    func removePlayerViewControllerObservers() {
+        _playerViewControllerReadyForDisplayObserver?.invalidate()
+        _playerViewControllerOverlayFrameObserver?.invalidate()
+    }
+    
+    func addPlayerLayerObserver() {
+        _playerLayerReadyForDisplayObserver = playerLayer?.observe(\.isReadyForDisplay, options:  [.new], changeHandler: _handlers.handleReadyForDisplay)
+    }
+    
+    func removePlayerLayerObserver() {
+        _playerLayerReadyForDisplayObserver?.invalidate()
+    }
+    
+    func addPlayerTimeObserver() {
+        removePlayerTimeObserver()
+        let progressUpdateIntervalMS:Float64 = _progressUpdateInterval / 1000
+        // @see endScrubbing in AVPlayerDemoPlaybackViewController.m
+        // of https://developer.apple.com/library/ios/samplecode/AVPlayerDemo/Introduction/Intro.html
+        _timeObserver = player?.addPeriodicTimeObserver(
+            forInterval: CMTimeMakeWithSeconds(progressUpdateIntervalMS, preferredTimescale: Int32(NSEC_PER_SEC)),
+            queue:nil,
+            using:_handlers.handleTimeUpdate
+        )
+    }
+    
+    /* Cancels the previously registered time observer. */
+    func removePlayerTimeObserver() {
+        if let timeObserver = _timeObserver {
+            player?.removeTimeObserver(timeObserver)
+            _timeObserver = nil
+        }
+    }
+    
+    func addTimeObserverIfNotSet() {
+        if (_timeObserver == nil) {
+            addPlayerTimeObserver()
+        }
+    }
+    
+    func replaceTimeObserverIfSet(_ newUpdateInterval:Float64? = nil) {
+        if let newUpdateInterval = newUpdateInterval {
+            _progressUpdateInterval = newUpdateInterval
+        }
+        if (_timeObserver != nil) {
+            addPlayerTimeObserver()
+        }
+    }
+    
+    func attachPlayerEventListeners() {
+
+        NotificationCenter.default.removeObserver(_handlers,
+                                                  name:NSNotification.Name.AVPlayerItemDidPlayToEndTime,
+                                                  object:player?.currentItem)
+        NotificationCenter.default.addObserver(_handlers,
+                                               selector:#selector(RCTPlayerObserverHandler.handlePlayerItemDidReachEnd(notification:)),
+                                               name:NSNotification.Name.AVPlayerItemDidPlayToEndTime,
+                                               object:player?.currentItem)
+        
+        NotificationCenter.default.removeObserver(_handlers,
+                                                  name:NSNotification.Name.AVPlayerItemPlaybackStalled,
+                                                  object:nil)
+        NotificationCenter.default.addObserver(_handlers,
+                                               selector:#selector(RCTPlayerObserverHandler.handlePlaybackStalled(notification:)),
+                                               name:NSNotification.Name.AVPlayerItemPlaybackStalled,
+                                               object:nil)
+        NotificationCenter.default.removeObserver(_handlers,
+                                                  name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
+                                                  object:nil)
+        NotificationCenter.default.addObserver(_handlers,
+                                               selector:#selector(RCTPlayerObserverHandler.handleDidFailToFinishPlaying(notification:)),
+                                               name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
+                                               object:nil)
+        // Unused
+//        NotificationCenter.default.removeObserver(_handlers,
+//                                                  name:NSNotification.Name.AVPlayerItemNewAccessLogEntry,
+//                                                  object:nil)
+//        NotificationCenter.default.addObserver(_handlers,
+//                                               selector: #selector(RCTPlayerObserverHandler.handleAVPlayerAccess(notification:)),
+//                                               name:NSNotification.Name.AVPlayerItemNewAccessLogEntry,
+//                                               object:nil)
+        
+    }
+    
+    func clearPlayer() {
+        player = nil
+        playerItem = nil
+        NotificationCenter.default.removeObserver(_handlers)
+    }
+}

ios/Video/Features/RCTPlayerOperations.swift

@@ -0,0 +1,160 @@
+import AVFoundation
+import MediaAccessibility
+
+let RCTVideoUnset = -1
+
+/*!
+ * Collection of mutating functions
+ */
+enum RCTPlayerOperations {
+    
+    static func setSideloadedText(player:AVPlayer?, textTracks:[TextTrack]?, criteria:SelectedTrackCriteria?) {
+        let type = criteria?.type
+        let textTracks:[TextTrack]! = textTracks ?? RCTVideoUtils.getTextTrackInfo(player)
+        
+        // The first few tracks will be audio & video track
+        let firstTextIndex:Int = 0
+        for firstTextIndex in 0..<(player?.currentItem?.tracks.count ?? 0) {
+            if player?.currentItem?.tracks[firstTextIndex].assetTrack?.hasMediaCharacteristic(.legible) ?? false {
+                break
+            }
+        }
+        
+        var selectedTrackIndex:Int = RCTVideoUnset
+        
+        if (type == "disabled") {
+            // Do nothing. We want to ensure option is nil
+        } else if (type == "language") {
+            let selectedValue = criteria?.value as? String
+            for i in 0..<textTracks.count {
+                let currentTextTrack = textTracks[i]
+                if (selectedValue == currentTextTrack.language) {
+                    selectedTrackIndex = i
+                    break
+                }
+            }
+        } else if (type == "title") {
+            let selectedValue = criteria?.value as? String
+            for i in 0..<textTracks.count {
+                let currentTextTrack = textTracks[i]
+                if (selectedValue == currentTextTrack.title) {
+                    selectedTrackIndex = i
+                    break
+                }
+            }
+        } else if (type == "index") {
+            if let value = criteria?.value, let index = value as? Int {
+                if textTracks.count > index {
+                    selectedTrackIndex = index
+                }
+            }
+        }
+        
+        // in the situation that a selected text track is not available (eg. specifies a textTrack not available)
+        if (type != "disabled") && selectedTrackIndex == RCTVideoUnset {
+            let captioningMediaCharacteristics = MACaptionAppearanceCopyPreferredCaptioningMediaCharacteristics(.user) as! CFArray
+            let captionSettings = captioningMediaCharacteristics as? [AnyHashable]
+            if ((captionSettings?.contains(AVMediaCharacteristic.transcribesSpokenDialogForAccessibility)) != nil) {
+                selectedTrackIndex = 0 // If we can't find a match, use the first available track
+                let systemLanguage = NSLocale.preferredLanguages.first
+                for i in 0..<textTracks.count {
+                    let currentTextTrack = textTracks[i]
+                    if systemLanguage == currentTextTrack.language {
+                        selectedTrackIndex = i
+                        break
+                    }
+                }
+            }
+        }
+        
+        for i in firstTextIndex..<(player?.currentItem?.tracks.count ?? 0) {
+            var isEnabled = false
+            if selectedTrackIndex != RCTVideoUnset {
+                isEnabled = i == selectedTrackIndex + firstTextIndex
+            }
+            player?.currentItem?.tracks[i].isEnabled = isEnabled
+        }
+    }
+    
+    // UNUSED
+    static func setStreamingText(player:AVPlayer?, criteria:SelectedTrackCriteria?) {
+        let type = criteria?.type
+        let group:AVMediaSelectionGroup! = player?.currentItem?.asset.mediaSelectionGroup(forMediaCharacteristic: AVMediaCharacteristic.legible)
+        var mediaOption:AVMediaSelectionOption!
+        
+        if (type == "disabled") {
+            // Do nothing. We want to ensure option is nil
+        } else if (type == "language") || (type == "title") {
+            let value = criteria?.value as? String
+            for i in 0..<group.options.count {
+                let currentOption:AVMediaSelectionOption! = group.options[i]
+                var optionValue:String!
+                if (type == "language") {
+                    optionValue = currentOption.extendedLanguageTag
+                } else {
+                    optionValue = currentOption.commonMetadata.map(\.value)[0] as! String
+                }
+                if (value == optionValue) {
+                    mediaOption = currentOption
+                    break
+                }
+            }
+            //} else if ([type isEqualToString:@"default"]) {
+            //  option = group.defaultOption; */
+        } else if (type == "index") {
+            if let value = criteria?.value, let index = value as? Int {
+                if group.options.count > index {
+                    mediaOption = group.options[index]
+                }
+            }
+        } else { // default. invalid type or "system"
+            player?.currentItem?.selectMediaOptionAutomatically(in: group)
+            return
+        }
+        
+        // If a match isn't found, option will be nil and text tracks will be disabled
+        player?.currentItem?.select(mediaOption, in:group)
+    }
+    
+    static func setMediaSelectionTrackForCharacteristic(player:AVPlayer?, characteristic:AVMediaCharacteristic, criteria:SelectedTrackCriteria?) {
+        let type = criteria?.type
+        let group:AVMediaSelectionGroup! = player?.currentItem?.asset.mediaSelectionGroup(forMediaCharacteristic: characteristic)
+        var mediaOption:AVMediaSelectionOption!
+        
+        if (type == "disabled") {
+            // Do nothing. We want to ensure option is nil
+        } else if (type == "language") || (type == "title") {
+            let value = criteria?.value as? String
+            for i in 0..<group.options.count {
+                let currentOption:AVMediaSelectionOption! = group.options[i]
+                var optionValue:String!
+                if (type == "language") {
+                    optionValue = currentOption.extendedLanguageTag
+                } else {
+                    optionValue = currentOption.commonMetadata.map(\.value)[0] as? String
+                }
+                if (value == optionValue) {
+                    mediaOption = currentOption
+                    break
+                }
+            }
+            //} else if ([type isEqualToString:@"default"]) {
+            //  option = group.defaultOption; */
+        } else if type == "index" {
+            if let value = criteria?.value, let index = value as? Int {
+                if group.options.count > index {
+                    mediaOption = group.options[index]
+                }
+            }
+        } else if let group = group { // default. invalid type or "system"
+            player?.currentItem?.selectMediaOptionAutomatically(in: group)
+            return
+        }
+        
+        if let group = group {
+            // If a match isn't found, option will be nil and text tracks will be disabled
+            player?.currentItem?.select(mediaOption, in:group)
+        }
+        
+    }
+}

ios/Video/Features/RCTResourceLoaderDelegate.swift

@@ -0,0 +1,258 @@
+import AVFoundation
+
+class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSessionDelegate {
+    
+    private var _loadingRequest:AVAssetResourceLoadingRequest?
+    private var _requestingCertificate:Bool = false
+    private var _requestingCertificateErrored:Bool = false
+    private var _drm: DRMParams?
+    private var _reactTag: NSNumber?
+    private var _onVideoError: RCTDirectEventBlock?
+    private var _onGetLicense: RCTDirectEventBlock?
+    
+    
+    init(
+        asset: AVURLAsset,
+        drm: DRMParams?,
+        onVideoError: RCTDirectEventBlock?,
+        onGetLicense: RCTDirectEventBlock?,
+        reactTag: NSNumber
+    ) {
+        super.init()
+        let queue = DispatchQueue(label: "assetQueue")
+        asset.resourceLoader.setDelegate(self, queue: queue)
+        _reactTag = reactTag
+        _onVideoError = onVideoError
+        _onGetLicense = onGetLicense
+        _drm = drm
+    }
+    
+    deinit {
+        _loadingRequest?.finishLoading()
+    }
+    
+    func resourceLoader(_ resourceLoader:AVAssetResourceLoader, shouldWaitForRenewalOfRequestedResource renewalRequest:AVAssetResourceRenewalRequest) -> Bool {
+        return loadingRequestHandling(renewalRequest)
+    }
+    
+    func resourceLoader(_ resourceLoader:AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest:AVAssetResourceLoadingRequest) -> Bool {
+        return loadingRequestHandling(loadingRequest)
+    }
+    
+    func resourceLoader(_ resourceLoader:AVAssetResourceLoader, didCancel loadingRequest:AVAssetResourceLoadingRequest) {
+        NSLog("didCancelLoadingRequest")
+    }
+    
+    func base64DataFromBase64String(base64String:String?) -> Data? {
+        if let base64String = base64String {
+            return Data(base64Encoded:base64String)
+        }
+        return nil
+    }
+    
+    func setLicenseResult(_ license:String!) {
+        guard let respondData = self.base64DataFromBase64String(base64String: license),
+              let _loadingRequest = _loadingRequest else {
+                  setLicenseResultError("No data from JS license response")
+                  return
+              }
+        let dataRequest:AVAssetResourceLoadingDataRequest! = _loadingRequest.dataRequest
+        dataRequest.respond(with: respondData)
+        _loadingRequest.finishLoading()
+    }
+    
+    func setLicenseResultError(_ error:String!) {
+        if _loadingRequest != nil {
+            self.finishLoadingWithError(error: RCTVideoErrorHandler.fromJSPart(error))
+        }
+    }
+    
+    func finishLoadingWithError(error:NSError!) -> Bool {
+        if let _loadingRequest = _loadingRequest, let error = error {
+            let licenseError:NSError! = error
+            _loadingRequest.finishLoading(with: licenseError)
+            
+            _onVideoError?([
+                "error": [
+                    "code": NSNumber(value: error.code),
+                    "localizedDescription": error.localizedDescription == nil ? "" : error.localizedDescription,
+                    "localizedFailureReason": ((error as NSError).localizedFailureReason == nil ? "" : (error as NSError).localizedFailureReason) ?? "",
+                    "localizedRecoverySuggestion": ((error as NSError).localizedRecoverySuggestion == nil ? "" : (error as NSError).localizedRecoverySuggestion) ?? "",
+                    "domain": (error as NSError).domain
+                ],
+                "target": _reactTag
+            ])
+            
+        }
+        return false
+    }
+    
+    func loadingRequestHandling(_ loadingRequest:AVAssetResourceLoadingRequest!) -> Bool {
+        if _requestingCertificate {
+            return true
+        } else if _requestingCertificateErrored {
+            return false
+        }
+        _loadingRequest = loadingRequest
+        
+        let url = loadingRequest.request.url
+        guard let _drm = _drm else {
+            return finishLoadingWithError(error: RCTVideoErrorHandler.noDRMData)
+        }
+        
+        var contentId:String!
+        let contentIdOverride:String! = _drm.contentId
+        if contentIdOverride != nil {
+            contentId = contentIdOverride
+        } else if (_onGetLicense != nil) {
+            contentId = url?.host
+        } else {
+            contentId = url?.absoluteString.replacingOccurrences(of: "skd://", with:"")
+        }
+        
+        let drmType:String! = _drm.type
+        guard drmType == "fairplay" else {
+            return finishLoadingWithError(error: RCTVideoErrorHandler.noDRMData)
+        }
+        
+        let certificateStringUrl:String! = _drm.certificateUrl
+        guard let certificateStringUrl = certificateStringUrl, let certificateURL = URL(string: certificateStringUrl.addingPercentEncoding(withAllowedCharacters: .urlFragmentAllowed) ?? "") else {
+            return finishLoadingWithError(error: RCTVideoErrorHandler.noCertificateURL)
+        }
+        DispatchQueue.global().async { [weak self] in
+            guard let self = self else { return }
+            var certificateData:Data?
+            if (_drm.base64Certificate != nil) {
+                certificateData = Data(base64Encoded: certificateData! as Data, options: .ignoreUnknownCharacters)
+            } else {
+                do {
+                   certificateData = try Data(contentsOf: certificateURL)
+                } catch {}
+            }
+
+            guard let certificateData = certificateData else {
+                self.finishLoadingWithError(error: RCTVideoErrorHandler.noCertificateData)
+                self._requestingCertificateErrored = true
+                return
+            }
+            
+            var contentIdData:NSData!
+            if self._onGetLicense != nil {
+                contentIdData = contentId.data(using: .utf8) as NSData?
+            } else {
+               contentIdData = NSData(bytes: contentId.cString(using: String.Encoding.utf8), length:contentId.lengthOfBytes(using: String.Encoding.utf8))
+            }
+            
+            let dataRequest:AVAssetResourceLoadingDataRequest! = loadingRequest.dataRequest
+            guard dataRequest != nil else {
+                self.finishLoadingWithError(error: RCTVideoErrorHandler.noCertificateData)
+                self._requestingCertificateErrored = true
+                return
+            }
+            
+            var spcError:NSError!
+            var spcData: Data?
+            do {
+                spcData = try loadingRequest.streamingContentKeyRequestData(forApp: certificateData, contentIdentifier: contentIdData as Data, options: nil)
+            } catch let spcError {
+                print("SPC error")
+            }
+            // Request CKC to the server
+            var licenseServer:String! = _drm.licenseServer
+            if spcError != nil {
+                self.finishLoadingWithError(error: spcError)
+                self._requestingCertificateErrored = true
+            }
+            
+            guard spcData != nil else {
+                self.finishLoadingWithError(error: RCTVideoErrorHandler.noSPC)
+                self._requestingCertificateErrored = true
+                return
+            }
+            
+            // js client has a onGetLicense callback and will handle license fetching
+            if let _onGetLicense = self._onGetLicense {
+                let base64Encoded = spcData?.base64EncodedString(options: [])
+                self._requestingCertificate = true
+                if licenseServer == nil {
+                    licenseServer = ""
+                }
+                _onGetLicense(["licenseUrl": licenseServer,
+                               "contentId": contentId,
+                               "spcBase64": base64Encoded,
+                               "target": self._reactTag])
+                
+                
+            } else if licenseServer != nil {
+                self.fetchLicense(
+                    licenseServer: licenseServer,
+                    spcData: spcData,
+                    contentId: contentId,
+                    dataRequest: dataRequest
+                )
+            }
+        }
+        return true
+    }
+    
+    func fetchLicense(
+        licenseServer: String,
+        spcData: Data?,
+        contentId: String,
+        dataRequest: AVAssetResourceLoadingDataRequest!
+    ) {
+        var request = URLRequest(url: URL(string: licenseServer)!)
+        request.httpMethod = "POST"
+        
+        // HEADERS
+        if let headers = _drm?.headers {
+            for item in headers {
+                guard let key = item.key as? String, let value = item.value as? String else {
+                    continue
+                }
+                request.setValue(value, forHTTPHeaderField: key)
+            }
+        }
+        
+        if (_onGetLicense != nil) {
+            request.httpBody = spcData
+        } else {
+            let spcEncoded = spcData?.base64EncodedString(options: [])
+            let spcUrlEncoded = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, spcEncoded as? CFString? as! CFString, nil, "?=&+" as CFString, CFStringBuiltInEncodings.UTF8.rawValue) as? String
+            let post = String(format:"spc=%@&%@", spcUrlEncoded as! CVarArg, contentId)
+            let postData = post.data(using: String.Encoding.utf8, allowLossyConversion:true)
+            request.httpBody = postData
+        }
+        
+        let postDataTask = URLSession.shared.dataTask(with: request as URLRequest, completionHandler:{ [weak self] (data:Data!,response:URLResponse!,error:Error!) in
+            guard let self = self else { return }
+            let httpResponse:HTTPURLResponse! = response as! HTTPURLResponse
+            guard error == nil else {
+                print("Error getting license from \(licenseServer), HTTP status code \(httpResponse.statusCode)")
+                self.finishLoadingWithError(error: error as NSError?)
+                self._requestingCertificateErrored = true
+                return
+            }
+            guard httpResponse.statusCode == 200 else {
+                print("Error getting license from \(licenseServer), HTTP status code \(httpResponse.statusCode)")
+                self.finishLoadingWithError(error: RCTVideoErrorHandler.licenseRequestNotOk(httpResponse.statusCode))
+                self._requestingCertificateErrored = true
+                return
+            }
+            
+            guard data != nil else {
+                self.finishLoadingWithError(error: RCTVideoErrorHandler.noDataFromLicenseRequest)
+                self._requestingCertificateErrored = true
+                return
+            }
+            
+            if (self._onGetLicense != nil) {
+                dataRequest.respond(with: data)
+            } else if let decodedData = Data(base64Encoded: data, options: []) {
+                dataRequest.respond(with: decodedData)
+            }
+            self._loadingRequest?.finishLoading()
+        })
+        postDataTask.resume()
+    }
+}

ios/Video/Features/RCTVideoErrorHandling.swift

@@ -0,0 +1,83 @@
+enum RCTVideoError : Int {
+    case fromJSPart
+    case licenseRequestNotOk
+    case noDataFromLicenseRequest
+    case noSPC
+    case noDataRequest
+    case noCertificateData
+    case noCertificateURL
+    case noFairplayDRM
+    case noDRMData
+}
+
+enum RCTVideoErrorHandler {
+    
+    static let noDRMData: NSError = NSError(
+        domain: "RCTVideo",
+        code: RCTVideoError.noDRMData.rawValue,
+        userInfo: [
+            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
+            NSLocalizedFailureReasonErrorKey: "No drm object found.",
+            NSLocalizedRecoverySuggestionErrorKey: "Have you specified the 'drm' prop?"
+        ])
+    
+    static let noCertificateURL: NSError = NSError(
+        domain: "RCTVideo",
+        code: RCTVideoError.noCertificateURL.rawValue,
+        userInfo: [
+            NSLocalizedDescriptionKey: "Error obtaining DRM License.",
+            NSLocalizedFailureReasonErrorKey: "No certificate URL has been found.",
+            NSLocalizedRecoverySuggestionErrorKey: "Did you specified the prop certificateUrl?"
+        ])
+    
+    static let noCertificateData: NSError = NSError(
+        domain: "RCTVideo",
+        code: RCTVideoError.noCertificateData.rawValue,
+        userInfo: [
+            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
+            NSLocalizedFailureReasonErrorKey: "No certificate data obtained from the specificied url.",
+            NSLocalizedRecoverySuggestionErrorKey: "Have you specified a valid 'certificateUrl'?"
+        ])
+    
+    static let noSPC:NSError! = NSError(
+        domain: "RCTVideo",
+        code: RCTVideoError.noSPC.rawValue,
+        userInfo: [
+            NSLocalizedDescriptionKey: "Error obtaining license.",
+            NSLocalizedFailureReasonErrorKey: "No spc received.",
+            NSLocalizedRecoverySuggestionErrorKey: "Check your DRM config."
+        ])
+    
+    static let noDataFromLicenseRequest:NSError! = NSError(
+        domain: "RCTVideo",
+        code: RCTVideoError.noDataFromLicenseRequest.rawValue,
+        userInfo: [
+            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
+            NSLocalizedFailureReasonErrorKey: "No data received from the license server.",
+            NSLocalizedRecoverySuggestionErrorKey: "Is the licenseServer ok?."
+        ])
+    
+    static func licenseRequestNotOk(_ statusCode: Int) -> NSError {
+        return NSError(
+            domain: "RCTVideo",
+            code: RCTVideoError.licenseRequestNotOk.rawValue,
+            userInfo: [
+                NSLocalizedDescriptionKey: "Error obtaining license.",
+                NSLocalizedFailureReasonErrorKey: String(
+                    format:"License server responded with status code %li",
+                    (statusCode)
+                ),
+                NSLocalizedRecoverySuggestionErrorKey: "Did you send the correct data to the license Server? Is the server ok?"
+            ])
+    }
+
+    static func fromJSPart(_ error: String) -> NSError {
+        return NSError(domain: "RCTVideo",
+            code: RCTVideoError.fromJSPart.rawValue,
+            userInfo: [
+                NSLocalizedDescriptionKey: error,
+                NSLocalizedFailureReasonErrorKey: error,
+                NSLocalizedRecoverySuggestionErrorKey: error
+            ])
+    }
+}

ios/Video/Features/RCTVideoSave.swift

@@ -0,0 +1,75 @@
+import AVFoundation
+
+enum RCTVideoSave {
+
+    static func save(
+        options:NSDictionary!,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject:@escaping RCTPromiseRejectBlock,
+        
+        playerItem: AVPlayerItem?
+    ) {
+        let asset:AVAsset! = playerItem?.asset
+        
+        guard asset != nil else {
+            reject("ERROR_ASSET_NIL", "Asset is nil", nil)
+            return
+        }
+        
+        guard let exportSession = AVAssetExportSession(asset: asset, presetName:AVAssetExportPresetHighestQuality) else {
+            reject("ERROR_COULD_NOT_CREATE_EXPORT_SESSION", "Could not create export session", nil)
+            return
+        }
+        var path:String! = nil
+        path = RCTVideoSave.generatePathInDirectory(
+            directory: URL(fileURLWithPath: RCTVideoSave.cacheDirectoryPath() ?? "").appendingPathComponent("Videos").path,
+            withExtension: ".mp4")
+        let url:NSURL! = NSURL.fileURL(withPath: path) as NSURL
+        exportSession.outputFileType = AVFileType.mp4
+        exportSession.outputURL = url as URL?
+        exportSession.videoComposition = playerItem?.videoComposition
+        exportSession.shouldOptimizeForNetworkUse = true
+        exportSession.exportAsynchronously(completionHandler: {
+            
+            switch (exportSession.status) {
+            case .failed:
+                reject("ERROR_COULD_NOT_EXPORT_VIDEO", "Could not export video", exportSession.error)
+                break
+            case .cancelled:
+                reject("ERROR_EXPORT_SESSION_CANCELLED", "Export session was cancelled", exportSession.error)
+                break
+            default:
+                resolve(["uri": url.absoluteString])
+                break
+            }
+            
+        })
+    }
+    
+    static func generatePathInDirectory(directory: String?, withExtension `extension`: String?) -> String? {
+        let fileName = UUID().uuidString + (`extension` ?? "")
+        RCTVideoSave.ensureDirExists(withPath: directory)
+        return URL(fileURLWithPath: directory ?? "").appendingPathComponent(fileName).path
+    }
+    
+    static func cacheDirectoryPath() -> String? {
+        let array = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).map(\.path)
+        return array[0]
+    }
+    
+    static func ensureDirExists(withPath path: String?) -> Bool {
+        var isDir: ObjCBool = false
+        var error: Error?
+        let exists = FileManager.default.fileExists(atPath: path ?? "", isDirectory: &isDir)
+        if !(exists && isDir.boolValue) {
+            do {
+                try FileManager.default.createDirectory(atPath: path ?? "", withIntermediateDirectories: true, attributes: nil)
+            } catch {
+            }
+            if error != nil {
+                return false
+            }
+        }
+        return true
+    }
+}

ios/Video/Features/RCTVideoUtils.swift

@@ -0,0 +1,143 @@
+import AVFoundation
+
+/*!
+ * Collection of pure functions
+ */
+enum RCTVideoUtils {
+    
+    /*!
+     * Calculates and returns the playable duration of the current player item using its loaded time ranges.
+     *
+     * \returns The playable duration of the current player item in seconds.
+     */
+    static func calculatePlayableDuration(_ player:AVPlayer?) -> NSNumber {
+        guard let player = player,
+              let video:AVPlayerItem = player.currentItem,
+              video.status == AVPlayerItem.Status.readyToPlay else {
+            return 0
+        }
+        
+        var effectiveTimeRange:CMTimeRange?
+        for (_, value) in video.loadedTimeRanges.enumerated() {
+            let timeRange:CMTimeRange = value.timeRangeValue
+            if CMTimeRangeContainsTime(timeRange, time: video.currentTime()) {
+                effectiveTimeRange = timeRange
+                break
+            }
+        }
+        
+        if let effectiveTimeRange = effectiveTimeRange {
+            let playableDuration:Float64 = CMTimeGetSeconds(CMTimeRangeGetEnd(effectiveTimeRange))
+            if playableDuration > 0 {
+                return playableDuration as NSNumber
+            }
+        }
+        
+        return 0
+    }
+
+    static func urlFilePath(filepath:NSString!) -> NSURL! {
+        if filepath.contains("file://") {
+            return NSURL(string: filepath as String)
+        }
+        
+        // if no file found, check if the file exists in the Document directory
+        let paths:[String]! = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)
+        var relativeFilePath:String! = filepath.lastPathComponent
+        // the file may be multiple levels below the documents directory
+        let fileComponents:[String]! = filepath.components(separatedBy: "Documents/")
+        if fileComponents.count > 1 {
+            relativeFilePath = fileComponents[1]
+        }
+        
+        let path:String! = (paths.first! as NSString).appendingPathComponent(relativeFilePath)
+        if FileManager.default.fileExists(atPath: path) {
+            return NSURL.fileURL(withPath: path) as NSURL
+        }
+        return nil
+    }
+    
+    static func playerItemSeekableTimeRange(_ player:AVPlayer?) -> CMTimeRange {
+        if let playerItem = player?.currentItem,
+           playerItem.status == .readyToPlay,
+           let firstItem = playerItem.seekableTimeRanges.first {
+            return firstItem.timeRangeValue
+        }
+        
+        return (CMTimeRange.zero)
+    }
+    
+    static func playerItemDuration(_ player:AVPlayer?) -> CMTime {
+        if let playerItem = player?.currentItem,
+           playerItem.status == .readyToPlay {
+            return(playerItem.duration)
+        }
+        
+        return(CMTime.invalid)
+    }
+    
+    static func calculateSeekableDuration(_ player:AVPlayer?) -> NSNumber {
+        let timeRange:CMTimeRange = RCTVideoUtils.playerItemSeekableTimeRange(player)
+        if CMTIME_IS_NUMERIC(timeRange.duration)
+        {
+            return NSNumber(value: CMTimeGetSeconds(timeRange.duration))
+        }
+        return 0
+    }
+    
+    static func getAudioTrackInfo(_ player:AVPlayer?) -> [AnyObject]! {
+        guard let player = player else {
+            return []
+        }
+
+        let audioTracks:NSMutableArray! = NSMutableArray()
+        let group = player.currentItem?.asset.mediaSelectionGroup(forMediaCharacteristic: .audible)
+        for i in 0..<(group?.options.count ?? 0) {
+            let currentOption = group?.options[i]
+            var title = ""
+            let values = currentOption?.commonMetadata.map(\.value)
+            if (values?.count ?? 0) > 0, let value = values?[0] {
+                title = value as! String
+            }
+            let language:String! = currentOption?.extendedLanguageTag ?? ""
+            let audioTrack = [
+                "index": NSNumber(value: i),
+                "title": title,
+                "language": language
+            ] as [String : Any]
+            audioTracks.add(audioTrack)
+        }
+        return audioTracks as [AnyObject]?
+    }
+    
+    static func getTextTrackInfo(_ player:AVPlayer?) -> [TextTrack]! {
+        guard let player = player else {
+            return []
+        }
+
+        // if streaming video, we extract the text tracks
+        var textTracks:[TextTrack] = []
+        let group = player.currentItem?.asset.mediaSelectionGroup(forMediaCharacteristic: .legible)
+        for i in 0..<(group?.options.count ?? 0) {
+            let currentOption = group?.options[i]
+            var title = ""
+            let values = currentOption?.commonMetadata.map(\.value)
+            if (values?.count ?? 0) > 0, let value = values?[0] {
+                title = value as! String
+            }
+            let language:String! = currentOption?.extendedLanguageTag ?? ""
+            let textTrack = TextTrack([
+                "index": NSNumber(value: i),
+                "title": title,
+                "language": language
+            ])
+            textTracks.append(textTrack)
+        }
+        return textTracks
+    }
+    
+    // UNUSED
+    static func getCurrentTime(playerItem:AVPlayerItem?) -> Float {
+        return Float(CMTimeGetSeconds(playerItem?.currentTime() ?? .zero))
+    }
+}