react-native-compressor 1.8.16 → 1.8.18

package/ios/Audio/FormatConverter/FormatConverter+PCM.swift

@@ -0,0 +1,239 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AVFoundation
+
+// MARK: - internal helper functions
+
+extension FormatConverter {
+    func convertToPCM(completionHandler: FormatConverterCallback? = nil) {
+        guard let inputURL = inputURL else {
+            completionHandler?(Self.createError(message: "Input file can't be nil."))
+            return
+        }
+        guard let outputURL = outputURL else {
+            completionHandler?(Self.createError(message: "Output file can't be nil."))
+            return
+        }
+
+        guard let options = options, let outputFormat = options.format else {
+            completionHandler?(Self.createError(message: "Options can't be nil."))
+            return
+        }
+        var format: AudioFileTypeID
+
+        switch outputFormat {
+        case .aif:
+            format = kAudioFileAIFFType
+        case .wav:
+            format = kAudioFileWAVEType
+        case .caf:
+            format = kAudioFileCAFType
+        default:
+            completionHandler?(Self.createError(message: "Output file must be caf, wav or aif."))
+            return
+        }
+
+        var inputFile: ExtAudioFileRef?
+        var outputFile: ExtAudioFileRef?
+
+        func closeFiles() {
+            if let strongFile = inputFile {
+                if noErr != ExtAudioFileDispose(strongFile) {
+                    print("Error disposing input file, could have a memory leak")
+                }
+            }
+            inputFile = nil
+
+            if let strongFile = outputFile {
+                if noErr != ExtAudioFileDispose(strongFile) {
+                    print("Error disposing output file, could have a memory leak")
+                }
+            }
+            outputFile = nil
+        }
+
+        // make sure these are closed on any exit to avoid leaking the file objects
+        defer {
+            closeFiles()
+        }
+
+        if noErr != ExtAudioFileOpenURL(inputURL as CFURL, &inputFile) {
+            completionHandler?(Self.createError(message: "Unable to open the input file."))
+            return
+        }
+
+        guard let strongInputFile = inputFile else {
+            completionHandler?(Self.createError(message: "Unable to open the input file."))
+            return
+        }
+
+        var inputDescription = AudioStreamBasicDescription()
+        var inputDescriptionSize = UInt32(MemoryLayout.stride(ofValue: inputDescription))
+
+        if noErr != ExtAudioFileGetProperty(strongInputFile,
+                                            kExtAudioFileProperty_FileDataFormat,
+                                            &inputDescriptionSize,
+                                            &inputDescription)
+        {
+            completionHandler?(Self.createError(message: "Unable to get the input file data format."))
+            return
+        }
+
+        var outputDescription = createOutputDescription(options: options,
+                                                        outputFormatID: format,
+                                                        inputDescription: inputDescription)
+
+        let inputFormat = AudioFileFormat(rawValue: inputURL.pathExtension.lowercased()) ?? .unknown
+
+        guard inputFormat != outputFormat ||
+            outputDescription.mSampleRate != inputDescription.mSampleRate ||
+            outputDescription.mChannelsPerFrame != inputDescription.mChannelsPerFrame ||
+            outputDescription.mBitsPerChannel != inputDescription.mBitsPerChannel
+        else {
+            print("No conversion is needed, formats are the same. Copying to", outputURL)
+            // just copy it?
+            do {
+                try FileManager.default.copyItem(at: inputURL, to: outputURL)
+                completionHandler?(nil)
+            } catch let err as NSError {
+                print(err)
+            }
+            return
+        }
+
+        // Create destination file
+        if noErr != ExtAudioFileCreateWithURL(outputURL as CFURL,
+                                              format,
+                                              &outputDescription,
+                                              nil,
+                                              AudioFileFlags.eraseFile.rawValue, // overwrite old file if present
+                                              &outputFile)
+        {
+            completionProxy(error: Self.createError(message: "Unable to create output file at \(outputURL.path). " +
+                                "dstFormat \(outputDescription)"),
+            completionHandler: completionHandler)
+            return
+        }
+
+        guard let strongOutputFile = outputFile else {
+            completionProxy(error: Self.createError(message: "Output file is nil."),
+                            completionHandler: completionHandler)
+            return
+        }
+
+        // The format must be linear PCM (kAudioFormatLinearPCM).
+        // You must set this in order to encode or decode a non-PCM file data format.
+        // You may set this on PCM files to specify the data format used in your calls
+        // to read/write.
+        if noErr != ExtAudioFileSetProperty(strongInputFile,
+                                            kExtAudioFileProperty_ClientDataFormat,
+                                            inputDescriptionSize,
+                                            &outputDescription)
+        {
+            completionProxy(error: Self.createError(message: "Unable to set data format on input file."),
+                            completionHandler: completionHandler)
+            return
+        }
+
+        if noErr != ExtAudioFileSetProperty(strongOutputFile,
+                                            kExtAudioFileProperty_ClientDataFormat,
+                                            inputDescriptionSize,
+                                            &outputDescription)
+        {
+            completionProxy(error: Self.createError(message: "Unable to set the output file data format."),
+                            completionHandler: completionHandler)
+            return
+        }
+        let bufferByteSize: UInt32 = 32768
+        var srcBuffer = [UInt8](repeating: 0, count: Int(bufferByteSize))
+        var sourceFrameOffset: UInt32 = 0
+
+        srcBuffer.withUnsafeMutableBytes { body in
+            while true {
+                let mBuffer = AudioBuffer(mNumberChannels: inputDescription.mChannelsPerFrame,
+                                          mDataByteSize: bufferByteSize,
+                                          mData: body.baseAddress)
+
+                var fillBufList = AudioBufferList(mNumberBuffers: 1,
+                                                  mBuffers: mBuffer)
+                var frameCount: UInt32 = 0
+
+                if outputDescription.mBytesPerFrame > 0 {
+                    frameCount = bufferByteSize / outputDescription.mBytesPerFrame
+                }
+
+                if noErr != ExtAudioFileRead(strongInputFile,
+                                             &frameCount,
+                                             &fillBufList)
+                {
+                    completionProxy(error: Self.createError(message: "Error reading from the input file."),
+                                    completionHandler: completionHandler)
+                    return
+                }
+                // EOF
+                if frameCount == 0 { break }
+
+                sourceFrameOffset += frameCount
+
+                if noErr != ExtAudioFileWrite(strongOutputFile,
+                                              frameCount,
+                                              &fillBufList)
+                {
+                    completionProxy(error: Self.createError(message: "Error reading from the output file."),
+                                    completionHandler: completionHandler)
+                    return
+                }
+            }
+        }
+
+        closeFiles()
+
+        // no errors
+        completionHandler?(nil)
+    }
+
+    func createOutputDescription(options: Options,
+                                 outputFormatID: AudioFormatID,
+                                 inputDescription: AudioStreamBasicDescription) -> AudioStreamBasicDescription
+    {
+        let mFormatID: AudioFormatID = kAudioFormatLinearPCM
+
+        let mSampleRate = options.sampleRate ?? inputDescription.mSampleRate
+        let mChannelsPerFrame = options.channels ?? inputDescription.mChannelsPerFrame
+        var mBitsPerChannel = options.bitDepth ?? inputDescription.mBitsPerChannel
+
+        // For example: don't allow upsampling to 24bit if the src is 16
+        if options.bitDepthRule == .lessThanOrEqual, mBitsPerChannel > inputDescription.mBitsPerChannel {
+            mBitsPerChannel = inputDescription.mBitsPerChannel
+        }
+
+        var mBytesPerFrame = mBitsPerChannel * mChannelsPerFrame / 8
+        var mBytesPerPacket = options.bitDepth == nil ? inputDescription.mBytesPerPacket : mBytesPerFrame
+
+        if mBitsPerChannel == 0 {
+            mBitsPerChannel = 16
+            mBytesPerPacket = 2 * mChannelsPerFrame
+            mBytesPerFrame = 2 * mChannelsPerFrame
+        }
+
+        var mFormatFlags: AudioFormatFlags = kLinearPCMFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger
+        if outputFormatID == kAudioFileAIFFType {
+            mFormatFlags = mFormatFlags | kLinearPCMFormatFlagIsBigEndian
+        }
+
+        if outputFormatID == kAudioFileWAVEType, mBitsPerChannel == 8 {
+            // if is 8 BIT PER CHANNEL, remove kAudioFormatFlagIsSignedInteger
+            mFormatFlags &= ~kAudioFormatFlagIsSignedInteger
+        }
+
+        return AudioStreamBasicDescription(mSampleRate: mSampleRate,
+                                           mFormatID: mFormatID,
+                                           mFormatFlags: mFormatFlags,
+                                           mBytesPerPacket: mBytesPerPacket,
+                                           mFramesPerPacket: 1,
+                                           mBytesPerFrame: mBytesPerFrame,
+                                           mChannelsPerFrame: mChannelsPerFrame,
+                                           mBitsPerChannel: mBitsPerChannel,
+                                           mReserved: 0)
+    }
+}

