VEX-5938: Update resource loader to handle encrypted local files (#12)

Adds offline decryption key and uses it to decrypt content during offline playback Jira: VEX-5938 https://jira.tenkasu.net/browse/VEX-5938 - Update to accept scheme for key required to play offline playback - Uses provided scheme to intercept call from player and return the key - Fixes player item observer removal pattern ### Reviews - Major reviewer (domain expert): @armadilio3
2021-10-28 10:34:05 +09:00
parent 8b75438148
commit e27baeb065
12 changed files with 573 additions and 379 deletions
--- a/ios/Video/Features/RCTPlayerObserver.swift
+++ b/ios/Video/Features/RCTPlayerObserver.swift
@@ -28,39 +28,43 @@ class RCTPlayerObserver: NSObject {
    var _handlers: RCTPlayerObserverHandler!
    
    var player:AVPlayer? {
+        willSet {
+            removePlayerObservers()
+            removePlayerTimeObserver()
+        }
        didSet {
-            if player == nil {
-                removePlayerObservers()
-                removePlayerTimeObserver()
-            } else {
+            if player != nil {
                addPlayerObservers()
                addPlayerTimeObserver()
            }
        }
    }
    var playerItem:AVPlayerItem? {
+        willSet {
+            removePlayerItemObservers()
+        }
        didSet {
-            if playerItem == nil {
-                removePlayerItemObservers()
-            } else {
+            if playerItem != nil {
                addPlayerItemObservers()
            }
        }
    }
    var playerViewController:AVPlayerViewController? {
+        willSet {
+            removePlayerViewControllerObservers()
+        }
        didSet {
-            if playerViewController == nil {
-                removePlayerViewControllerObservers()
-            } else {
+            if playerViewController != nil {
                addPlayerViewControllerObservers()
            }
        }
    }
    var playerLayer:AVPlayerLayer? {
+        willSet {
+            removePlayerLayerObserver()
+        }
        didSet {
            if playerLayer == nil {
-                removePlayerLayerObserver()
-            } else {
                addPlayerLayerObserver()
            }
        }
@@ -148,8 +152,8 @@ class RCTPlayerObserver: NSObject {
    
    /* Cancels the previously registered time observer. */
    func removePlayerTimeObserver() {
-        if let timeObserver = _timeObserver {
-            player?.removeTimeObserver(timeObserver)
+        if _timeObserver != nil {
+            player?.removeTimeObserver(_timeObserver)
            _timeObserver = nil
        }
    }
--- a/ios/Video/Features/RCTPlayerOperations.swift
+++ b/ios/Video/Features/RCTPlayerOperations.swift
@@ -1,5 +1,6 @@
 import AVFoundation
 import MediaAccessibility
+import Promises

 let RCTVideoUnset = -1

@@ -157,4 +158,23 @@ enum RCTPlayerOperations {
        }
        
    }
+
+    static func seek(player: AVPlayer, playerItem:AVPlayerItem, paused:Bool, seekTime:Float, seekTolerance:Float) -> Promise<Bool> {
+        let timeScale:Int = 1000
+        let cmSeekTime:CMTime = CMTimeMakeWithSeconds(Float64(seekTime), preferredTimescale: Int32(timeScale))
+        let current:CMTime = playerItem.currentTime()
+        let tolerance:CMTime = CMTimeMake(value: Int64(seekTolerance), timescale: Int32(timeScale))
+        
+        return Promise<Bool>(on: .global()) { fulfill, reject in
+            guard CMTimeCompare(current, cmSeekTime) != 0 else {
+                reject(NSError())
+                return
+            }
+            if !paused { player.pause() }
+
+            player.seek(to: cmSeekTime, toleranceBefore:tolerance, toleranceAfter:tolerance, completionHandler:{ (finished:Bool) in
+                fulfill(finished)
+            })
+        }
+    }
 }
--- a/ios/Video/Features/RCTResourceLoaderDelegate.swift
+++ b/ios/Video/Features/RCTResourceLoaderDelegate.swift
@@ -1,4 +1,5 @@
 import AVFoundation
+import Promises

 class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSessionDelegate {
    
@@ -6,6 +7,7 @@ class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSes
    private var _requestingCertificate:Bool = false
    private var _requestingCertificateErrored:Bool = false
    private var _drm: DRMParams?
+    private var _localSourceEncryptionKeyScheme: String?
    private var _reactTag: NSNumber?
    private var _onVideoError: RCTDirectEventBlock?
    private var _onGetLicense: RCTDirectEventBlock?
@@ -14,6 +16,7 @@ class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSes
    init(
        asset: AVURLAsset,
        drm: DRMParams?,
+        localSourceEncryptionKeyScheme: String?,
        onVideoError: RCTDirectEventBlock?,
        onGetLicense: RCTDirectEventBlock?,
        reactTag: NSNumber
@@ -25,6 +28,7 @@ class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSes
        _onVideoError = onVideoError
        _onGetLicense = onGetLicense
        _drm = drm
+        _localSourceEncryptionKeyScheme = localSourceEncryptionKeyScheme
    }
    
    deinit {
@@ -42,16 +46,9 @@ class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSes
    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),
+        guard let respondData = RCTVideoUtils.base64DataFromBase64String(base64String: license),
              let _loadingRequest = _loadingRequest else {
                  setLicenseResultError("No data from JS license response")
                  return
@@ -67,14 +64,13 @@ class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSes
        }
    }
    
-    func finishLoadingWithError(error:NSError!) -> Bool {
+    func finishLoadingWithError(error:Error!) -> Bool {
        if let _loadingRequest = _loadingRequest, let error = error {
-            let licenseError:NSError! = error
-            _loadingRequest.finishLoading(with: licenseError)
+            _loadingRequest.finishLoading(with: error as! NSError)
            
            _onVideoError?([
                "error": [
-                    "code": NSNumber(value: error.code),
+                    "code": NSNumber(value: (error as NSError).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) ?? "",
@@ -88,6 +84,35 @@ class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSes
    }
    
    func loadingRequestHandling(_ loadingRequest:AVAssetResourceLoadingRequest!) -> Bool {
+        if handleEmbeddedKey(loadingRequest) {
+            return true
+        }
+        
+        if _drm != nil {
+            return handleDrm(loadingRequest)
+        }
+        
+       return false
+    }
+    
+    func handleEmbeddedKey(_ loadingRequest:AVAssetResourceLoadingRequest!) -> Bool {
+        guard let url = loadingRequest.request.url,
+              let _localSourceEncryptionKeyScheme = _localSourceEncryptionKeyScheme,
+              let persistentKeyData = RCTVideoUtils.extractDataFromCustomSchemeUrl(from: url, scheme: _localSourceEncryptionKeyScheme)
+        else {
+            return false
+        }
+        
+        loadingRequest.contentInformationRequest?.contentType = AVStreamingKeyDeliveryPersistentContentKeyType
+        loadingRequest.contentInformationRequest?.isByteRangeAccessSupported = true
+        loadingRequest.contentInformationRequest?.contentLength = Int64(persistentKeyData.count)
+        loadingRequest.dataRequest?.respond(with: persistentKeyData)
+        loadingRequest.finishLoading()
+        
+        return true
+    }
+    
+    func handleDrm(_ loadingRequest:AVAssetResourceLoadingRequest!) -> Bool {
        if _requestingCertificate {
            return true
        } else if _requestingCertificateErrored {
@@ -95,164 +120,48 @@ class RCTResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate, URLSes
        }
        _loadingRequest = loadingRequest
        
-        let url = loadingRequest.request.url
-        guard let _drm = _drm else {
+        guard let _drm = _drm, let drmType = _drm.type, drmType == "fairplay" 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: [])
+        var promise: Promise<Data>
+        if _onGetLicense != nil {
+            let contentId = _drm.contentId ?? loadingRequest.request.url?.host
+            promise = RCTVideoDRM.handleWithOnGetLicense(
+                loadingRequest:loadingRequest,
+                contentId:contentId,
+                certificateUrl:_drm.certificateUrl,
+                base64Certificate:_drm.base64Certificate
+            ) .then{ spcData -> Void in
                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
-                )
+                self._onGetLicense?(["licenseUrl": self._drm?.licenseServer ?? "",
+                                     "contentId": contentId,
+                                     "spcBase64": spcData.base64EncodedString(options: []),
+                                     "target": self._reactTag])
            }
+        } else {
+            promise = RCTVideoDRM.handleInternalGetLicense(
+                loadingRequest:loadingRequest,
+                contentId:_drm.contentId,
+                licenseServer:_drm.licenseServer,
+                certificateUrl:_drm.certificateUrl,
+                base64Certificate:_drm.base64Certificate,
+                headers:_drm.headers
+            ) .then{ data -> Void in
+                    guard let dataRequest = loadingRequest.dataRequest else {
+                        throw RCTVideoErrorHandler.noCertificateData
+                    }
+                    dataRequest.respond(with:data)
+                    loadingRequest.finishLoading()
+                }
        }
+        
+        
+        promise.catch{ error in
+            self.finishLoadingWithError(error:error)
+            self._requestingCertificateErrored = true
+        }
+        
        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()
-    }
 }
--- a/ios/Video/Features/RCTVideoDRM.swift
+++ b/ios/Video/Features/RCTVideoDRM.swift
@@ -0,0 +1,168 @@
+import AVFoundation
+import Promises
+
+struct RCTVideoDRM {
+    @available(*, unavailable) private init() {}
+
+    static func fetchLicense(
+        licenseServer: String,
+        spcData: Data?,
+        contentId: String,
+        headers: [String:Any]?
+    ) -> Promise<Data> {
+        let request = createLicenseRequest(licenseServer:licenseServer, spcData:spcData, contentId:contentId, headers:headers)
+        
+        return Promise<Data>(on: .global()) { fulfill, reject in
+            let postDataTask = URLSession.shared.dataTask(with: request as URLRequest, completionHandler:{ (data:Data!,response:URLResponse!,error:Error!) in
+                
+                let httpResponse:HTTPURLResponse! = (response as! HTTPURLResponse)
+
+                guard error == nil else {
+                    print("Error getting license from \(licenseServer), HTTP status code \(httpResponse.statusCode)")
+                    reject(error)
+                    return
+                }
+                guard httpResponse.statusCode == 200 else {
+                    print("Error getting license from \(licenseServer), HTTP status code \(httpResponse.statusCode)")
+                    reject(RCTVideoErrorHandler.licenseRequestNotOk(httpResponse.statusCode))
+                    return
+                }
+                
+                guard data != nil, let decodedData = Data(base64Encoded: data, options: []) else {
+                    reject(RCTVideoErrorHandler.noDataFromLicenseRequest)
+                    return
+                }
+                
+                fulfill(decodedData)
+            })
+            postDataTask.resume()
+        }
+    }
+    
+    static func createLicenseRequest(
+        licenseServer: String,
+        spcData: Data?,
+        contentId: String,
+        headers: [String:Any]?
+    ) -> URLRequest {
+        var request = URLRequest(url: URL(string: licenseServer)!)
+        request.httpMethod = "POST"
+        
+        if let headers = 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)
+            }
+        }
+        
+        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
+        
+        return request
+    }
+    
+    static func fetchSpcData(
+        loadingRequest: AVAssetResourceLoadingRequest,
+        certificateData: Data,
+        contentIdData: Data
+    ) -> Promise<Data> {
+        return Promise<Data>(on: .global()) { fulfill, reject in
+            var spcError:NSError!
+            var spcData: Data?
+            do {
+                spcData = try loadingRequest.streamingContentKeyRequestData(forApp: certificateData, contentIdentifier: contentIdData as Data, options: nil)
+            } catch _ {
+                print("SPC error")
+            }
+            
+            if spcError != nil {
+                reject(spcError)
+            }
+            
+            guard let spcData = spcData else {
+                reject(RCTVideoErrorHandler.noSPC)
+                return
+            }
+            
+            fulfill(spcData)
+        }
+    }
+    
+    static func createCertificateData(certificateStringUrl:String?, base64Certificate:Bool?) -> Promise<Data> {
+        return Promise<Data>(on: .global()) { fulfill, reject in
+
+            guard let certificateStringUrl = certificateStringUrl,
+                  let certificateURL = URL(string: certificateStringUrl.addingPercentEncoding(withAllowedCharacters: .urlFragmentAllowed) ?? "") else {
+                      reject(RCTVideoErrorHandler.noCertificateURL)
+                return
+            }
+
+            var certificateData:Data?
+            do {
+               certificateData = try Data(contentsOf: certificateURL)
+                if (base64Certificate != nil) {
+                    certificateData = Data(base64Encoded: certificateData! as Data, options: .ignoreUnknownCharacters)
+                }
+            } catch {}
+            
+            guard let certificateData = certificateData else {
+                reject(RCTVideoErrorHandler.noCertificateData)
+                return
+            }
+            
+            fulfill(certificateData)
+        }
+    }
+    
+    static func handleWithOnGetLicense(loadingRequest: AVAssetResourceLoadingRequest, contentId:String?, certificateUrl:String?, base64Certificate:Bool?) -> Promise<Data> {
+        let contentIdData = contentId?.data(using: .utf8)
+        
+        return RCTVideoDRM.createCertificateData(certificateStringUrl:certificateUrl, base64Certificate:base64Certificate)
+            .then{ certificateData -> Promise<Data> in
+                guard let contentIdData = contentIdData else {
+                    throw RCTVideoError.invalidContentId as! Error
+                }
+                
+                return RCTVideoDRM.fetchSpcData(
+                    loadingRequest:loadingRequest,
+                    certificateData:certificateData,
+                    contentIdData:contentIdData
+                )
+            }
+    }
+    
+    static func handleInternalGetLicense(loadingRequest: AVAssetResourceLoadingRequest, contentId:String?, licenseServer:String?, certificateUrl:String?, base64Certificate:Bool?, headers: [String:Any]?) -> Promise<Data> {
+        let url = loadingRequest.request.url
+        
+        guard let contentId = contentId ?? url?.absoluteString.replacingOccurrences(of: "skd://", with:"") else {
+            return Promise(RCTVideoError.invalidContentId as! Error)
+        }
+        
+        let contentIdData = NSData(bytes: contentId.cString(using: String.Encoding.utf8), length:contentId.lengthOfBytes(using: String.Encoding.utf8)) as Data
+        
+        return RCTVideoDRM.createCertificateData(certificateStringUrl:certificateUrl, base64Certificate:base64Certificate)
+            .then{ certificateData in
+                return RCTVideoDRM.fetchSpcData(
+                    loadingRequest:loadingRequest,
+                    certificateData:certificateData,
+                    contentIdData:contentIdData
+                )
+            }
+            .then{ spcData -> Promise<Data> in
+                guard let licenseServer = licenseServer else {
+                    throw RCTVideoError.noLicenseServerURL as! Error
+                }
+                return RCTVideoDRM.fetchLicense(
+                    licenseServer: licenseServer,
+                    spcData: spcData,
+                    contentId: contentId,
+                    headers: headers
+                )
+            }
+    }
+}
--- a/ios/Video/Features/RCTVideoErrorHandling.swift
+++ b/ios/Video/Features/RCTVideoErrorHandling.swift
@@ -1,5 +1,6 @@
 enum RCTVideoError : Int {
    case fromJSPart
+    case noLicenseServerURL
    case licenseRequestNotOk
    case noDataFromLicenseRequest
    case noSPC
@@ -8,11 +9,12 @@ enum RCTVideoError : Int {
    case noCertificateURL
    case noFairplayDRM
    case noDRMData
+    case invalidContentId
 }

 enum RCTVideoErrorHandler {
    
-    static let noDRMData: NSError = NSError(
+    static let noDRMData = NSError(
        domain: "RCTVideo",
        code: RCTVideoError.noDRMData.rawValue,
        userInfo: [
@@ -21,7 +23,7 @@ enum RCTVideoErrorHandler {
            NSLocalizedRecoverySuggestionErrorKey: "Have you specified the 'drm' prop?"
        ])
    
-    static let noCertificateURL: NSError = NSError(
+    static let noCertificateURL = NSError(
        domain: "RCTVideo",
        code: RCTVideoError.noCertificateURL.rawValue,
        userInfo: [
@@ -30,7 +32,7 @@ enum RCTVideoErrorHandler {
            NSLocalizedRecoverySuggestionErrorKey: "Did you specified the prop certificateUrl?"
        ])
    
-    static let noCertificateData: NSError = NSError(
+    static let noCertificateData = NSError(
        domain: "RCTVideo",
        code: RCTVideoError.noCertificateData.rawValue,
        userInfo: [
@@ -39,7 +41,7 @@ enum RCTVideoErrorHandler {
            NSLocalizedRecoverySuggestionErrorKey: "Have you specified a valid 'certificateUrl'?"
        ])
    
-    static let noSPC:NSError! = NSError(
+    static let noSPC = NSError(
        domain: "RCTVideo",
        code: RCTVideoError.noSPC.rawValue,
        userInfo: [
@@ -48,13 +50,22 @@ enum RCTVideoErrorHandler {
            NSLocalizedRecoverySuggestionErrorKey: "Check your DRM config."
        ])
    
-    static let noDataFromLicenseRequest:NSError! = NSError(
+    static let noLicenseServerURL = NSError(
+        domain: "RCTVideo",
+        code: RCTVideoError.noLicenseServerURL.rawValue,
+        userInfo: [
+            NSLocalizedDescriptionKey: "Error obtaining DRM License.",
+            NSLocalizedFailureReasonErrorKey: "No license server URL has been found.",
+            NSLocalizedRecoverySuggestionErrorKey: "Did you specified the prop licenseServer?"
+        ])
+    
+    static let noDataFromLicenseRequest = 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?."
+            NSLocalizedRecoverySuggestionErrorKey: "Is the licenseServer ok?"
        ])
    
    static func licenseRequestNotOk(_ statusCode: Int) -> NSError {
@@ -80,4 +91,13 @@ enum RCTVideoErrorHandler {
                NSLocalizedRecoverySuggestionErrorKey: error
            ])
    }
+    
+    static let invalidContentId = NSError(
+        domain: "RCTVideo",
+        code: RCTVideoError.invalidContentId.rawValue,
+        userInfo: [
+            NSLocalizedDescriptionKey: "Error obtaining DRM license.",
+            NSLocalizedFailureReasonErrorKey: "No valide content Id received",
+            NSLocalizedRecoverySuggestionErrorKey: "Is the contentId and url ok?"
+        ])
 }
--- a/ios/Video/Features/RCTVideoUtils.swift
+++ b/ios/Video/Features/RCTVideoUtils.swift
@@ -1,4 +1,5 @@
 import AVFoundation
+import Promises

 /*!
 * Collection of pure functions
@@ -140,4 +141,110 @@ enum RCTVideoUtils {
    static func getCurrentTime(playerItem:AVPlayerItem?) -> Float {
        return Float(CMTimeGetSeconds(playerItem?.currentTime() ?? .zero))
    }
+    
+    static func base64DataFromBase64String(base64String:String?) -> Data? {
+        if let base64String = base64String {
+            return Data(base64Encoded:base64String)
+        }
+        return nil
+    }
+
+    static func replaceURLScheme(url: URL, scheme: String?) -> URL? {
+        var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        urlComponents?.scheme = scheme
+
+        return urlComponents?.url
+    }
+
+    static func extractDataFromCustomSchemeUrl(from url: URL, scheme: String) -> Data? {
+        guard url.scheme == scheme,
+              let adoptURL = RCTVideoUtils.replaceURLScheme(url:url, scheme: nil) else { return nil }
+
+        return Data(base64Encoded: adoptURL.absoluteString)
+    }
+    
+    static func generateMixComposition(_ asset:AVAsset) -> AVMutableComposition {
+        let mixComposition:AVMutableComposition = AVMutableComposition()
+        
+        let videoAsset:AVAssetTrack! = asset.tracks(withMediaType: AVMediaType.video).first
+        let videoCompTrack:AVMutableCompositionTrack! = mixComposition.addMutableTrack(withMediaType: AVMediaType.video, preferredTrackID:kCMPersistentTrackID_Invalid)
+        do {
+            try videoCompTrack.insertTimeRange(
+                CMTimeRangeMake(start: .zero, duration: videoAsset.timeRange.duration),
+                of: videoAsset,
+                at: .zero)
+        } catch {
+        }
+        
+        let audioAsset:AVAssetTrack! = asset.tracks(withMediaType: AVMediaType.audio).first
+        let audioCompTrack:AVMutableCompositionTrack! = mixComposition.addMutableTrack(withMediaType: AVMediaType.audio, preferredTrackID:kCMPersistentTrackID_Invalid)
+        do {
+            try audioCompTrack.insertTimeRange(
+                CMTimeRangeMake(start: .zero, duration: videoAsset.timeRange.duration),
+                of: audioAsset,
+                at: .zero)
+        } catch {
+        }
+        
+        return mixComposition
+    }
+    
+    static func getValidTextTracks(asset:AVAsset, assetOptions:NSDictionary?, mixComposition:AVMutableComposition, textTracks:[TextTrack]?) -> [TextTrack] {
+        let videoAsset:AVAssetTrack! = asset.tracks(withMediaType: AVMediaType.video).first
+        var validTextTracks:[TextTrack] = []
+        if let textTracks = textTracks, textTracks.count > 0 {
+            for i in 0..<textTracks.count {
+                var textURLAsset:AVURLAsset!
+                let textUri:String = textTracks[i].uri
+                if textUri.lowercased().hasPrefix("http") {
+                    textURLAsset = AVURLAsset(url: NSURL(string: textUri)! as URL, options:(assetOptions as! [String : Any]))
+                } else {
+                    textURLAsset = AVURLAsset(url: RCTVideoUtils.urlFilePath(filepath: textUri as NSString?) as URL, options:nil)
+                }
+                let textTrackAsset:AVAssetTrack! = textURLAsset.tracks(withMediaType: AVMediaType.text).first
+                if (textTrackAsset == nil) {continue} // fix when there's no textTrackAsset
+                validTextTracks.append(textTracks[i])
+                let textCompTrack:AVMutableCompositionTrack! = mixComposition.addMutableTrack(withMediaType: AVMediaType.text,
+                                                                                              preferredTrackID:kCMPersistentTrackID_Invalid)
+                do {
+                    try textCompTrack.insertTimeRange(
+                        CMTimeRangeMake(start: .zero, duration: videoAsset.timeRange.duration),
+                        of: textTrackAsset,
+                        at: .zero)
+                } catch {
+                }
+            }
+        }
+        return validTextTracks
+    }
+
+    static func delay(seconds: Int = 0) -> Promise<Void> {
+        return Promise<Void>(on: .global()) { fulfill, reject in
+            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + Double(Int64(seconds)) / Double(NSEC_PER_SEC), execute: {
+                fulfill(())
+            })
+        }
+    }
+    
+    static func prepareAsset(source:VideoSource) -> (asset:AVURLAsset?, assetOptions:NSMutableDictionary?)? {
+        guard source.uri != nil && source.uri != "" else { return nil }
+        var asset:AVURLAsset!
+        let bundlePath = Bundle.main.path(forResource: source.uri, ofType: source.type) ?? ""
+        let url = source.isNetwork || source.isAsset
+        ? URL(string: source.uri ?? "")
+        : URL(fileURLWithPath: bundlePath)
+        let assetOptions:NSMutableDictionary! = NSMutableDictionary()
+        
+        if source.isNetwork {
+            if let headers = source.requestHeaders, headers.count > 0 {
+                assetOptions.setObject(headers, forKey:"AVURLAssetHTTPHeaderFieldsKey" as NSCopying)
+            }
+            let cookies:[AnyObject]! = HTTPCookieStorage.shared.cookies
+            assetOptions.setObject(cookies, forKey:AVURLAssetHTTPCookiesKey as NSCopying)
+            asset = AVURLAsset(url: url!, options:assetOptions as! [String : Any])
+        } else {
+            asset = AVURLAsset(url: url!)
+        }
+        return (asset, assetOptions)
+    }
 }