Amir Abbas Mousavian
272 lines
13 KiB
Swift
272 lines
13 KiB
Swift
//
|
|
// LocalFileProvider.swift
|
|
// ExtDownloader
|
|
//
|
|
// Created by Amir Abbas Mousavian on 3/29/95.
|
|
// Copyright © 1395 Mousavian. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
|
|
final class LocalFileObject: FileObject {
|
|
let allocatedSize: Int64
|
|
|
|
init(absoluteURL: NSURL, name: String, size: Int64, allocatedSize: Int64, createdDate: NSDate?, modifiedDate: NSDate?, fileType: FileType, isHidden: Bool, isReadOnly: Bool) {
|
|
self.allocatedSize = allocatedSize
|
|
super.init(absoluteURL: absoluteURL, name: name, size: size, createdDate: createdDate, modifiedDate: modifiedDate, fileType: fileType, isHidden: isHidden, isReadOnly: isReadOnly)
|
|
}
|
|
}
|
|
|
|
class LocalFileProvider: FileProvider {
|
|
let type = "NSFileManager"
|
|
var isPathRelative: Bool = true
|
|
var baseURL: NSURL? = LocalFileProvider.defaultBaseURL()
|
|
var currentPath: String = ""
|
|
var dispatch_queue: dispatch_queue_t
|
|
var delegate: FileProviderDelegate?
|
|
let credential: NSURLCredential? = nil
|
|
|
|
typealias FileObjectClass = LocalFileObject
|
|
|
|
init () {
|
|
dispatch_queue = dispatch_queue_create("FileProvider.\(type)", DISPATCH_QUEUE_SERIAL)
|
|
}
|
|
|
|
init (baseURL: NSURL) {
|
|
self.baseURL = baseURL
|
|
dispatch_queue = dispatch_queue_create("FileProvider.\(type)", DISPATCH_QUEUE_SERIAL)
|
|
}
|
|
|
|
private static func defaultBaseURL() -> NSURL {
|
|
let paths = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true);
|
|
return NSURL(fileURLWithPath: paths[0])
|
|
}
|
|
|
|
func contentsOfDirectoryAtPath(path: String, completionHandler: ((contents: [LocalFileObject], error: ErrorType?) -> Void)) {
|
|
dispatch_async(dispatch_queue) {
|
|
do {
|
|
let contents = try NSFileManager.defaultManager().contentsOfDirectoryAtURL(self.absoluteURL(path), includingPropertiesForKeys: [NSURLNameKey, NSURLFileSizeKey, NSURLFileAllocatedSizeKey, NSURLCreationDateKey, NSURLContentModificationDateKey, NSURLIsHiddenKey, NSURLVolumeIsReadOnlyKey, NSFileGroupOwnerAccountName], options: NSDirectoryEnumerationOptions.SkipsSubdirectoryDescendants)
|
|
let filesAttributes = contents.map({ (fileURL) -> LocalFileObject in
|
|
return self.attributesOfItemAtURL(fileURL)
|
|
})
|
|
completionHandler(contents: filesAttributes, error: nil)
|
|
} catch let e as NSError {
|
|
completionHandler(contents: [], error: e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func attributesOfItemAtURL(fileURL: NSURL) -> LocalFileObject {
|
|
var namev, sizev, allocated, filetypev, creationDatev, modifiedDatev, hiddenv, readonlyv: AnyObject?
|
|
_ = try? fileURL.getResourceValue(&namev, forKey: NSURLNameKey)
|
|
_ = try? fileURL.getResourceValue(&sizev, forKey: NSURLFileSizeKey)
|
|
_ = try? fileURL.getResourceValue(&allocated, forKey: NSURLFileAllocatedSizeKey)
|
|
_ = try? fileURL.getResourceValue(&creationDatev, forKey: NSURLCreationDateKey)
|
|
_ = try? fileURL.getResourceValue(&modifiedDatev, forKey: NSURLContentModificationDateKey)
|
|
_ = try? fileURL.getResourceValue(&filetypev, forKey: NSURLFileResourceTypeKey)
|
|
_ = try? fileURL.getResourceValue(&hiddenv, forKey: NSURLIsHiddenKey)
|
|
_ = try? fileURL.getResourceValue(&readonlyv, forKey: NSURLVolumeIsReadOnlyKey)
|
|
let fileAttr = LocalFileObject(absoluteURL: fileURL, name: namev as! String, size: sizev?.longLongValue ?? -1, allocatedSize: allocated?.longLongValue ?? -1, createdDate: creationDatev as? NSDate, modifiedDate: modifiedDatev as? NSDate, fileType: FileType(urlResourceTypeValue: filetypev as? String ?? ""), isHidden: hiddenv?.boolValue ?? false, isReadOnly: readonlyv?.boolValue ?? false)
|
|
return fileAttr
|
|
}
|
|
|
|
func attributesOfItemAtPath(path: String, completionHandler: ((attributes: LocalFileObject?, error: ErrorType?) -> Void)) {
|
|
dispatch_async(dispatch_queue) {
|
|
completionHandler(attributes: self.attributesOfItemAtURL(self.absoluteURL(path)), error: nil)
|
|
}
|
|
}
|
|
|
|
func createFolder(folderName: String, atPath: String, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
do {
|
|
try NSFileManager.defaultManager().createDirectoryAtURL(self.absoluteURL(atPath).URLByAppendingPathComponent(folderName), withIntermediateDirectories: true, attributes: [:])
|
|
completionHandler?(error: nil)
|
|
dispatch_async(dispatch_get_main_queue(), {
|
|
self.delegate?.fileproviderCreateModifyNotify(self, path: atPath)
|
|
})
|
|
} catch let e as NSError {
|
|
completionHandler?(error: e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func createFile(fileAttribs: FileObject, atPath: String, contents data: NSData?, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
let fileURL = self.absoluteURL(atPath).URLByAppendingPathComponent(fileAttribs.name)
|
|
var attributes = [String : AnyObject]()
|
|
if let createdDate = fileAttribs.createdDate {
|
|
attributes[NSFileCreationDate] = createdDate
|
|
}
|
|
if let modDate = fileAttribs.modifiedDate {
|
|
attributes[NSFileModificationDate] = modDate
|
|
}
|
|
if fileAttribs.isReadOnly {
|
|
attributes[NSFilePosixPermissions] = NSNumber(short: 365 /*555 o*/)
|
|
}
|
|
let success = NSFileManager.defaultManager().createFileAtPath(fileURL.path!, contents: data, attributes: attributes)
|
|
if success {
|
|
do {
|
|
try fileURL.setResourceValue(fileAttribs.isHidden, forKey: NSURLIsHiddenKey)
|
|
} catch _ {}
|
|
completionHandler?(error: nil)
|
|
dispatch_async(dispatch_get_main_queue(), {
|
|
self.delegate?.fileproviderCreateModifyNotify(self, path: atPath)
|
|
})
|
|
} else {
|
|
completionHandler?(error: self.throwError(atPath, code: NSURLError.CannotCreateFile))
|
|
}
|
|
}
|
|
}
|
|
|
|
func moveItemAtPath(path: String, toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
if !overwrite && NSFileManager.defaultManager().fileExistsAtPath(self.absoluteURL(toPath).path ?? "") {
|
|
completionHandler?(error: self.throwError(toPath, code: NSURLError.CannotMoveFile))
|
|
return
|
|
}
|
|
do {
|
|
try NSFileManager.defaultManager().moveItemAtURL(self.absoluteURL(path), toURL: self.absoluteURL(toPath))
|
|
completionHandler?(error: nil)
|
|
dispatch_async(dispatch_get_main_queue(), {
|
|
self.delegate?.fileproviderMoveNotify(self, fromPath: path, toPath: toPath)
|
|
})
|
|
} catch let e as NSError {
|
|
completionHandler?(error: e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func copyItemAtPath(path: String, toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
if !overwrite && NSFileManager.defaultManager().fileExistsAtPath(self.absoluteURL(toPath).path ?? "") {
|
|
completionHandler?(error: self.throwError(toPath, code: NSURLError.CannotWriteToFile))
|
|
return
|
|
}
|
|
do {
|
|
try NSFileManager.defaultManager().copyItemAtURL(self.absoluteURL(path), toURL: self.absoluteURL(toPath))
|
|
completionHandler?(error: nil)
|
|
dispatch_async(dispatch_get_main_queue(), {
|
|
self.delegate?.fileproviderCopyNotify(self, fromPath: path, toPath: toPath)
|
|
})
|
|
} catch let e as NSError {
|
|
completionHandler?(error: e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func removeItemAtPath(path: String, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
do {
|
|
try NSFileManager.defaultManager().removeItemAtURL(self.absoluteURL(path))
|
|
completionHandler?(error: nil)
|
|
dispatch_async(dispatch_get_main_queue(), {
|
|
self.delegate?.fileproviderRemoveNotify(self, path: path)
|
|
})
|
|
} catch let e as NSError {
|
|
completionHandler?(error: e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func copyLocalFileToPath(localFile: NSURL, toPath: String, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
do {
|
|
try NSFileManager.defaultManager().copyItemAtURL(localFile, toURL: self.absoluteURL(toPath))
|
|
completionHandler?(error: nil)
|
|
dispatch_async(dispatch_get_main_queue(), {
|
|
self.delegate?.fileproviderCreateModifyNotify(self, path: toPath)
|
|
})
|
|
} catch let e as NSError {
|
|
completionHandler?(error: e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func copyPathToLocalFile(path: String, toLocalURL: NSURL, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
do {
|
|
try NSFileManager.defaultManager().copyItemAtURL(self.absoluteURL(path), toURL: toLocalURL)
|
|
completionHandler?(error: nil)
|
|
} catch let e as NSError {
|
|
completionHandler?(error: e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func contentsAtPath(path: String, completionHandler: ((contents: NSData?, error: ErrorType?) -> Void)) {
|
|
dispatch_async(dispatch_queue) {
|
|
let data = NSFileManager.defaultManager().contentsAtPath(self.absoluteURL(path).path!)
|
|
completionHandler(contents: data, error: nil)
|
|
}
|
|
}
|
|
|
|
func contentsAtPath(path: String, offset: Int64, length: Int, completionHandler: ((contents: NSData?, error: ErrorType?) -> Void)) {
|
|
// Unfortunatlely there is no method provided in NSFileManager to read a segment of file.
|
|
// So we have to fallback to POSIX provided methods
|
|
dispatch_async(dispatch_queue) {
|
|
let aPath = self.absoluteURL(path).path!
|
|
if self.attributesOfItemAtURL(self.absoluteURL(path)).fileType == .Directory {
|
|
self.throwError(path, code: NSURLError.FileIsDirectory)
|
|
}
|
|
if !NSFileManager.defaultManager().fileExistsAtPath(aPath) {
|
|
self.throwError(path, code: NSURLError.FileDoesNotExist)
|
|
}
|
|
let fd_from = open(aPath, O_RDONLY)
|
|
if fd_from < 0 {
|
|
completionHandler(contents: nil, error: self.throwError(path, code: NSURLError.CannotOpenFile))
|
|
}
|
|
defer { precondition(close(fd_from) >= 0) }
|
|
lseek(fd_from, offset, SEEK_SET)
|
|
var buf = [UInt8](count: length, repeatedValue: 0)
|
|
let nread = read(fd_from, &buf, buf.count)
|
|
if nread < 0 { self.throwError(path, code: NSURLError.NoPermissionsToReadFile) }
|
|
if nread == 0 {
|
|
completionHandler(contents: nil, error: nil)
|
|
} else {
|
|
let data = NSData(bytesNoCopy: &buf, length: nread, freeWhenDone: true)
|
|
completionHandler(contents: data, error: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeContentsAtPath(path: String, contents data: NSData, atomically: Bool, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
data.writeToURL(self.absoluteURL(path), atomically: atomically)
|
|
dispatch_async(dispatch_get_main_queue(), {
|
|
self.delegate?.fileproviderCreateModifyNotify(self, path: path)
|
|
})
|
|
}
|
|
}
|
|
|
|
func searchFilesAtPath(path: String, recursive: Bool, query: String, foundItemHandler: ((FileObjectClass) -> Void)?, completionHandler: ((files: [FileObjectClass], error: ErrorType?) -> Void)) {
|
|
dispatch_async(dispatch_queue) {
|
|
let iterator = NSFileManager.defaultManager().enumeratorAtURL(self.absoluteURL(path), includingPropertiesForKeys: nil, options: recursive ? NSDirectoryEnumerationOptions() : .SkipsSubdirectoryDescendants) { (url, e) -> Bool in
|
|
completionHandler(files: [], error: e)
|
|
return true
|
|
}
|
|
var result = [LocalFileObject]()
|
|
while let fileURL = iterator?.nextObject() as? NSURL {
|
|
if fileURL.fileName.lowercaseString.containsString(query.lowercaseString) {
|
|
let fileObject = self.attributesOfItemAtURL(fileURL)
|
|
result.append(self.attributesOfItemAtURL(fileURL))
|
|
foundItemHandler?(fileObject)
|
|
}
|
|
}
|
|
completionHandler(files: result, error: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
extension LocalFileProvider {
|
|
func createSymbolicLinkAtPath(path: String, withDestinationPath destPath: String, completionHandler: SimpleCompletionHandler) {
|
|
dispatch_async(dispatch_queue) {
|
|
do {
|
|
try NSFileManager.defaultManager().createSymbolicLinkAtURL(self.absoluteURL(path), withDestinationURL: self.absoluteURL(destPath))
|
|
completionHandler?(error: nil)
|
|
} catch let e as NSError {
|
|
completionHandler?(error: e)
|
|
}
|
|
}
|
|
}
|
|
}
|