package/ios/Audio/FormatConverter/FormatConverter+Utilities.swift

@@ -0,0 +1,103 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AVFoundation
+
+extension FormatConverter {
+    class func createError(message: String, code: Int = 1) -> NSError {
+        let userInfo = [NSLocalizedDescriptionKey: message]
+        return NSError(domain: "com.audiodesigndesk.FormatConverter.error",
+                       code: code,
+                       userInfo: userInfo)
+    }
+}
+
+public extension FormatConverter {
+    /// Is this file a PCM file?
+    /// - Parameters:
+    ///   - url: The URL to parse
+    ///   - ignorePathExtension: Do a deep parse rather than rely on the path extension
+    /// - Returns: Bool or nil if it couldn't be determined
+    class func isPCM(url: URL, ignorePathExtension _: Bool = false) -> Bool? {
+        guard let value = isCompressed(url: url) else { return nil }
+        return !value
+    }
+
+    /// Compressed format or not
+    class func isCompressed(url: URL, ignorePathExtension: Bool = false) -> Bool? {
+        guard !ignorePathExtension else {
+            return isCompressedExt(url: url)
+        }
+        let ext = url.pathExtension.lowercased()
+
+        switch ext {
+        case "wav", "bwf", "aif", "aiff", "caf":
+            return false
+
+        case "m4a", "mp3", "mp4", "m4v", "mpg", "flac", "ogg":
+            return true
+
+        default:
+            // if the file extension is missing or unknown, open the file and check it
+            return isCompressedExt(url: url) ?? false
+        }
+    }
+
+    private class func isCompressedExt(url: URL) -> Bool? {
+        var inputFile: ExtAudioFileRef?
+
+        func closeFiles() {
+            if let strongFile = inputFile {
+                // print("🗑 Disposing input", inputURL.path)
+                if noErr != ExtAudioFileDispose(strongFile) {
+                    print("Error disposing input file, could have a memory leak")
+                }
+            }
+            inputFile = nil
+        }
+
+        // make sure these are closed on any exit
+        defer {
+            closeFiles()
+        }
+
+        if noErr != ExtAudioFileOpenURL(url as CFURL,
+                                        &inputFile)
+        {
+            print("Unable to open", url.lastPathComponent)
+            return nil
+        }
+
+        guard let strongInputFile = inputFile else {
+            return nil
+        }
+
+        var inputDescription = AudioStreamBasicDescription()
+        var inputDescriptionSize = UInt32(MemoryLayout.stride(ofValue: inputDescription))
+
+        if noErr != ExtAudioFileGetProperty(strongInputFile,
+                                            kExtAudioFileProperty_FileDataFormat,
+                                            &inputDescriptionSize,
+                                            &inputDescription) {}
+
+        let mFormatID = inputDescription.mFormatID
+
+        switch mFormatID {
+        case kAudioFormatLinearPCM,
+             kAudioFormatAppleLossless: return false
+        default:
+            // basically all other format IDs are compressed
+            return true
+        }
+    }
+}
+
+extension Comparable {
+    // ie: 5.clamped(to: 7...10)
+    // ie: 5.0.clamped(to: 7.0...10.0)
+    // ie: "a".clamped(to: "b"..."h")
+    /// **OTCore:**
+    /// Returns the value clamped to the passed range.
+    @inlinable func clamped(to limits: ClosedRange<Self>) -> Self {
+        min(max(self, limits.lowerBound), limits.upperBound)
+    }
+}

