Image Manager

ImageManager.swift

private let ImageFolderDirectoryName = "SomeAppDomainImageDirectory"

final class ImageManager: NSObject {
    
    // MARK: Singleton
    
    class func sharedManager() -> ImageManager {
        struct Singleton {
            static let instance = ImageManager()
        }
        return Singleton.instance
    }
    
    // MARK: System Manager Pointers
    
    private lazy var standardUserDefaults = NSUserDefaults.standardUserDefaults()
    private lazy var defaultFileManager = NSFileManager.defaultManager()
    
    // MARK: Image Directory
    
    private lazy var imageFolderDirectoryPath: NSURL = {
        let pathsArray = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)
        if let pathString = pathsArray.first, documentsDirectoryPath = NSURL(string: pathString) {
            let imageFolderDirectoryPath = documentsDirectoryPath.URLByAppendingPathComponent(ImageFolderDirectoryName)
            self.createImageDirectoryIfNecessaryForFolderPath(imageFolderDirectoryPath)
            return imageFolderDirectoryPath
        } else {
            fatalError("Unable to create documents directory!")
        }
    }()
    
    private func createImageDirectoryIfNecessaryForFolderPath(imageFolderPath: NSURL) {
        if !defaultFileManager.fileExistsAtPath(imageFolderPath.absoluteString) {
            try! defaultFileManager.createDirectoryAtURL(imageFolderPath, withIntermediateDirectories: false, attributes: nil)
        }
    }
    
    private func createImageDirectoryIfNecessary(imageFolderPath: String) {
        if !defaultFileManager.fileExistsAtPath(imageFolderPath) {
            try! defaultFileManager.createDirectoryAtPath(imageFolderPath, withIntermediateDirectories: false, attributes: nil)
        }
    }
    
    // MARK: Image Writing
    
    func writeImageToFile(image: UIImage) -> Bool {
        let uniqueFileName = NSUUID().UUIDString
        let success = self.writeImageToFile(image, withFileName: uniqueFileName)
        return success
    }
    
    func writeImageToFile(image: UIImage, withFileName fileName: String) -> Bool {
        let directoryPath = self.imageFolderDirectoryPath
        let filePath = directoryPath.URLByAppendingPathComponent(fileName)
        if let imageData = UIImageJPEGRepresentation(image, 1.0) {
            return imageData.writeToFile(filePath.absoluteString, atomically: true)
        } else {
            return false
        }
    }
    
    func writeImageToFile(image: UIImage, inBackgroundWithCompletion completion: ((fileName: String, success: Bool) -> Void)?) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), { () -> Void in
            let uniqueFileName = NSUUID().UUIDString
            let success = self.writeImageToFile(image, withFileName: uniqueFileName)
            if let comp = completion {
                dispatch_async(dispatch_get_main_queue(), { () -> Void in
                    comp(fileName: uniqueFileName, success: success)
                })
            }
        })
    }
    
    // MARK: Image Deleting
    
    func deleteImageWithFileName(fileName: String) -> ErrorType? {
        let completePath = imageFolderDirectoryPath.URLByAppendingPathComponent(fileName)
        do {
            try defaultFileManager.removeItemAtPath(completePath.absoluteString)
            return nil
        } catch {
            print("Error deleting file: \(fileName) error: \(error)")
            return error
        }
    }
    
    // MARK: Image Getting
    
    lazy var retrievedImageCache = NSCache()
    
    var allImageFileNames: [String]? {
        return try? defaultFileManager.subpathsOfDirectoryAtPath(imageFolderDirectoryPath.absoluteString)
    }
    
    func imageWithFileName(fileName: String) -> UIImage? {
        if let cachedImg = retrievedImageCache.objectForKey(fileName) as? UIImage {
            return cachedImg
        } else {
            let imageDirectoryPath = imageFolderDirectoryPath
            let completeImagePath = imageDirectoryPath.URLByAppendingPathComponent(fileName)
            if defaultFileManager.fileExistsAtPath(completeImagePath.absoluteString) {
                if let img = UIImage(contentsOfFile: completeImagePath.absoluteString) {
                    retrievedImageCache.setObject(img, forKey: fileName)
                    return img
                } else {
                    return nil
                }
            } else {
                return nil
            }
        }
    }
    
}

Originally written for Swift 1.0, it now compiles in 2.0, but could use an api overhaul.