package/ios/Audio/FormatConverter/FormatConverter.swift

@@ -0,0 +1,264 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AVFoundation
+
+/**
+ FormatConverter wraps the more complex AVFoundation and CoreAudio audio conversions in an easy to use format.
+ ```swift
+ let options = FormatConverter.Options()
+
+ // any options left nil will adopt the value of the input file
+ options.format = "wav"
+ options.sampleRate = 48000
+ options.bitDepth = 24
+
+ let converter = FormatConverter(inputURL: oldURL, outputURL: newURL, options: options)
+
+ converter.start { error in
+    // the error will be nil on success
+ }
+ ```
+ */
+public class FormatConverter {
+    // MARK: - properties
+
+    /// The source audio file
+    public var inputURL: URL?
+
+    /// The audio file to be created after conversion
+    public var outputURL: URL?
+
+    /// Options for conversion
+    public var options: Options?
+
+    // MARK: - private properties
+
+    // The reader needs to exist outside the start func otherwise the async nature of the
+    // AVAssetWriterInput will lose its reference
+    var reader: AVAssetReader?
+    var writer: AVAssetWriter?
+
+    // MARK: - initialization
+
+    /// init with input, output and options - then start()
+    public init(inputURL: URL,
+                outputURL: URL,
+                options: Options? = nil)
+    {
+        self.inputURL = inputURL
+        self.outputURL = outputURL
+        self.options = options ?? Options()
+    }
+
+    deinit {
+        reader = nil
+        writer = nil
+        inputURL = nil
+        outputURL = nil
+        options = nil
+    }
+
+    // MARK: - functions
+
+    /// The entry point for file conversion
+    /// - Parameter completionHandler: the callback that will be triggered when process has completed.
+    public func start(completionHandler: FormatConverterCallback? = nil) {
+        guard let inputURL = inputURL else {
+            completionHandler?(Self.createError(message: "Input file can't be nil."))
+            return
+        }
+
+        guard let outputURL = outputURL else {
+            completionHandler?(Self.createError(message: "Output file can't be nil."))
+            return
+        }
+
+        let inputFormat = AudioFileFormat(rawValue: inputURL.pathExtension.lowercased()) ?? .unknown
+        // verify inputFormat, only allow files with path extensions for speed?
+        guard FormatConverter.inputFormats.contains(inputFormat) else {
+            completionHandler?(Self.createError(message: "The input file format is in an incompatible format: \(inputFormat)"))
+            return
+        }
+
+        if FileManager.default.fileExists(atPath: outputURL.path) {
+            if options?.eraseFile == true {
+                print("Warning: removing existing file at", outputURL.path)
+                try? FileManager.default.removeItem(at: outputURL)
+            } else {
+                let message = "The output file exists already. You need to choose a unique URL or delete the file."
+                completionHandler?(Self.createError(message: message))
+                return
+            }
+        }
+
+        if options?.format == nil {
+            options?.format = AudioFileFormat(rawValue: outputURL.pathExtension.lowercased()) ?? .unknown
+        }
+
+        // Format checks are necessary as AVAssetReader has opinions about compressed
+
+        // PCM output, any supported input
+        if Self.isPCM(url: outputURL) == true {
+            // PCM output
+            convertToPCM(completionHandler: completionHandler)
+
+            // PCM input, compressed output
+        } else if Self.isPCM(url: inputURL) == true,
+                  Self.isCompressed(url: outputURL) == true
+        {
+            convertPCMToCompressed(completionHandler: completionHandler)
+
+            // Compressed input and output, won't do sample rate
+        } else if Self.isCompressed(url: inputURL) == true,
+                  Self.isCompressed(url: outputURL) == true
+        {
+            convertCompressed(completionHandler: completionHandler)
+
+        } else {
+            completionHandler?(Self.createError(message: "Unable to determine formats for conversion"))
+        }
+    }
+}
+
+// MARK: - Definitions
+
+public enum AudioFileFormat: String {
+    case aac
+    case aif
+    case aifc
+    case aiff
+    case au
+    case caf
+    case m4a
+    case m4v
+    case mov
+    case mp3
+    case mp4
+    case sd2
+    case snd
+    case ts
+    case unknown
+    case wav
+}
+
+public extension FormatConverter {
+
+    /// FormatConverterCallback is the callback format for start()
+    /// - Parameter: error This will contain one parameter of type Error which is nil if the conversion was successful.
+    typealias FormatConverterCallback = (_ error: Error?) -> Void
+
+    /// Formats that this class can write
+    static let outputFormats: [AudioFileFormat] = [.wav, .aif, .caf, .m4a]
+
+    static let defaultOutputFormat: AudioFileFormat = .wav
+
+    /// Formats that this class can read
+    static let inputFormats: [AudioFileFormat] = FormatConverter.outputFormats + [
+        .mp3, .snd, .au, .sd2,
+        .aif, .aiff, .aifc, .aac,
+        .mp4, .m4v, .mov, .ts,
+        .unknown, // allow files with no extension. convertToPCM can still read the type
+    ]
+
+    /// An option to block upsampling to a higher bit depth than the source.
+    /// For example, converting to 24bit from 16 doesn't have much benefit
+    enum BitDepthRule {
+        /// Don't allow upsampling to 24bit if the src is 16
+        case lessThanOrEqual
+
+        /// allow any conversaion
+        case any
+    }
+
+    /// The conversion options, leave any property nil to adopt the value of the input file
+    /// bitRate assumes a stereo bit rate and the converter will half it for mono
+    struct Options {
+        /// Audio Format
+        public var format: AudioFileFormat?
+        /// Sample Rate in Hertz
+        public var sampleRate: Double?
+        /// used only with PCM data
+        public var bitDepth: UInt32?
+        /// used only when outputting compressed audio
+        public var bitRate: UInt32 = 128000 {
+            didSet {
+                bitRate = bitRate.clamped(to: 64000 ... 320000)
+            }
+        }
+
+        /// An option to block upsampling to a higher bit depth than the source.
+        /// default value is `.lessThanOrEqual`
+        public var bitDepthRule: BitDepthRule = .lessThanOrEqual
+
+        /// How many channels to convert to. Typically 1 or 2
+        public var channels: UInt32?
+
+        /// Maps to PCM Conversion format option `AVLinearPCMIsNonInterleaved`
+        public var isInterleaved: Bool?
+
+        /// Overwrite existing files, set false if you want to handle this before you call start()
+        public var eraseFile: Bool = true
+
+        public init() {}
+
+        /// Create options by parsing the contents of the url and using the audio settings
+        /// in the file
+        /// - Parameter url: The audio file to open and parse
+        public init?(url: URL) {
+            guard let avFile = try? AVAudioFile(forReading: url) else { return nil }
+            self.init(audioFile: avFile)
+        }
+
+        /// Create options by parsing the audioFile for its settings
+        /// - Parameter audioFile: an AVAudioFile to parse
+        public init?(audioFile: AVAudioFile) {
+            let streamDescription = audioFile.fileFormat.streamDescription.pointee
+
+            format = AudioFileFormat(rawValue: audioFile.url.pathExtension) ?? .unknown
+            // FormatConverter.formatIDToString(streamDescription.mFormatID)
+            sampleRate = streamDescription.mSampleRate
+            bitDepth = streamDescription.mBitsPerChannel
+            channels = streamDescription.mChannelsPerFrame
+        }
+
+        /// Create PCM Options
+        /// - Parameters:
+        ///   - pcmFormat: wav, aif, or caf
+        ///   - sampleRate: Sample Rate
+        ///   - bitDepth: Bit Depth, or bits per channel
+        ///   - channels: How many channels
+        public init?(pcmFormat: AudioFileFormat,
+                     sampleRate: Double? = nil,
+                     bitDepth: UInt32? = nil,
+                     channels: UInt32? = nil)
+        {
+            format = pcmFormat
+            self.sampleRate = sampleRate
+            self.bitDepth = bitDepth
+            self.channels = channels
+        }
+    }
+
+    internal func completionProxy(error: Error?,
+                                  deleteOutputOnError: Bool = true,
+                                  completionHandler: FormatConverterCallback? = nil)
+    {
+        guard error != nil,
+              deleteOutputOnError,
+              let outputURL = outputURL,
+              FileManager.default.fileExists(atPath: outputURL.path)
+        else {
+            completionHandler?(error)
+            return
+        }
+
+        do {
+            print("Deleting on error", outputURL.path)
+            try FileManager.default.removeItem(at: outputURL)
+        } catch let err as NSError {
+            print("Failed to remove file", outputURL, err)
+        }
+
+        completionHandler?(error)
+    }
+}

package/ios/Compressor.mm

@@ -39,7 +39,10 @@ RCT_EXTERN_METHOD(upload:(NSString *)fileUrl
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(download:(NSString *)fileUrl
+RCT_EXTERN_METHOD(cancelUpload:(NSString *)uuid
+                  withShouldCancelAll:(BOOL*)shouldCancelAll)
+
+RCT_EXTERN_METHOD(download:(NSString *)fileUrlu
                  withOptions:(NSDictionary *)options
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)

package/ios/Compressor.xcodeproj/xcuserdata/apple.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>Compressor.xcscheme_^#shared#^_</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>56</integer>
+		</dict>
+	</dict>
+</dict>
+</plist>

package/ios/CompressorManager.swift

@@ -86,6 +86,11 @@ class Compressor: RCTEventEmitter {
         uploader.upload(filePath: filePath, options: options, resolve: resolve, reject: reject)
     }
     
+    @objc(cancelUpload:withShouldCancelAll:)
+    func cancelUpload(uuid: String,shouldCancelAll:Bool) -> Void {
+        uploader.cancelUpload(uuid: uuid,shouldCancelAll: shouldCancelAll)
+    }
+    
     @objc(download:withOptions:withResolver:withRejecter:)
     func download(filePath: String, options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
         Downloader.downloadFileAndSaveToCache(filePath, uuid: options["uuid"] as! String,progressDivider: options["progressDivider"] as? Int ?? 0) { downloadedPath in

package/ios/Utils/Uploader.swift

@@ -29,6 +29,8 @@ struct UploadError: Error {
 class Uploader : NSObject, URLSessionTaskDelegate{
     var uploadResolvers: [String: RCTPromiseResolveBlock] = [:]
     var uploadRejectors: [String: RCTPromiseRejectBlock] = [:]
+    var currentTask: URLSessionDataTask?
+    private lazy var taskManager = UrlTaskManager()
     
     func upload(filePath: String, options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
         let fileUrl = Utils.makeValidUri(filePath: filePath)
@@ -97,10 +99,25 @@ class Uploader : NSObject, URLSessionTaskDelegate{
             let errorMessage = String(format: "Invalid upload type: '%@'.", options["uploadType"] as? String ?? "")
             reject("ERR_FILESYSTEM_INVALID_UPLOAD_TYPE", errorMessage, nil)
         }
-        
+        taskManager.registerTask(task, uuid: uuid)
         task.resume()
      
     }
+    
+    func cancelUpload(uuid:String,shouldCancelAll:Bool) {
+        if(shouldCancelAll==true)
+        {
+            taskManager.cancelAllTasks()
+        } else if(uuid=="")
+        {
+         taskManager.taskPop()?.cancel()
+        }
+        else
+        {
+            taskManager.uploadTaskForId(uuid)?.cancel()
+        }
+        
+    }
 
     func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
       guard let uuid = session.configuration.identifier else {return}