Replaced absoluteURL with relative url (resolved #27), improving performance.

- renamed `DropboxFileProvider.copyItem(path:toRemoteURL:) ` to `DropboxFileProvider.copyItem(remoteURL:toPath:)` due to logic

FileProvider.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
   #
 
   s.name         = "FileProvider"
-  s.version      = "0.10.0"
+  s.version      = "0.11.1"
   s.summary      = "FileManager replacement for Local and Remote (WebDAV/Dropbox/OneDrive/SMB2) files on iOS and macOS."
 
   # This description is used to generate tags and improve search results.

FileProvider.xcodeproj/project.pbxproj

@@ -35,6 +35,9 @@
 		792572411DF23BDA006A1526 /* LocalHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 792572401DF23BDA006A1526 /* LocalHelper.swift */; };
 		792572421DF23BDA006A1526 /* LocalHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 792572401DF23BDA006A1526 /* LocalHelper.swift */; };
 		792572431DF23BDA006A1526 /* LocalHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 792572401DF23BDA006A1526 /* LocalHelper.swift */; };
+		79480FF61E3ABDD0007E7275 /* CloudFileProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 79480FF51E3ABDD0007E7275 /* CloudFileProvider.swift */; };
+		79480FF71E3ABDD0007E7275 /* CloudFileProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 79480FF51E3ABDD0007E7275 /* CloudFileProvider.swift */; };
+		79480FF81E3ABDD0007E7275 /* CloudFileProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 79480FF51E3ABDD0007E7275 /* CloudFileProvider.swift */; };
 		794C21FE1D58912A00EC49B8 /* DropboxHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */; };
 		794C21FF1D58912A00EC49B8 /* DropboxHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */; };
 		794C22001D58912A00EC49B8 /* DropboxHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */; };
@@ -127,6 +130,7 @@
 		7924B1921D89DAE000589DB7 /* Parser.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Parser.swift; sourceTree = "<group>"; };
 		7924B1A81D89F79200589DB7 /* FPSStreamTask.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = FPSStreamTask.swift; sourceTree = "<group>"; };
 		792572401DF23BDA006A1526 /* LocalHelper.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = LocalHelper.swift; sourceTree = "<group>"; };
+		79480FF51E3ABDD0007E7275 /* CloudFileProvider.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CloudFileProvider.swift; sourceTree = "<group>"; };
 		794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DropboxHelper.swift; sourceTree = "<group>"; };
 		794C22091D5893F800EC49B8 /* SMB2Notification.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SMB2Notification.swift; sourceTree = "<group>"; };
 		794C220D1D591A4B00EC49B8 /* SMB2QueryTypes.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SMB2QueryTypes.swift; sourceTree = "<group>"; };
@@ -286,6 +290,7 @@
 				79F5745A1DFDB10A00179ABF /* FileObject.swift */,
 				799396961D48C02300086753 /* LocalFileProvider.swift */,
 				792572401DF23BDA006A1526 /* LocalHelper.swift */,
+				79480FF51E3ABDD0007E7275 /* CloudFileProvider.swift */,
 				79BD638B1E2CC2300035128C /* ExtendedLocalFileProvider.swift */,
 				7902C0851D61B56D00564440 /* RemoteSession.swift */,
 				799396931D48C02300086753 /* DropboxFileProvider.swift */,
@@ -480,6 +485,7 @@
 				799396D41D48C02300086753 /* SMB2Tree.swift in Sources */,
 				7924B1A21D89DAE000589DB7 /* Options.swift in Sources */,
 				792572411DF23BDA006A1526 /* LocalHelper.swift in Sources */,
+				79480FF61E3ABDD0007E7275 /* CloudFileProvider.swift in Sources */,
 				79F5745B1DFDB10B00179ABF /* FileObject.swift in Sources */,
 				79BD63C51E2D17880035128C /* OneDriveFileProvide.swift in Sources */,
 				7924B1991D89DAE000589DB7 /* Element.swift in Sources */,
@@ -519,6 +525,7 @@
 				799396D51D48C02300086753 /* SMB2Tree.swift in Sources */,
 				7924B1A31D89DAE000589DB7 /* Options.swift in Sources */,
 				792572421DF23BDA006A1526 /* LocalHelper.swift in Sources */,
+				79480FF71E3ABDD0007E7275 /* CloudFileProvider.swift in Sources */,
 				79F5745C1DFDB10B00179ABF /* FileObject.swift in Sources */,
 				79BD63C61E2D17880035128C /* OneDriveFileProvide.swift in Sources */,
 				7924B1B01D89F7DE00589DB7 /* FPSStreamTask.swift in Sources */,
@@ -558,6 +565,7 @@
 				799396D61D48C02300086753 /* SMB2Tree.swift in Sources */,
 				7924B1A41D89DAE000589DB7 /* Options.swift in Sources */,
 				792572431DF23BDA006A1526 /* LocalHelper.swift in Sources */,
+				79480FF81E3ABDD0007E7275 /* CloudFileProvider.swift in Sources */,
 				79F5745D1DFDB10B00179ABF /* FileObject.swift in Sources */,
 				79BD63C71E2D17880035128C /* OneDriveFileProvide.swift in Sources */,
 				7924B1B11D89F7DF00589DB7 /* FPSStreamTask.swift in Sources */,
@@ -595,7 +603,7 @@
 		799396601D48B7BF00086753 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				BUNDLE_VERSION_STRING = 0.10.0;
+				BUNDLE_VERSION_STRING = 0.11.1;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
@@ -625,7 +633,7 @@
 		799396611D48B7BF00086753 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				BUNDLE_VERSION_STRING = 0.10.0;
+				BUNDLE_VERSION_STRING = 0.11.1;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_EMPTY_BODY = YES;

README.md

@@ -26,11 +26,17 @@ Local and WebDAV providers are fully tested and can be used in production enviro
 
 - [x] **LocalFileProvider** a wrapper around `FileManager` with some additions like searching and reading a portion of file.
 - [x] **WebDAVFileProvider** WebDAV protocol is defacto file transmission standard, replaced FTP.
-- [x] **DropboxFileProvider** A wrapper around Dropbox Web API. For now it has limitation in uploading files up to 150MB.
-- [x] **OneDriveFileProvider** A wrapper around OneDrive Web API, works with `onedrive.com` and compatible servers. For now it has limitation in uploading files up to 100MB.
-- [ ] **SMBFileProvider** SMB2/3 introduced in 2006, which is a file and printer sharing protocol originated from Microsoft Windows and now is replacing AFP protocol on MacOS. I implemented data types and some basic functions but *main interface is not implemented yet!* SMB1/CIFS is depericated and very tricky to be implemented
+- [x] **DropboxFileProvider** A wrapper around Dropbox Web API.
+* For now it has limitation in uploading files up to 150MB.
+- [x] **OneDriveFileProvider** A wrapper around OneDrive Web API, works with `onedrive.com` and compatible (business) servers.
+* For now it has limitation in uploading files up to 100MB.
+- [x] **CloudFileProvider** A wrapper around app's ubiquitous container to iCloud Drive in iOS 8+ API.
+- [ ] **SMBFileProvider** SMB2/3 introduced in 2006, which is a file and printer sharing protocol originated from Microsoft Windows and now is replacing AFP protocol on MacOS.
+* Data types and some basic functions are implemented but *main interface is not implemented yet!*
+*  SMB1/CIFS is depericated and very tricky to be implemented
 - [ ] **FTPFileProvider** while deprecated in 1990s, it's still in use on some Web hosts.
 - [ ] **AmazonS3FileProvider** 
+- [ ] **GoogleDriveFileProvider**
 
 ## Requirements
 
@@ -97,18 +103,31 @@ For LocalFileProvider if you want to deal with `Documents` folder
 
 ```	swift
 let documentsProvider = LocalFileProvider()
-```
 
-is equal to:
+// Equals with:
+let documentsProvider = LocalFileProvider(directory: .documentDirectory, domainMask: = .userDomainMask)
 
-```	swift
-let documentPath = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true);
-let documentsURL = URL(fileURLWithPath: documentPath);
+// Equals with:
+let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
 let documentsProvider = LocalFileProvider(baseURL: documentsURL)
 ```
 
+Also for using group shared container:
+
+```swift
+let documentsProvider = LocalFileProvider(sharedContainerId: "group.yourcompany.appContainer")
+// Replace your group identifier with string above
+```
+
 You can't change the base url later. and all paths are related to this base url by default.
 
+To initialize an iCloud Container provider use below code, This will automatically manager creating Documents folder in container:
+
+```swift
+let documentsProvider = CloudFileProvider(containerId: nil)
+```
+
+
 For remote file providers authentication may be necessary:
 
 ```	swift

Sources/CloudFileProvider.swift

@@ -0,0 +1,480 @@
+//
+//  CloudFileProvider.swift
+//  FileProvider
+//
+//  Created by Amir Abbas Mousavian.
+//  Copyright © 2017 Mousavian. Distributed under MIT license.
+//
+
+import Foundation
+
+open class CloudFileProvider: LocalFileProvider {
+    
+    public var type: String {
+        return "iCloudDrive"
+    }
+    
+    /// Actually is readonly, value is true
+    override open var isCoorinating: Bool {
+        get {
+            return true
+        }
+        set {
+            return
+        }
+    }
+    
+    open var containerId: String?
+    
+    public init? (containerId: String?) {
+        assert(!Thread.isMainThread, "LocalFileProvider.init(containerId:) is not recommended to be executed on Main Thread.")
+        guard FileManager.default.ubiquityIdentityToken == nil else {
+            return nil
+        }
+        guard let ubiquityURL = FileManager.default.url(forUbiquityContainerIdentifier: containerId) else {
+            return nil
+        }
+        self.containerId = containerId
+        let baseURL = ubiquityURL.standardized.appendingPathComponent("Documents/")
+        super.init(baseURL: baseURL)
+        self.isCoorinating = true
+        
+        dispatch_queue = DispatchQueue(label: "FileProvider.\(self.type)", attributes: DispatchQueue.Attributes.concurrent)
+        operation_queue = OperationQueue()
+        operation_queue.name = "FileProvider.\(self.type).Operation"
+        
+        fileManager.url(forUbiquityContainerIdentifier: containerId)
+        opFileManager.url(forUbiquityContainerIdentifier: containerId)
+        
+        try? fileManager.createDirectory(at: baseURL, withIntermediateDirectories: true)
+    }
+    
+    open override func contentsOfDirectory(path: String, completionHandler: @escaping ((_ contents: [FileObject], _ error: Error?) -> Void)) {
+        dispatch_queue.async {
+            let pathURL = self.url(of: path)
+            let query = NSMetadataQuery()
+            query.predicate = NSPredicate(format: "%K BEGINSWITH %@", NSMetadataItemPathKey, pathURL.path)
+            query.searchScopes = [NSMetadataQueryUbiquitousDocumentsScope]
+            var finishObserver: NSObjectProtocol?
+            finishObserver = NotificationCenter.default.addObserver(forName: NSNotification.Name.NSMetadataQueryDidFinishGathering, object: query, queue: nil, using: { (notification) in
+                defer {
+                    query.stop()
+                    NotificationCenter.default.removeObserver(finishObserver!)
+                }
+                
+                guard let results = query.results as? [NSMetadataItem] else {
+                    return
+                }
+                
+                query.disableUpdates()
+                
+                var contents = [FileObject]()
+                for result in results {
+                    guard let attribs = result.values(forAttributes: [NSMetadataItemURLKey, NSMetadataItemFSNameKey, NSMetadataItemPathKey, NSMetadataItemFSSizeKey, NSMetadataItemContentTypeTreeKey, NSMetadataItemFSCreationDateKey, NSMetadataItemFSContentChangeDateKey]) else {
+                        continue
+                    }
+                    
+                    guard let url = (attribs[NSMetadataItemURLKey] as? URL)?.standardized, url.deletingLastPathComponent().path.trimmingCharacters(in: pathTrimSet) == pathURL.path.trimmingCharacters(in: pathTrimSet) else {
+                        continue
+                    }
+                    
+                    if let file = self.mapFileObject(attributes: attribs) {
+                        contents.append(file)
+                    }
+                }
+                
+                completionHandler(contents, nil)
+            })
+            query.start()
+        }
+    }
+    
+    /// iCloud Storage size and free space is unavailable, it returns local space
+    open override func storageProperties(completionHandler: (@escaping (_ total: Int64, _ used: Int64) -> Void)) {
+        super.storageProperties(completionHandler: completionHandler)
+    }
+    
+    open override func attributesOfItem(path: String, completionHandler: @escaping ((_ attributes: FileObject?, _ error: Error?) -> Void)) {
+        dispatch_queue.async {
+            let pathURL = self.url(of: path)
+            let query = NSMetadataQuery()
+            query.predicate = NSPredicate(format: "%K LIKE %@", NSMetadataItemPathKey, pathURL.path)
+            query.searchScopes = [NSMetadataQueryUbiquitousDocumentsScope]
+            var finishObserver: NSObjectProtocol?
+            finishObserver = NotificationCenter.default.addObserver(forName: NSNotification.Name.NSMetadataQueryDidFinishGathering, object: query, queue: nil, using: { (notification) in
+                defer {
+                    query.stop()
+                    NotificationCenter.default.removeObserver(finishObserver!)
+                }
+                
+                query.disableUpdates()
+                
+                guard let result = (query.results as? [NSMetadataItem])?.first, let attribs = result.values(forAttributes: [NSMetadataItemURLKey, NSMetadataItemFSNameKey, NSMetadataItemPathKey, NSMetadataItemFSSizeKey, NSMetadataItemContentTypeTreeKey, NSMetadataItemFSCreationDateKey, NSMetadataItemFSContentChangeDateKey]) else {
+                    let error = self.throwError(path, code: CocoaError.fileNoSuchFile)
+                    completionHandler(nil, error)
+                    return
+                }
+                
+                if let file = self.mapFileObject(attributes: attribs) {
+                    completionHandler(file, nil)
+                } else {
+                    let noFileError = self.throwError(path, code: CocoaError.fileNoSuchFile)
+                    completionHandler(nil, noFileError)
+                }
+            })
+            query.start()
+        }
+    }
+    
+    @discardableResult
+    open override func create(folder folderName: String, at atPath: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let r = super.create(folder: folderName, at: atPath, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func create(file fileName: String, at atPath: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let r = super.create(file: fileName, at: atPath, contents: data, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func moveItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let r = super.moveItem(path: path, to: toPath, overwrite: overwrite, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func copyItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let r = super.copyItem(path: path, to: toPath, overwrite: overwrite, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func removeItem(path: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let r = super.removeItem(path: path, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func copyItem(localFile: URL, to toPath: String, overwrite: Bool, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        // TODO: Make use of overwrite parameter
+        let opType = FileOperationType.copy(source: localFile.absoluteString, destination: toPath)
+        operation_queue.addOperation {
+            let tempFolder: URL
+            if #available(iOS 10.0, macOS 10.12, tvOS 10.0, *) {
+                tempFolder = FileManager.default.temporaryDirectory
+            } else {
+                tempFolder = URL(fileURLWithPath: NSTemporaryDirectory())
+            }
+            let tmpFile = tempFolder.appendingPathComponent(UUID().uuidString)
+            
+            do {
+                try self.opFileManager.copyItem(at: localFile, to: tmpFile)
+                let toUrl = self.url(of: toPath)
+                try self.opFileManager.setUbiquitous(true, itemAt: tmpFile, destinationURL: toUrl)
+                completionHandler?(nil)
+                DispatchQueue.main.async(execute: {
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
+                })
+            } catch let e {
+                if self.opFileManager.fileExists(atPath: tmpFile.path) {
+                    try? self.opFileManager.removeItem(at: tmpFile)
+                }
+                completionHandler?(e)
+                DispatchQueue.main.async(execute: {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                })
+            }
+        }
+        return CloudOperationHandle(operationType: opType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func copyItem(path: String, toLocalURL: URL, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.copy(source: path, destination: toLocalURL.absoluteString)
+        
+        do {
+            try self.opFileManager.startDownloadingUbiquitousItem(at: self.url(of: path))
+        } catch let e {
+            completionHandler?(e)
+            DispatchQueue.main.async(execute: {
+                self.delegate?.fileproviderFailed(self, operation: opType)
+            })
+            return nil
+        }
+        
+        let r = super.copyItem(path: path, toLocalURL: toLocalURL, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func contents(path: String, completionHandler: @escaping ((_ contents: Data?, _ error: Error?) -> Void)) -> OperationHandle? {
+        let r = super.contents(path: path, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func contents(path: String, offset: Int64, length: Int, completionHandler: @escaping ((_ contents: Data?, _ error: Error?) -> Void)) -> OperationHandle? {
+        let r = super.contents(path: path, offset: offset, length: length, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    @discardableResult
+    open override func writeContents(path: String, contents data: Data, atomically: Bool, overwrite: Bool, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let r = super.writeContents(path: path, contents: data, atomically: atomically, overwrite: overwrite, completionHandler: completionHandler)
+        return CloudOperationHandle(operationType: r!.operationType, baseURL: self.baseURL)
+    }
+    
+    open override func searchFiles(path: String, recursive: Bool, query: String, foundItemHandler: ((FileObject) -> Void)?, completionHandler: @escaping ((_ files: [FileObject], _ error: Error?) -> Void)) {
+        dispatch_queue.async {
+            let pathURL = self.url(of: path)
+            let query = NSMetadataQuery()
+            query.predicate = NSPredicate(format: "(%K BEGINSWITH %@) && (%K LIKE %@)", NSMetadataItemPathKey, pathURL.path, NSMetadataItemFSNameKey, query)
+            query.searchScopes = [NSMetadataQueryUbiquitousDocumentsScope]
+            
+            var lastReportedCount = 0
+            
+            if let foundItemHandler = foundItemHandler {
+                var updateObserver: NSObjectProtocol?
+                
+                updateObserver = NotificationCenter.default.addObserver(forName: .NSMetadataQueryGatheringProgress, object: query, queue: nil, using: { (notification) in
+                    
+                    query.disableUpdates()
+                    
+                    guard query.resultCount > lastReportedCount else { return }
+                    
+                    for index in lastReportedCount..<query.resultCount {
+                        guard let attribs = (query.result(at: index) as? NSMetadataItem)?.values(forAttributes: [NSMetadataItemURLKey, NSMetadataItemFSNameKey, NSMetadataItemPathKey, NSMetadataItemFSSizeKey, NSMetadataItemContentTypeTreeKey, NSMetadataItemFSCreationDateKey, NSMetadataItemFSContentChangeDateKey]) else {
+                            continue
+                        }
+                        
+                        guard let url = (attribs[NSMetadataItemURLKey] as? URL)?.standardized, recursive || url.deletingLastPathComponent().path.trimmingCharacters(in: pathTrimSet) == pathURL.path.trimmingCharacters(in: pathTrimSet) else {
+                            continue
+                        }
+                        
+                        if let file = self.mapFileObject(attributes: attribs) {
+                            foundItemHandler(file)
+                        }
+                    }
+                    lastReportedCount = query.resultCount
+                    
+                    query.enableUpdates()
+                })
+            }
+            
+            var finishObserver: NSObjectProtocol?
+            finishObserver = NotificationCenter.default.addObserver(forName: .NSMetadataQueryDidFinishGathering, object: query, queue: nil, using: { (notification) in
+                defer {
+                    query.stop()
+                    NotificationCenter.default.removeObserver(finishObserver!)
+                }
+                
+                guard let results = query.results as? [NSMetadataItem] else {
+                    return
+                }
+                
+                query.disableUpdates()
+                
+                var contents = [FileObject]()
+                for result in results {
+                    guard let attribs = result.values(forAttributes: [NSMetadataItemURLKey, NSMetadataItemFSNameKey, NSMetadataItemPathKey, NSMetadataItemFSSizeKey, NSMetadataItemContentTypeTreeKey, NSMetadataItemFSCreationDateKey, NSMetadataItemFSContentChangeDateKey]) else {
+                        continue
+                    }
+                    
+                    guard let url = (attribs[NSMetadataItemURLKey] as? URL)?.standardized, recursive || url.deletingLastPathComponent().path.trimmingCharacters(in: pathTrimSet) == pathURL.path.trimmingCharacters(in: pathTrimSet) else {
+                        continue
+                    }
+                    
+                    if let file = self.mapFileObject(attributes: attribs) {
+                        contents.append(file)
+                    }
+                }
+                
+                completionHandler(contents, nil)
+            })
+            
+            query.start()
+        }
+    }
+    
+    fileprivate var monitors = [URL: (NSMetadataQuery, NSObjectProtocol)]()
+    //
+    open override func registerNotifcation(path: String, eventHandler: @escaping (() -> Void)) {
+        self.unregisterNotifcation(path: path)
+        let pathURL = self.url(of: path)
+        let query = NSMetadataQuery()
+        query.predicate = NSPredicate(format: "(%K BEGINSWITH %@)", NSMetadataItemPathKey, pathURL.path)
+        query.searchScopes = [NSMetadataQueryUbiquitousDocumentsScope]
+        
+        let updateObserver = NotificationCenter.default.addObserver(forName: .NSMetadataQueryDidUpdate, object: query, queue: nil, using: { (notification) in
+            
+            query.disableUpdates()
+            
+            eventHandler()
+            
+            query.enableUpdates()
+        })
+        
+        query.start()
+        
+        monitors[pathURL] = (query, updateObserver)
+    }
+    
+    open override func unregisterNotifcation(path: String) {
+        let key = url(of: path)
+        guard let (query, observer) = monitors[key] else {
+            return
+        }
+        query.disableUpdates()
+        query.stop()
+        monitors.removeValue(forKey: key)
+        NotificationCenter.default.removeObserver(observer)
+    }
+    
+    open override func isRegisteredForNotification(path: String) -> Bool {
+        return monitors[url(of: path)] != nil
+    }
+    
+    /// may return nil
+    open override func copy(with zone: NSZone? = nil) -> Any {
+        let copy = CloudFileProvider(containerId: self.containerId)
+        copy?.currentPath = self.currentPath
+        copy?.delegate = self.delegate
+        copy?.fileOperationDelegate = self.fileOperationDelegate
+        copy?.isPathRelative = self.isPathRelative
+        return copy as Any
+    }
+    
+    fileprivate func mapFileObject(attributes attribs: [String: Any]) -> FileObject? {
+        guard let url = (attribs[NSMetadataItemURLKey] as? URL)?.standardized, let name = attribs[NSMetadataItemFSNameKey] as? String else {
+            return nil
+        }
+        
+        let path = self.relativePathOf(url: url)
+        let rpath = path.hasPrefix("/") ? path.substring(from: path.index(after: path.startIndex)) : path
+        let relativeUrl = URL(string: rpath, relativeTo: self.baseURL)
+        let file = FileObject(url: relativeUrl ?? url, name: name, path: path)
+        
+        file.size = (attribs[NSMetadataItemFSSizeKey] as? NSNumber)?.int64Value ?? -1
+        file.creationDate = attribs[NSMetadataItemFSCreationDateKey] as? Date
+        file.modifiedDate = attribs[NSMetadataItemFSContentChangeDateKey] as? Date
+        let isFolder = (attribs[NSMetadataItemContentTypeTreeKey] as? [String])?.contains("public.folder") ?? false
+        let isSymbolic = (attribs[NSMetadataItemContentTypeTreeKey] as? [String])?.contains("public.symlink") ?? false
+        file.type = isFolder ? .directory : (isSymbolic ? .symbolicLink : .regular)
+        
+        return file
+    }
+    
+    /// Removes local copy of file, but spares cloud copy
+    open func evictItem(path: String, completionHandler: SimpleCompletionHandler) {
+        operation_queue.addOperation {
+            do {
+                try self.opFileManager.evictUbiquitousItem(at: self.url(of: path))
+                completionHandler?(nil)
+            } catch let e {
+                completionHandler?(e)
+            }
+        }
+    }
+    
+    open func temporaryLink(to path: String, completionHandler: @escaping ((_ link: URL?, _ attribute: FileObject?, _ expiration: Date?, _ error: Error?) -> Void)) {
+        operation_queue.addOperation {
+            do {
+                var expiration: NSDate?
+                let url = try self.opFileManager.url(forPublishingUbiquitousItemAt: self.url(of: path), expiration: &expiration)
+                completionHandler(url, nil, expiration as Date?, nil)
+            } catch let e {
+                completionHandler(nil, nil, nil, e)
+            }
+        }
+    }
+}
+
+open class CloudOperationHandle: OperationHandle {
+    public let baseURL: URL?
+    public let operationType: FileOperationType
+    
+    init (operationType: FileOperationType, baseURL: URL?) {
+        self.baseURL = baseURL
+        self.operationType = operationType
+    }
+    
+    private var sourceURL: URL? {
+        guard let source = operationType.source, let baseURL = baseURL else { return nil }
+        return source.hasPrefix("file://") ? URL(fileURLWithPath: source) : baseURL.appendingPathComponent(source)
+    }
+    
+    private var destURL: URL? {
+        guard let dest = operationType.destination, let baseURL = baseURL else { return nil }
+        return dest.hasPrefix("file://") ? URL(fileURLWithPath: dest) : baseURL.appendingPathComponent(dest)
+    }
+    
+    /// Caution: may put pressure on CPU, may have latency
+    open var bytesSoFar: Int64 {
+        assert(!Thread.isMainThread, "Don't run \(#function) method on main thread")
+        
+        guard let url = destURL ?? sourceURL, let item = CloudOperationHandle.getMetadataItem(url: url) else { return 0 }
+        let downloaded = item.value(forAttribute: NSMetadataUbiquitousItemPercentDownloadedKey) as? Double ?? 0
+        let uploaded = item.value(forAttribute: NSMetadataUbiquitousItemPercentUploadedKey) as? Double ?? 0
+        guard let size = item.value(forAttribute: NSMetadataItemFSSizeKey) as? Int64 else { return -1 }
+        if (downloaded == 0 || downloaded == 100) && (uploaded > 0 && uploaded < 100) {
+            return Int64(uploaded * (Double(size) / 100))
+        } else if (uploaded == 0 || uploaded == 100) && (downloaded > 0 && downloaded < 100) {
+            return Int64(downloaded * (Double(size) / 100))
+        } else if uploaded == 100 || downloaded == 100 {
+            return size
+        }
+        return 0
+    }
+    
+    /// Caution: may put pressure on CPU, may have latency
+    open var totalBytes: Int64 {
+        assert(!Thread.isMainThread, "Don't run \(#function) method on main thread")
+        guard let url = destURL ?? sourceURL, let item = CloudOperationHandle.getMetadataItem(url: url) else { return -1 }
+        return item.value(forAttribute: NSMetadataItemFSSizeKey) as? Int64 ?? -1
+    }
+    
+    open var inProgress: Bool {
+        guard let url = destURL ?? sourceURL, let item = CloudOperationHandle.getMetadataItem(url: url) else { return false }
+        let downloadStatus = item.value(forAttribute: NSMetadataUbiquitousItemDownloadingStatusKey) as? String ?? NSMetadataUbiquitousItemDownloadingStatusNotDownloaded
+        let isUploading = item.value(forAttribute: NSMetadataUbiquitousItemIsUploadingKey) as? Bool ?? false
+        return downloadStatus == NSMetadataUbiquitousItemDownloadingStatusCurrent || isUploading
+    }
+    
+    /// Not usable in local provider
+    open func cancel() -> Bool {
+        
+        return false
+    }
+    
+    fileprivate static func getMetadataItem(url: URL) -> NSMetadataItem? {
+        let query = NSMetadataQuery()
+        query.predicate = NSPredicate(format: "(%K LIKE %@)", NSMetadataItemPathKey, url.path)
+        query.searchScopes = [NSMetadataQueryUbiquitousDocumentsScope]
+        
+        var item: NSMetadataItem?
+        
+        let group = DispatchGroup()
+        var finishObserver: NSObjectProtocol?
+        finishObserver = NotificationCenter.default.addObserver(forName: .NSMetadataQueryDidFinishGathering, object: query, queue: nil, using: { (notification) in
+            defer {
+                query.stop()
+                group.leave()
+                NotificationCenter.default.removeObserver(finishObserver!)
+            }
+            
+            if query.resultCount > 0 {
+                item = query.result(at: 0) as? NSMetadataItem
+            }
+            
+            query.disableUpdates()
+            
+        })
+        
+        group.enter()
+        query.start()
+        _ = group.wait(timeout: DispatchTime.now() + 30)
+        return item
+    }
+}

Sources/DropboxFileProvider.swift

@@ -13,47 +13,57 @@ import CoreGraphics
 // Because this class uses NSURLSession, it's necessary to disable App Transport Security
 // in case of using this class with unencrypted HTTP connection.
 
-open class DropboxFileProvider: NSObject,  FileProviderBasicRemote {
+open class DropboxFileProvider: FileProviderBasicRemote {
     open static let type: String = "DropBox"
-    open let isPathRelative: Bool = true
+    open let isPathRelative: Bool
     open let baseURL: URL?
-    open var currentPath: String = ""
+    open var currentPath: String
     
-    open let apiURL = URL(string: "https://api.dropboxapi.com/2/")!
-    open let contentURL = URL(string: "https://content.dropboxapi.com/2")!
+    open let apiURL: URL
+    open let contentURL: URL
     
-    open var dispatch_queue: DispatchQueue {
+    open var dispatch_queue: DispatchQueue
+    open var operation_queue: OperationQueue {
         willSet {
             assert(_session == nil, "It's not effective to change dispatch_queue property after session is initialized.")
         }
     }
+    
     open weak var delegate: FileProviderDelegate?
     open let credential: URLCredential?
     open private(set) var cache: URLCache?
-    public var useCache: Bool = false
-    public var validatingCache: Bool = true
+    public var useCache: Bool
+    public var validatingCache: Bool
    
     fileprivate var _session: URLSession?
     fileprivate var sessionDelegate: SessionDelegate?
     public var session: URLSession {
         if _session == nil {
             self.sessionDelegate = SessionDelegate(fileProvider: self, credential: credential)
-            let queue = OperationQueue()
-            //queue.underlyingQueue = dispatch_queue
             let config = URLSessionConfiguration.default
             config.urlCache = cache
             config.requestCachePolicy = .returnCacheDataElseLoad
-            _session = URLSession(configuration: config, delegate: sessionDelegate as URLSessionDelegate?, delegateQueue: queue)
+            _session = URLSession(configuration: config, delegate: sessionDelegate as URLSessionDelegate?, delegateQueue: self.operation_queue)
         }
         return _session!
     }
     
     public init? (credential: URLCredential?, cache: URLCache? = nil) {
         self.baseURL = nil
-        dispatch_queue = DispatchQueue(label: "FileProvider.\(DropboxFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
-        //let url = baseURL.uw_absoluteString
-        self.credential = credential
+        self.isPathRelative = true
+        self.currentPath = ""
+        self.useCache = false
+        self.validatingCache = true
         self.cache = cache
+        self.credential = credential
+        
+        self.apiURL = URL(string: "https://api.dropboxapi.com/2/")!
+        self.contentURL = URL(string: "https://content.dropboxapi.com/2/")!
+        
+        dispatch_queue = DispatchQueue(label: "FileProvider.\(type(of: self).type)", attributes: DispatchQueue.Attributes.concurrent)
+        operation_queue = OperationQueue()
+        operation_queue.name = "FileProvider.\(type(of: self).type).Operation"
+
     }
     
     deinit {
@@ -227,7 +237,7 @@ extension DropboxFileProvider: FileProviderReadWrite {
         request.httpMethod = "GET"
         request.setValue("Bearer \(credential?.password ?? "")", forHTTPHeaderField: "Authorization")
         if length > 0 {
-            request.setValue("bytes=\(offset)-\(offset + length)", forHTTPHeaderField: "Range")
+            request.setValue("bytes=\(offset)-\(offset + length - 1)", forHTTPHeaderField: "Range")
         } else if offset > 0 && length < 0 {
             request.setValue("bytes=\(offset)-", forHTTPHeaderField: "Range")
         }
@@ -282,7 +292,14 @@ extension DropboxFileProvider: FileProviderReadWrite {
 }
 
 extension DropboxFileProvider {
+    @available(*, deprecated, message: "Use DropboxFileProvider.temporaryLink(to:, completionHandler: (URL?, DropboxFileObject?, Date?,  Error?)) function instead.")
     open func temporaryLink(to path: String, completionHandler: @escaping ((_ link: URL?, _ attribute: DropboxFileObject?, _ error: Error?) -> Void)) {
+        self.temporaryLink(to: path) { (url, file, _, error) in
+            completionHandler(url, file, error)
+        }
+    }
+    
+    open func temporaryLink(to path: String, completionHandler: @escaping ((_ link: URL?, _ attribute: DropboxFileObject?, _ expiration: Date?, _ error: Error?) -> Void)) {
         let url = URL(string: "files/get_temporary_link", relativeTo: apiURL)!
         var request = URLRequest(url: url)
         request.httpMethod = "POST"
@@ -306,18 +323,20 @@ extension DropboxFileProvider {
                     }
                 }
             }
-            completionHandler(link, fileObject, dbError ?? error)
+            
+            let expiration: Date? = link != nil ? Date(timeIntervalSinceNow: 4 * 60 * 60) : nil
+            completionHandler(link, fileObject, expiration, dbError ?? error)
         })
         task.resume()
     }
     
-    open func copyItem(path: String, toRemoteURL destURL: URL, completionHandler: @escaping ((_ jobId: String?, _ attribute: DropboxFileObject?, _ error: Error?) -> Void)) {
+    open func copyItem(remoteURL: URL, to toPath: String, completionHandler: @escaping ((_ jobId: String?, _ attribute: DropboxFileObject?, _ error: Error?) -> Void)) {
         let url = URL(string: "files/save_url", relativeTo: apiURL)!
         var request = URLRequest(url: url)
         request.httpMethod = "POST"
         request.setValue("Bearer \(credential?.password ?? "")", forHTTPHeaderField: "Authorization")
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        let requestDictionary = ["path": correctPath(path)! as NSString, "url" : destURL.absoluteString as NSString]
+        let requestDictionary = ["path": correctPath(toPath)! as NSString, "url" : remoteURL.absoluteString as NSString]
         request.httpBody = dictionaryToJSON(requestDictionary)?.data(using: .utf8)
         let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
             var dbError: FileProviderDropboxError?
@@ -325,7 +344,7 @@ extension DropboxFileProvider {
             var fileObject: DropboxFileObject?
             if let response = response as? HTTPURLResponse {
                 let code = FileProviderHTTPErrorCode(rawValue: response.statusCode)
-                dbError = code != nil ? FileProviderDropboxError(code: code!, path: path, errorDescription: String(data: data ?? Data(), encoding: .utf8)) : nil
+                dbError = code != nil ? FileProviderDropboxError(code: code!, path: toPath, errorDescription: String(data: data ?? Data(), encoding: .utf8)) : nil
                 if let data = data, let jsonStr = String(data: data, encoding: .utf8), let json = jsonToDictionary(jsonStr) {
                     jobId = json["async_job_id"] as? String
                     if let attribDic = json["metadata"] as? [String: AnyObject] {

Sources/DropboxHelper.swift

@@ -20,7 +20,7 @@ public struct FileProviderDropboxError: Error, CustomStringConvertible {
 
 public final class DropboxFileObject: FileObject {
     internal init(name: String, path: String) {
-        super.init(absoluteURL: URL(string: path), name: name, path: path)
+        super.init(url: URL(string: path) ?? URL(string: "/")!, name: name, path: path)
     }
     
     open internal(set) var serverTime: Date? {
@@ -98,7 +98,12 @@ internal extension DropboxFileProvider {
     }
     
     func upload_simple(_ targetPath: String, data: Data, modifiedDate: Date = Date(), overwrite: Bool, operation: FileOperationType, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        assert(data.count < 150*1024*1024, "Maximum size of allowed size to upload is 150MB")
+        if data.count > 150 * 1024 * 1024 {
+            let error = FileProviderDropboxError(code: .payloadTooLarge, path: targetPath, errorDescription: nil)
+            completionHandler?(error)
+            self.delegateNotify(.create(path: targetPath), error: error)
+            return nil
+        }
         var requestDictionary = [String: Any]()
         let url: URL
         url = URL(string: "files/upload", relativeTo: contentURL)!
@@ -125,6 +130,13 @@ internal extension DropboxFileProvider {
     }
     
     func upload_simple(_ targetPath: String, localFile: URL, modifiedDate: Date = Date(), overwrite: Bool, operation: FileOperationType, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let size = (try? localFile.resourceValues(forKeys: [.fileSizeKey]))?.fileSize ?? -1
+        if size > 150 * 1024 * 1024 {
+            let error = FileProviderDropboxError(code: .payloadTooLarge, path: targetPath, errorDescription: nil)
+            completionHandler?(error)
+            self.delegateNotify(.create(path: targetPath), error: error)
+            return nil
+        }
         var requestDictionary = [String: Any]()
         let url: URL
         url = URL(string: "files/upload", relativeTo: contentURL)!

Sources/ExtendedLocalFileProvider.swift

@@ -64,7 +64,7 @@ extension LocalFileProvider: ExtendedFileProvider {
         (dispatch_queue).async {
             var thumbnailImage: ImageClass? = nil
             // Check cache
-            let fileURL = self.absoluteURL(path)
+            let fileURL = self.url(of: path)
             // Create Thumbnail and cache
             switch fileURL.pathExtension.lowercased() {
             case LocalFileInformationGenerator.videoThumbnailExtensions:
@@ -117,7 +117,7 @@ extension LocalFileProvider: ExtendedFileProvider {
             var dic = [String: Any]()
             var keys = [String]()
             if let getterMethod = getter {
-                (dic, keys) = getterMethod(self.absoluteURL(path))
+                (dic, keys) = getterMethod(self.url(of: path))
             }
             
             completionHandler(dic, keys, nil)

Sources/FileObject.swift

@@ -16,20 +16,25 @@ open class FileObject {
         self.allValues = allValues
     }
     
-    internal init(absoluteURL: URL? = nil, name: String, path: String) {
+    internal init(url: URL, name: String, path: String) {
         self.allValues = [String: Any]()
-        self.absoluteURL = absoluteURL
+        self.url = url
         self.name = name
         self.path = path
     }
     
     /// url to access the resource, not supported by Dropbox provider
-    open internal(set) var absoluteURL: URL? {
+    @available(*, deprecated, message: "Use FileObject.url.absoluteURL instead.")
+    open var absoluteURL: URL? {
+        return url?.absoluteURL
+    }
+    
+    open internal(set) var url: URL? {
         get {
-            return allValues["NSURLAbsoluteURLKey"] as? URL
+            return allValues["NSURLFileURLKey"] as? URL
         }
         set {
-            allValues["NSURLAbsoluteURLKey"] = newValue
+            allValues["NSURLFileURLKey"] = newValue
         }
     }
     
@@ -135,7 +140,7 @@ open class FileObject {
     }
 }
 
-/// Sorting FileObject array by given criteria, not thread-safe
+/// Sorting FileObject array by given criteria, **not thread-safe**
 public struct FileObjectSorting {
     
     /// Determines sort kind by which item of File object
@@ -222,6 +227,17 @@ public struct FileObjectSorting {
     }
 }
 
+extension Array where Element: FileObject {
+    public func sorted(by type: FileObjectSorting.SortType, ascending: Bool = true, isDirectoriesFirst: Bool = false) -> [Element] {
+        let sorting = FileObjectSorting(type: type, ascending: ascending, isDirectoriesFirst: isDirectoriesFirst)
+        return sorting.sort(self) as! [Element]
+    }
+    
+    public mutating func sorted(by type: FileObjectSorting.SortType, ascending: Bool = true, isDirectoriesFirst: Bool = false) {
+        self = self.sorted(by: type, ascending: ascending, isDirectoriesFirst: isDirectoriesFirst)
+    }
+}
+
 extension URLFileResourceType {
     public init(fileTypeValue: FileAttributeType) {
         switch fileTypeValue {

Sources/FileProvider.swift

@@ -19,10 +19,12 @@ public typealias SimpleCompletionHandler = ((_ error: Error?) -> Void)?
 
 public protocol FileProviderBasic: class {
     static var type: String { get }
+    var type: String { get }
     var isPathRelative: Bool { get }
     var baseURL: URL? { get }
     var currentPath: String { get set }
     var dispatch_queue: DispatchQueue { get set }
+    var operation_queue: OperationQueue { get set }
     var delegate: FileProviderDelegate? { get set }
     var credential: URLCredential? { get }
     
@@ -34,6 +36,17 @@ public protocol FileProviderBasic: class {
     func url(of path: String?) -> URL
 }
 
+public extension FileProviderBasic {
+    public var maximumOperationTasks: Int {
+        get {
+            return operation_queue.maxConcurrentOperationCount
+        }
+        set {
+            operation_queue.maxConcurrentOperationCount = newValue
+        }
+    }
+}
+
 public protocol FileProviderBasicRemote: FileProviderBasic {
     var session: URLSession { get }
     var cache: URLCache? { get }
@@ -180,7 +193,7 @@ public protocol FileProviderMonitor: FileProviderBasic {
 public protocol FileProvider: FileProviderBasic, FileProviderOperations, FileProviderReadWrite, NSCopying {
 }
 
-fileprivate let pathTrimSet = CharacterSet(charactersIn: " /")
+internal let pathTrimSet = CharacterSet(charactersIn: " /")
 extension FileProviderBasic {
     public var type: String {
         return Self.type
@@ -205,17 +218,22 @@ extension FileProviderBasic {
         } else {
             rpath = self.currentPath
         }
-        if isPathRelative, let baseURL = baseURL {
-            if rpath.hasPrefix("/") {
+        rpath = rpath.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? rpath
+        if let baseURL = baseURL {
+            if isPathRelative && rpath.hasPrefix("/") {
                 rpath.remove(at: rpath.startIndex)
             }
-            return URL(string: rpath.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed)!, relativeTo: baseURL)!
+            return URL(string: rpath, relativeTo: baseURL) ?? baseURL
         } else {
-            return URL(string: rpath.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed)!)!.standardizedFileURL
+            return URL(string: rpath)!
         }
     }
     
     public func relativePathOf(url: URL) -> String {
+        if url.baseURL == self.baseURL {
+            return url.relativePath.removingPercentEncoding!
+        }
+        
         guard let baseURL = self.baseURL else { return url.absoluteString }
         return url.standardizedFileURL.absoluteString.replacingOccurrences(of: baseURL.absoluteString, with: "/").removingPercentEncoding!
     }
@@ -250,7 +268,7 @@ extension FileProviderBasic {
             }
             var i = number ?? 2
             let similiar = contents.map {
-                $0.absoluteURL?.lastPathComponent ?? $0.name
+                $0.url?.lastPathComponent ?? $0.name
             }.filter {
                 $0.hasPrefix(result)
             }
@@ -266,7 +284,7 @@ extension FileProviderBasic {
     }
     
     internal func throwError(_ path: String, code: FoundationErrorEnum) -> NSError {
-        let fileURL = self.absoluteURL(path)
+        let fileURL = self.url(of: path)
         let domain: String
         switch code {
         case is URLError:

Sources/LocalFileProvider.swift

@@ -9,49 +9,85 @@
 import Foundation
 
 open class LocalFileProvider: FileProvider, FileProviderMonitor {
-    open static let type = "Local"
-    open var isPathRelative: Bool = true
-    open private(set) var baseURL: URL? = LocalFileProvider.defaultBaseURL()
-    open var currentPath: String = ""
+    open static let type: String = "Local"
+    open var isPathRelative: Bool
+    open fileprivate(set) var baseURL: URL?
+    open var currentPath: String
     open var dispatch_queue: DispatchQueue
-    open var operation_queue: DispatchQueue
+    open var operation_queue: OperationQueue
     open weak var delegate: FileProviderDelegate?
-    open let credential: URLCredential? = nil
+    open internal(set) var credential: URLCredential?
         
     open private(set) var fileManager = FileManager()
     open private(set) var opFileManager = FileManager()
     fileprivate var fileProviderManagerDelegate: LocalFileProviderManagerDelegate? = nil
     
-    public init () {
-        dispatch_queue = DispatchQueue(label: "FileProvider.\(LocalFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
-        operation_queue = DispatchQueue(label: "FileProvider.\(LocalFileProvider.type).Operation", attributes: [])
-        fileProviderManagerDelegate = LocalFileProviderManagerDelegate(provider: self)
-        opFileManager.delegate = fileProviderManagerDelegate
+    /// Forces file operations to use NSFileCoordinating, should be set true if:
+    /// - Files are on ubiquity(iCloud) container
+    /// - Multiple processes are accessing same file, recommended always in macOS and when using app extensions in iOS/tvOS (shared container)
+    open var isCoorinating: Bool
+    
+    /// default values are `directory: .documentDirectory, domainMask: .userDomainMask`
+    public convenience init (directory: FileManager.SearchPathDirectory = .documentDirectory, domainMask: FileManager.SearchPathDomainMask = .userDomainMask) {
+        self.init(baseURL: FileManager.default.urls(for: directory, in: domainMask).first!)
+    }
+    
+    public convenience init ? (sharedContainerId: String, directory: FileManager.SearchPathDirectory = .userDirectory) {
+        guard let baseURL = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: sharedContainerId) else {
+            return nil
+        }
+        
+        var finalBaseURL = baseURL
+        
+        switch directory {
+        case .documentDirectory:
+            finalBaseURL = baseURL.appendingPathComponent("Documents")
+        case .libraryDirectory:
+            finalBaseURL = baseURL.appendingPathComponent("Library")
+        case .cachesDirectory:
+            finalBaseURL = baseURL.appendingPathComponent("Library/Caches")
+        case .applicationSupportDirectory:
+            finalBaseURL = baseURL.appendingPathComponent("Library/Application%20support")
+        default:
+            break
+        }
+        
+        self.init(baseURL: finalBaseURL)
+        
+        try? fileManager.createDirectory(at: finalBaseURL, withIntermediateDirectories: true)
     }
     
     public init (baseURL: URL) {
         self.baseURL = baseURL
-        dispatch_queue = DispatchQueue(label: "FileProvider.\(LocalFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
-        operation_queue = DispatchQueue(label: "FileProvider.\(LocalFileProvider.type).Operation", attributes: [])
+        self.isPathRelative = true
+        self.currentPath = ""
+        self.credential = nil
+        self.isCoorinating = false
+        
+        dispatch_queue = DispatchQueue(label: "FileProvider.\(type(of: self).type)", attributes: DispatchQueue.Attributes.concurrent)
+        operation_queue = OperationQueue()
+        operation_queue.name = "FileProvider.\(type(of: self).type).Operation"
+        
         fileProviderManagerDelegate = LocalFileProviderManagerDelegate(provider: self)
         opFileManager.delegate = fileProviderManagerDelegate
+        
     }
     
-    open static func defaultBaseURL() -> URL {
-        let paths = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true);
-        return URL(fileURLWithPath: paths[0])
+    @available(*, deprecated, message: "Overriding this method has no effect anymore.")
+    open class func defaultBaseURL() -> URL {
+        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
     }
     
     open func contentsOfDirectory(path: String, completionHandler: @escaping ((_ contents: [FileObject], _ error: Error?) -> Void)) {
         dispatch_queue.async {
             do {
-                let contents = try self.fileManager.contentsOfDirectory(at: self.absoluteURL(path), includingPropertiesForKeys: [.nameKey, .fileSizeKey, .fileAllocatedSizeKey, .creationDateKey, .contentModificationDateKey, .isHiddenKey, .volumeIsReadOnlyKey], options: .skipsSubdirectoryDescendants)
+                let contents = try self.fileManager.contentsOfDirectory(at: self.url(of: path), includingPropertiesForKeys: [.nameKey, .fileSizeKey, .fileAllocatedSizeKey, .creationDateKey, .contentModificationDateKey, .isHiddenKey, .volumeIsReadOnlyKey], options: .skipsSubdirectoryDescendants)
                 let filesAttributes = contents.flatMap({ (fileURL) -> LocalFileObject? in
                     let path = self.relativePathOf(url: fileURL)
                     return LocalFileObject(fileWithPath: path, relativeTo: self.baseURL)
                 })
                 completionHandler(filesAttributes, nil)
-            } catch let e as NSError {
+            } catch let e {
                 completionHandler([], e)
             }
         }
@@ -75,109 +111,204 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
     @discardableResult
     open func create(folder folderName: String, at atPath: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         let opType = FileOperationType.create(path: (atPath as NSString).appendingPathComponent(folderName) + "/")
-        operation_queue.async {
+        let url = self.url(of: atPath).appendingPathComponent(folderName)
+        
+        let operationHandler: (URL) -> Void = { url in
             do {
-                try self.opFileManager.createDirectory(at: self.absoluteURL(atPath).appendingPathComponent(folderName), withIntermediateDirectories: true, attributes: [:])
+                try self.opFileManager.createDirectory(at: url, withIntermediateDirectories: true, attributes: [:])
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: opType)
-                })
-            } catch let e as NSError {
+                }
+            } catch let e {
                 completionHandler?(e)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: opType)
-                })
+                }
             }
         }
+        
+        if isCoorinating {
+            let intent = NSFileAccessIntent.writingIntent(with: url, options: .forReplacing)
+            self.coordinated(intents: [intent], completionHandler: operationHandler, errorHandler: { error in
+                completionHandler?(error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            })
+        } else {
+            operation_queue.addOperation {
+                operationHandler(url)
+            }
+        }
+        
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
     @discardableResult
     open func create(file fileName: String, at atPath: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         let opType = FileOperationType.create(path: (atPath as NSString).appendingPathComponent(fileName))
-        operation_queue.async {
-            let fileURL = self.absoluteURL(atPath).appendingPathComponent(fileName)
-            let success = self.opFileManager.createFile(atPath: fileURL.path, contents: data, attributes: nil)
+        let url = self.url(of: atPath).appendingPathComponent(fileName, isDirectory: false)
+        
+        let operationHandler: (URL) -> Void = { url in
+            let success = self.opFileManager.createFile(atPath: url.path, contents: data, attributes: nil)
             if success {
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: opType)
-                })
+                }
             } else {
                 completionHandler?(self.throwError(atPath, code: URLError.cannotCreateFile as FoundationErrorEnum))
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: opType)
-                })
+                }
             }
         }
+        
+        if isCoorinating {
+            let intent = NSFileAccessIntent.writingIntent(with:url, options: .forReplacing)
+            self.coordinated(intents: [intent], completionHandler: operationHandler, errorHandler: { error in
+                completionHandler?(error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            })
+        } else {
+            operation_queue.addOperation {
+                operationHandler(url)
+            }
+        }
+        
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
     @discardableResult
     open func moveItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         let opType = FileOperationType.move(source: path, destination: toPath)
-        operation_queue.async {
-            if !overwrite && self.fileManager.fileExists(atPath: self.absoluteURL(toPath).path) {
+        let sourceUrl = self.url(of: path)
+        let destUrl = self.url(of: toPath)
+        
+        let sourceIntent = NSFileAccessIntent.writingIntent(with: sourceUrl, options: .forDeleting)
+        let destIntent = NSFileAccessIntent.writingIntent(with: destUrl, options: .forReplacing)
+        
+        let operationHandler: (URL, URL) -> Void = { sourceUrl, destUrl in
+            if !overwrite && self.fileManager.fileExists(atPath: destUrl.path) {
                 completionHandler?(self.throwError(toPath, code: URLError.cannotMoveFile as FoundationErrorEnum))
                 return
             }
             do {
-                try self.opFileManager.moveItem(at: self.absoluteURL(path), to: self.absoluteURL(toPath))
+                try self.opFileManager.moveItem(at: sourceUrl, to: destUrl)
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: opType)
-                })
-            } catch let e as NSError {
+                }
+            } catch let e {
                 completionHandler?(e)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: opType)
-                })
+                }
             }
         }
+        
+        if isCoorinating {
+            coordinated(intents: [sourceIntent, destIntent], completionHandler: operationHandler) { (error) in
+                completionHandler?(error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            }
+        } else {
+            operation_queue.addOperation {
+                operationHandler(sourceUrl, destUrl)
+            }
+        }
+        
+        
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
     @discardableResult
     open func copyItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         let opType = FileOperationType.copy(source: path, destination: toPath)
-        operation_queue.async {
-            if !overwrite && self.fileManager.fileExists(atPath: self.absoluteURL(toPath).path) {
-                completionHandler?(self.throwError(toPath, code: URLError.cannotWriteToFile as FoundationErrorEnum))
+        let sourceUrl = self.url(of: path)
+        let destUrl = self.url(of: toPath)
+        
+        let sourceIntent = NSFileAccessIntent.readingIntent(with: sourceUrl, options: .withoutChanges)
+        let destIntent = NSFileAccessIntent.writingIntent(with: destUrl, options: .forDeleting)
+        
+        let operationHandler: (URL, URL) -> Void = { sourceUrl, destUrl in
+            if !overwrite && self.fileManager.fileExists(atPath: destUrl.path) {
+                completionHandler?(self.throwError(toPath, code: URLError.cannotMoveFile as FoundationErrorEnum))
                 return
             }
             do {
-                try self.opFileManager.copyItem(at: self.absoluteURL(path), to: self.absoluteURL(toPath))
+                try self.opFileManager.copyItem(at: sourceUrl, to: destUrl)
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: opType)
-                })
-            } catch let e as NSError {
+                }
+            } catch let e {
                 completionHandler?(e)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: opType)
-                })
+                }
             }
         }
+        
+        if isCoorinating {
+            coordinated(intents: [sourceIntent, destIntent], moving: true, completionHandler: operationHandler) { (error) in
+                completionHandler?(error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            }
+        } else {
+            operation_queue.addOperation {
+                operationHandler(sourceUrl, destUrl)
+            }
+        }
+        
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
     @discardableResult
     open func removeItem(path: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         let opType = FileOperationType.remove(path: path)
-        operation_queue.async {
+        let url = self.url(of: path)
+        
+        let operationHandler: (URL) -> Void = { url in
             do {
-                try self.opFileManager.removeItem(at: self.absoluteURL(path))
+                let successfulSecurityScopedResourceAccess = url.startAccessingSecurityScopedResource()
+                try self.opFileManager.removeItem(at: url)
+                if successfulSecurityScopedResourceAccess {
+                    url.stopAccessingSecurityScopedResource()
+                }
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: opType)
-                })
-            } catch let e as NSError {
+                }
+            } catch let e {
                 completionHandler?(e)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: opType)
-                })
+                }
             }
         }
+        
+        if isCoorinating {
+            let intent = NSFileAccessIntent.writingIntent(with:url, options: .forReplacing)
+            self.coordinated(intents: [intent], completionHandler: operationHandler, errorHandler: { error in
+                completionHandler?(error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            })
+        } else {
+            operation_queue.addOperation {
+                operationHandler(url)
+            }
+        }
+        
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
@@ -185,18 +316,18 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
     open func copyItem(localFile: URL, to toPath: String, overwrite: Bool, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         // TODO: Make use of overwrite parameter
         let opType = FileOperationType.copy(source: localFile.absoluteString, destination: toPath)
-        operation_queue.async {
+        operation_queue.addOperation {
             do {
-                try self.opFileManager.copyItem(at: localFile, to: self.absoluteURL(toPath))
+                try self.opFileManager.copyItem(at: localFile, to: self.url(of: toPath))
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: opType)
-                })
-            } catch let e as NSError {
+                }
+            } catch let e {
                 completionHandler?(e)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: opType)
-                })
+                }
             }
         }
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
@@ -205,18 +336,18 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
     @discardableResult
     open func copyItem(path: String, toLocalURL: URL, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         let opType = FileOperationType.copy(source: path, destination: toLocalURL.absoluteString)
-        operation_queue.async {
+        operation_queue.addOperation {
             do {
-                try self.opFileManager.copyItem(at: self.absoluteURL(path), to: toLocalURL)
+                try self.opFileManager.copyItem(at: self.url(of: path), to: toLocalURL)
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: opType)
-                })
-            } catch let e as NSError {
+                }
+            } catch let e {
                 completionHandler?(e)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: opType)
-                })
+                }
             }
         }
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
@@ -224,11 +355,29 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
     
     @discardableResult
     open func contents(path: String, completionHandler: @escaping ((_ contents: Data?, _ error: Error?) -> Void)) -> OperationHandle? {
-        dispatch_queue.async {
-            let data = self.fileManager.contents(atPath: self.absoluteURL(path).path)
+        let opType = FileOperationType.fetch(path: path)
+        let url = self.url(of: path)
+        
+        let operationHandler: (URL) -> Void = { url in
+            let data = self.fileManager.contents(atPath: url.path)
             completionHandler(data, nil)
         }
-        return nil
+        
+        if isCoorinating {
+            let intent = NSFileAccessIntent.readingIntent(with: url, options: .withoutChanges)
+            coordinated(intents: [intent], completionHandler: operationHandler, errorHandler: { error in
+                completionHandler(nil, error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            })
+        } else {
+            dispatch_queue.async {
+                operationHandler(url)
+            }
+        }
+        
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
     @discardableResult
@@ -236,14 +385,16 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
         if length < 0 {
             return self.contents(path: path, completionHandler: completionHandler)
         }
+        
         let opType = FileOperationType.fetch(path: path)
-        dispatch_queue.async {
-            let aPath = self.absoluteURL(path).path
-            guard self.fileManager.fileExists(atPath: aPath) && !self.absoluteURL(path).fileIsDirectory else {
+        let url = self.url(of: path)
+        
+        let operationHandler: (URL) -> Void = { url in
+            guard self.fileManager.fileExists(atPath: url.path) && !url.fileIsDirectory else {
                 completionHandler(nil, self.throwError(path, code: URLError.cannotOpenFile as FoundationErrorEnum))
                 return
             }
-            guard let handle = FileHandle(forReadingAtPath: aPath) else {
+            guard let handle = FileHandle(forReadingAtPath: url.path) else {
                 completionHandler(nil, self.throwError(path, code: URLError.cannotOpenFile as FoundationErrorEnum))
                 return
             }
@@ -253,14 +404,29 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
             handle.seek(toFileOffset: UInt64(offset))
             let data = handle.readData(ofLength: length)
             completionHandler(data, nil)
-            
         }
+        
+        if isCoorinating {
+            let intent = NSFileAccessIntent.readingIntent(with: url, options: .withoutChanges)
+            coordinated(intents: [intent], completionHandler: operationHandler, errorHandler: { error in
+                completionHandler(nil, error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            })
+        } else {
+            dispatch_queue.async {
+                operationHandler(url)
+            }
+        }
+        
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
     @discardableResult
     open func writeContents(path: String, contents data: Data, atomically: Bool, overwrite: Bool, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
         let opType = FileOperationType.modify(path: path)
+        let url = self.url(of: path)
         var options: Data.WritingOptions = []
         if atomically {
             options.insert(.atomic)
@@ -268,18 +434,42 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
         if overwrite {
             options.insert(.withoutOverwriting)
         }
-        operation_queue.async {
-            try? data.write(to: self.absoluteURL(path), options: atomically ? [.atomic] : [])
-            DispatchQueue.main.async(execute: {
-                self.delegate?.fileproviderSucceed(self, operation: opType)
-            })
+        
+        let operationHandler: (URL) -> Void = { url in
+            do {
+                try data.write(to: url, options: atomically ? [.atomic] : [])
+                completionHandler?(nil)
+                DispatchQueue.main.async{
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
+                }
+            } catch let e {
+                completionHandler?(e)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            }
         }
+        
+        if isCoorinating {
+            let intent = NSFileAccessIntent.writingIntent(with: url, options: .forReplacing)
+            coordinated(intents: [intent], completionHandler: operationHandler, errorHandler: { error in
+                completionHandler?(error)
+                DispatchQueue.main.async {
+                    self.delegate?.fileproviderFailed(self, operation: opType)
+                }
+            })
+        } else {
+            operation_queue.addOperation {
+                operationHandler(url)
+            }
+        }
+        
         return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
     }
     
     open func searchFiles(path: String, recursive: Bool, query: String, foundItemHandler: ((FileObject) -> Void)?, completionHandler: @escaping ((_ files: [FileObject], _ error: Error?) -> Void)) {
         dispatch_queue.async { 
-            let iterator = self.fileManager.enumerator(at: self.absoluteURL(path), includingPropertiesForKeys: nil, options: recursive ? [] : [.skipsSubdirectoryDescendants, .skipsPackageDescendants]) { (url, e) -> Bool in
+            let iterator = self.fileManager.enumerator(at: self.url(of: path), includingPropertiesForKeys: nil, options: recursive ? [] : [.skipsSubdirectoryDescendants, .skipsPackageDescendants]) { (url, e) -> Bool in
                 completionHandler([], e)
                 return true
             }
@@ -301,12 +491,12 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
     
     open func registerNotifcation(path: String, eventHandler: @escaping (() -> Void)) {
         self.unregisterNotifcation(path: path)
-        let absurl = self.absoluteURL(path)
-        let isdir = (try? absurl.resourceValues(forKeys: [.isDirectoryKey]).isDirectory ?? false) ?? false
+        let dirurl = self.url(of: path)
+        let isdir = (try? dirurl.resourceValues(forKeys: [.isDirectoryKey]).isDirectory ?? false) ?? false
         if !isdir {
             return
         }
-        let monitor = LocalFolderMonitor(url: absurl) {
+        let monitor = LocalFolderMonitor(url: dirurl) {
             eventHandler()
         }
         monitor.start()
@@ -340,18 +530,60 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
 
 public extension LocalFileProvider {
     public func create(symbolicLink path: String, withDestinationPath destPath: String, completionHandler: SimpleCompletionHandler) {
-        operation_queue.async {
+        operation_queue.addOperation {
             do {
-                try self.opFileManager.createSymbolicLink(at: self.absoluteURL(path), withDestinationURL: self.absoluteURL(destPath))
+                try self.opFileManager.createSymbolicLink(at: self.url(of: path), withDestinationURL: self.url(of: destPath))
                 completionHandler?(nil)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderSucceed(self, operation: .link(link: path, target: destPath))
-                })
-            } catch let e as NSError {
+                }
+            } catch let e {
                 completionHandler?(e)
-                DispatchQueue.main.async(execute: {
+                DispatchQueue.main.async {
                     self.delegate?.fileproviderFailed(self, operation: .link(link: path, target: destPath))
-                })
+                }
+            }
+        }
+    }
+    
+    public func destination(ofSymbolicLink path: String, completionHandler: @escaping (_ url: URL?, _ error: Error?) -> Void) {
+        dispatch_queue.async {
+            do {
+                let destPath = try self.opFileManager.destinationOfSymbolicLink(atPath: self.url(of: path).path)
+                let destUrl = URL(fileURLWithPath: destPath)
+                completionHandler(destUrl, nil)
+            } catch let e{
+                completionHandler(nil, e)
+            }
+        }
+    }
+}
+
+internal extension LocalFileProvider {
+    func coordinated(intents: [NSFileAccessIntent], completionHandler: @escaping (_ url: URL) -> Void, errorHandler: ((_ error: Error) -> Void)? = nil) {
+        let coordinator = NSFileCoordinator(filePresenter: nil)
+        coordinator.coordinate(with: intents, queue: operation_queue) { (error) in
+            if let error = error {
+                errorHandler?(error)
+                return
+            }
+            completionHandler(intents[0].url)
+        }
+    }
+    
+    func coordinated(intents: [NSFileAccessIntent], moving: Bool = false, completionHandler: @escaping (_ sourceUrl: URL, _ destURL: URL) -> Void, errorHandler:  ((_ error: Error) -> Void)? = nil) {
+        let coordinator = NSFileCoordinator(filePresenter: nil)
+        coordinator.coordinate(with: intents, queue: operation_queue) { (error) in
+            if let error = error {
+                errorHandler?(error)
+                return
+            }
+            if moving {
+                coordinator.item(at: intents[0].url, willMoveTo: intents[1].url)
+            }
+            completionHandler(intents[0].url, intents[1].url)
+            if moving {
+                coordinator.item(at: intents[0].url, didMoveTo: intents[1].url)
             }
         }
     }

Sources/LocalHelper.swift

@@ -9,32 +9,32 @@
 import Foundation
 
 public final class LocalFileObject: FileObject {
-    internal init(absoluteURL: URL, name: String, path: String) {
-        super.init(absoluteURL: absoluteURL, name: name, path: path)
+    internal override init(url: URL, name: String, path: String) {
+        super.init(url: url, name: name, path: path)
     }
     
     public convenience init? (fileWithPath path: String, relativeTo relativeURL: URL?) {
         let fileURL: URL
-        if let relativeURL = relativeURL {
-            fileURL = relativeURL.appendingPathComponent(path)
+        var rpath = path.replacingOccurrences(of: relativeURL?.absoluteString  ?? "", with: "")
+        if path.hasPrefix("/") {
+            rpath.remove(at: rpath.startIndex)
+        }
+        if rpath.isEmpty {
+            fileURL = relativeURL ?? URL(fileURLWithPath: path)
         } else {
-            fileURL = URL(fileURLWithPath: path)
-        }
-        do {
-            let values = try fileURL.resourceValues(forKeys: [.nameKey, .fileSizeKey, .fileAllocatedSizeKey, .creationDateKey, .contentModificationDateKey, .fileResourceTypeKey, .isHiddenKey, .isWritableKey])
-            self.init(absoluteURL: fileURL, name: values.name ?? fileURL.lastPathComponent, path: path)
-            for (key, value) in values.allValues {
-                self.allValues[key.rawValue] = value
+            if #available(iOS 9.0, macOS 10.11, tvOS 9.0, *) {
+                fileURL = URL(fileURLWithPath: rpath, relativeTo: relativeURL)
+            } else {
+                fileURL = relativeURL?.appendingPathComponent(path) ?? URL(fileURLWithPath: path)
             }
-        } catch {
-            return nil
         }
+        self.init(fileWithURL: fileURL)
     }
     
     public convenience init?(fileWithURL fileURL: URL) {
         do {
             let values = try fileURL.resourceValues(forKeys: [.nameKey, .fileSizeKey, .fileAllocatedSizeKey, .creationDateKey, .contentModificationDateKey, .fileResourceTypeKey, .isHiddenKey, .isWritableKey, .typeIdentifierKey])
-            self.init(absoluteURL: fileURL, name: values.name ?? fileURL.lastPathComponent, path: fileURL.path)
+            self.init(url: fileURL, name: values.name ?? fileURL.lastPathComponent, path: fileURL.path)
             for (key, value) in values.allValues {
                 self.allValues[key.rawValue] = value
             }
@@ -190,7 +190,7 @@ open class LocalOperationHandle: OperationHandle {
     public let operationType: FileOperationType
     
     init (operationType: FileOperationType, baseURL: URL?) {
-        self.baseURL = baseURL ?? LocalFileProvider.defaultBaseURL()
+        self.baseURL = baseURL ?? URL(fileURLWithPath: "/")
         self.operationType = operationType
     }
     

Sources/OneDriveFileProvide.swift

@@ -13,26 +13,29 @@ import CoreGraphics
 // Because this class uses NSURLSession, it's necessary to disable App Transport Security
 // in case of using this class with unencrypted HTTP connection.
 
-open class OneDriveFileProvider: NSObject,  FileProviderBasicRemote {
+open class OneDriveFileProvider: FileProviderBasicRemote {
     open static let type: String = "OneDrive"
-    open let isPathRelative: Bool = true
+    open let isPathRelative: Bool
     open let baseURL: URL?
+    open var serverURL: URL { return baseURL! }
     open var drive: String
     open var driveURL: URL {
-        return URL(string: "/drive/root:/", relativeTo: baseURL)!
+        return URL(string: "/drive/\(drive):/", relativeTo: baseURL)!
     }
-    open var currentPath: String = ""
+    open var currentPath: String
     
-    open var dispatch_queue: DispatchQueue {
+    open var dispatch_queue: DispatchQueue
+    open var operation_queue: OperationQueue {
         willSet {
             assert(_session == nil, "It's not effective to change dispatch_queue property after session is initialized.")
         }
     }
+    
     open weak var delegate: FileProviderDelegate?
     open let credential: URLCredential?
     open private(set) var cache: URLCache?
-    public var useCache: Bool = false
-    public var validatingCache: Bool = true
+    public var useCache: Bool
+    public var validatingCache: Bool
    
     fileprivate var _session: URLSession?
     fileprivate var sessionDelegate: SessionDelegate?
@@ -49,13 +52,18 @@ open class OneDriveFileProvider: NSObject,  FileProviderBasicRemote {
         return _session!
     }
     
-    public init? (baseURL: URL?, drive: String = "root", credential: URLCredential?, cache: URLCache? = nil) {
-        self.baseURL = baseURL ?? URL(string: "https://api.onedrive.com")
+    public init? (credential: URLCredential?, serverURL: URL? = nil, drive: String = "root", cache: URLCache? = nil) {
+        self.baseURL = (serverURL ?? URL(string: "https://api.onedrive.com/")!).appendingPathComponent("")
         self.drive = drive
-        dispatch_queue = DispatchQueue(label: "FileProvider.\(OneDriveFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
-        //let url = baseURL.uw_absoluteString
-        self.credential = credential
+        self.isPathRelative = true
+        self.currentPath = ""
+        self.useCache = false
+        self.validatingCache = true
         self.cache = cache
+        self.credential = credential
+        dispatch_queue = DispatchQueue(label: "FileProvider.\(type(of: self).type)", attributes: DispatchQueue.Attributes.concurrent)
+        operation_queue = OperationQueue()
+        operation_queue.name = "FileProvider.\(type(of: self).type).Operation"
     }
     
     deinit {
@@ -220,7 +228,7 @@ extension OneDriveFileProvider: FileProviderReadWrite {
         request.httpMethod = "GET"
         request.setValue("Bearer \(credential?.password ?? "")", forHTTPHeaderField: "Authorization")
         if length > 0 {
-            request.setValue("bytes=\(offset)-\(offset + length)", forHTTPHeaderField: "Range")
+            request.setValue("bytes=\(offset)-\(offset + length - 1)", forHTTPHeaderField: "Range")
         } else if offset > 0 && length < 0 {
             request.setValue("bytes=\(offset)-", forHTTPHeaderField: "Range")
         }
@@ -341,7 +349,7 @@ extension OneDriveFileProvider: ExtendedFileProvider {
 
 extension OneDriveFileProvider: FileProvider {
     open func copy(with zone: NSZone? = nil) -> Any {
-        let copy = OneDriveFileProvider(baseURL: self.baseURL, drive: self.drive, credential: self.credential, cache: self.cache)!
+        let copy = OneDriveFileProvider(credential: self.credential, serverURL: self.baseURL, drive: self.drive, cache: self.cache)!
         copy.currentPath = self.currentPath
         copy.delegate = self.delegate
         copy.fileOperationDelegate = self.fileOperationDelegate

Sources/OneDriveHelper.swift

@@ -19,8 +19,13 @@ public struct FileProviderOneDriveError: Error, CustomStringConvertible {
 }
 
 public final class OneDriveFileObject: FileObject {
-    internal init(name: String, path: String) {
-        super.init(absoluteURL: URL(string: path), name: name, path: path)
+    internal init(baseURL: URL?, name: String, path: String) {
+        var rpath = path
+        if path.hasPrefix("/") {
+            rpath.remove(at: rpath.startIndex)
+        }
+        let url = URL(string: rpath, relativeTo: baseURL) ?? URL(string: path)!
+        super.init(url: url, name: name, path: path)
     }
     
     
@@ -93,7 +98,12 @@ internal extension OneDriveFileProvider {
     }
     
     func upload_simple(_ targetPath: String, data: Data, modifiedDate: Date = Date(), overwrite: Bool, operation: FileOperationType, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        assert(data.count < 100*1024*1024, "Maximum size of allowed size to upload is 100MB")
+        if data.count > 100 * 1024 * 1024 {
+            let error = FileProviderOneDriveError(code: .payloadTooLarge, path: targetPath, errorDescription: nil)
+            completionHandler?(error)
+            self.delegateNotify(.create(path: targetPath), error: error)
+            return nil
+        }
         let queryStr = overwrite ? "" : "?@name.conflictBehavior=fail"
         let url = URL(string: escaped(path: targetPath) + ":/content" + queryStr, relativeTo: driveURL)!
         var request = URLRequest(url: url)
@@ -115,6 +125,13 @@ internal extension OneDriveFileProvider {
     }
     
     func upload_simple(_ targetPath: String, localFile: URL, modifiedDate: Date = Date(), overwrite: Bool, operation: FileOperationType, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let size = (try? localFile.resourceValues(forKeys: [.fileSizeKey]))?.fileSize ?? -1
+        if size > 100 * 1024 * 1024 {
+            let error = FileProviderOneDriveError(code: .payloadTooLarge, path: targetPath, errorDescription: nil)
+            completionHandler?(error)
+            self.delegateNotify(.create(path: targetPath), error: error)
+            return nil
+        }
         let queryStr = overwrite ? "" : "?@name.conflictBehavior=fail"
         let url = URL(string: escaped(path: targetPath) + ":/content" + queryStr, relativeTo: driveURL)!
         var request = URLRequest(url: url)
@@ -187,10 +204,7 @@ internal extension OneDriveFileProvider {
         guard let name = json["name"] as? String else { return nil }
         guard let path = (json["parentReference"] as? NSDictionary)?["path"] as? String else { return nil }
         let lPath = path.replacingOccurrences(of: "/drive/\(drive):", with: "/", options: .anchored, range: nil)
-        let fileObject = OneDriveFileObject(name: name, path: lPath)
-        if let webURL = json["webUrl"] as? String, let absolluteURL = URL(string: webURL) {
-            fileObject.absoluteURL = absolluteURL
-        }
+        let fileObject = OneDriveFileObject(baseURL: self.baseURL, name: name, path: lPath)
         fileObject.size = (json["size"] as? NSNumber)?.int64Value ?? -1
         fileObject.modifiedDate = resolve(dateString: json["lastModifiedDateTime"] as? String ?? "")
         fileObject.creationDate = resolve(dateString: json["createdDateTime"] as? String ?? "")

Sources/SMBFileProvider.swift

@@ -9,11 +9,13 @@
 import Foundation
 
 class SMBFileProvider: FileProvider, FileProviderMonitor {
+
     open static var type: String = "Samba"
     open var isPathRelative: Bool = true
     open var baseURL: URL?
     open var currentPath: String = ""
     open var dispatch_queue: DispatchQueue
+    open var operation_queue: OperationQueue
     open weak var delegate: FileProviderDelegate?
     open let credential: URLCredential?
     
@@ -23,9 +25,11 @@ class SMBFileProvider: FileProvider, FileProviderMonitor {
         guard baseURL.uw_scheme.lowercased() == "smb" else {
             return nil
         }
-        self.baseURL = baseURL
-        dispatch_queue = DispatchQueue(label: "FileProvider.\(SMBFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
-        //let url = baseURL.uw_absoluteString
+        self.baseURL = baseURL.appendingPathComponent("")
+        dispatch_queue = DispatchQueue(label: "FileProvider.\(type(of: self).type)", attributes: DispatchQueue.Attributes.concurrent)
+        operation_queue = OperationQueue()
+        operation_queue.name = "FileProvider.\(type(of: self).type).Operation"
+        
         self.credential = credential
     }
         

Sources/WebDAVFileProvider.swift

@@ -9,8 +9,8 @@
 import Foundation
 
 public final class WebDavFileObject: FileObject {
-    internal init(absoluteURL: URL, name: String, path: String) {
-        super.init(absoluteURL: absoluteURL, name: name, path: path)
+    internal override init(url: URL, name: String, path: String) {
+        super.init(url: url, name: name, path: path)
     }
     
     open internal(set) var contentType: String {
@@ -35,21 +35,24 @@ public final class WebDavFileObject: FileObject {
 /// Because this class uses NSURLSession, it's necessary to disable App Transport Security
 /// in case of using this class with unencrypted HTTP connection.
 
-open class WebDAVFileProvider: NSObject,  FileProviderBasicRemote {
+open class WebDAVFileProvider: FileProviderBasicRemote {
     open static let type: String = "WebDAV"
-    open let isPathRelative: Bool = true
+    open let isPathRelative: Bool
     open let baseURL: URL?
-    open var currentPath: String = ""
-    public var dispatch_queue: DispatchQueue {
+    open var currentPath: String
+    
+    open var dispatch_queue: DispatchQueue
+    open var operation_queue: OperationQueue {
         willSet {
             assert(_session == nil, "It's not effective to change dispatch_queue property after session is initialized.")
         }
     }
+    
     public weak var delegate: FileProviderDelegate?
     open let credential: URLCredential?
     open private(set) var cache: URLCache?
-    public var useCache: Bool = false
-    public var validatingCache: Bool = true
+    public var useCache: Bool
+    public var validatingCache: Bool
     
     fileprivate var _session: URLSession?
     fileprivate var sessionDelegate: SessionDelegate?
@@ -70,11 +73,16 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasicRemote {
         if  !["http", "https"].contains(baseURL.uw_scheme.lowercased()) {
             return nil
         }
-        self.baseURL = baseURL
-        dispatch_queue = DispatchQueue(label: "FileProvider.\(WebDAVFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
-        //let url = baseURL.uw_absoluteString
-        self.credential = credential
+        self.baseURL = baseURL.appendingPathComponent("")
+        self.isPathRelative = true
+        self.currentPath = ""
+        self.useCache = false
+        self.validatingCache = true
         self.cache = cache
+        self.credential = credential
+        dispatch_queue = DispatchQueue(label: "FileProvider.\(type(of: self).type)", attributes: DispatchQueue.Attributes.concurrent)
+        operation_queue = OperationQueue()
+        operation_queue.name = "FileProvider.\(type(of: self).type).Operation"
     }
     
     deinit {
@@ -83,7 +91,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasicRemote {
     
     open func contentsOfDirectory(path: String, completionHandler: @escaping ((_ contents: [FileObject], _ error: Error?) -> Void)) {
         let opType = FileOperationType.fetch(path: path)
-        let url = absoluteURL(path)
+        let url = self.url(of: path).appendingPathComponent("")
         var request = URLRequest(url: url)
         request.httpMethod = "PROPFIND"
         request.setValue("1", forHTTPHeaderField: "Depth")
@@ -110,7 +118,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasicRemote {
     }
     
     open func attributesOfItem(path: String, completionHandler: @escaping ((_ attributes: FileObject?, _ error: Error?) -> Void)) {
-        let url = absoluteURL(path)
+        let url = self.url(of: path)
         var request = URLRequest(url: url)
         request.httpMethod = "PROPFIND"
         request.setValue("1", forHTTPHeaderField: "Depth")
@@ -170,7 +178,7 @@ extension WebDAVFileProvider: FileProviderOperations {
         guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
             return nil
         }
-        let url = absoluteURL((atPath as NSString).appendingPathComponent(folderName) + "/")
+        let url = self.url(of: atPath).appendingPathComponent(folderName, isDirectory: true)
         var request = URLRequest(url: url)
         request.httpMethod = "MKCOL"
         let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
@@ -192,7 +200,7 @@ extension WebDAVFileProvider: FileProviderOperations {
         guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
             return nil
         }
-        let url = absoluteURL(path).appendingPathComponent(fileName)
+        let url = self.url(of: path).appendingPathComponent(fileName)
         var request = URLRequest(url: url)
         request.httpMethod = "PUT"
         let task = session.uploadTask(with: request, from: data, completionHandler: { (data, response, error) in
@@ -236,10 +244,10 @@ extension WebDAVFileProvider: FileProviderOperations {
     }
     
     func doOperation(operation opType: FileOperationType, overwrite: Bool? = nil, completionHandler: SimpleCompletionHandler) -> OperationHandle?  {
-        let sourceURL = absoluteURL(opType.source!)
+        let sourceURL = self.url(of:opType.source!)
         var request = URLRequest(url: sourceURL)
         if let dest = opType.destination {
-            request.setValue(absoluteURL(dest).absoluteString, forHTTPHeaderField: "Destination")
+            request.setValue(url(of:dest).absoluteString, forHTTPHeaderField: "Destination")
         }
         switch opType {
         case .copy:
@@ -286,7 +294,7 @@ extension WebDAVFileProvider: FileProviderOperations {
         guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
             return nil
         }
-        let url = absoluteURL(toPath)
+        let url = self.url(of:toPath)
         var request = URLRequest(url: url)
         request.httpMethod = "PUT"
         let task = session.uploadTask(with: request, fromFile: localFile, completionHandler: { (data, response, error) in
@@ -308,7 +316,7 @@ extension WebDAVFileProvider: FileProviderOperations {
         guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
             return nil
         }
-        let url = absoluteURL(path)
+        let url = self.url(of:path)
         let request = URLRequest(url: url)
         let task = session.downloadTask(with: request, completionHandler: { (sourceFileURL, response, error) in
             var responseError: FileProviderWebDavError?
@@ -336,11 +344,11 @@ extension WebDAVFileProvider: FileProviderReadWrite {
     @discardableResult
     public func contents(path: String, offset: Int64, length: Int, completionHandler: @escaping ((_ contents: Data?, _ error: Error?) -> Void)) -> OperationHandle? {
         let opType = FileOperationType.fetch(path: path)
-        let url = absoluteURL(path)
+        let url = self.url(of: path)
         var request = URLRequest(url: url)
         request.httpMethod = "GET"
         if length > 0 {
-            request.setValue("bytes=\(offset)-\(offset + length)", forHTTPHeaderField: "Range")
+            request.setValue("bytes=\(offset)-\(offset + length - 1)", forHTTPHeaderField: "Range")
         } else if offset > 0 && length < 0 {
             request.setValue("bytes=\(offset)-", forHTTPHeaderField: "Range")
         }
@@ -362,7 +370,7 @@ extension WebDAVFileProvider: FileProviderReadWrite {
             return nil
         }
         // FIXME: lock destination before writing process
-        let url = atomically ? absoluteURL(path).appendingPathExtension("tmp") : absoluteURL(path)
+        let url = atomically ? self.url(of: path).appendingPathExtension("tmp") : self.url(of: path)
         var request = URLRequest(url: url)
         request.httpMethod = "PUT"
         if !overwrite {
@@ -371,7 +379,7 @@ extension WebDAVFileProvider: FileProviderReadWrite {
         let task = session.uploadTask(with: request, from: data, completionHandler: { (data, response, error) in
             var responseError: FileProviderWebDavError?
             if let code = (response as? HTTPURLResponse)?.statusCode , code >= 300, let rCode = FileProviderHTTPErrorCode(rawValue: code) {
-                responseError = FileProviderWebDavError(code: rCode, url: self.absoluteURL(path))
+                responseError = FileProviderWebDavError(code: rCode, url: self.url(of: path))
             }
             defer {
                 self.delegateNotify(opType, error: responseError ?? error)
@@ -390,7 +398,7 @@ extension WebDAVFileProvider: FileProviderReadWrite {
     }
     
     public func searchFiles(path: String, recursive: Bool, query: String, foundItemHandler: ((FileObject) -> Void)?, completionHandler: @escaping ((_ files: [FileObject], _ error: Error?) -> Void)) {
-        let url = absoluteURL(path)
+        let url = self.url(of: path)
         var request = URLRequest(url: url)
         request.httpMethod = "PROPFIND"
         //request.setValue("1", forHTTPHeaderField: "Depth")
@@ -496,7 +504,19 @@ internal extension WebDAVFileProvider {
             }
         }
         let href = node[hreftag].value
-        if let href = href, let hrefURL = URL(string: href) {
+        if let href = href {
+            let phrefURL: URL?
+            var relativePath = href.replacingOccurrences(of: self.baseURL?.absoluteString ?? "", with: "/")
+            if relativePath.hasPrefix("http://") || relativePath.hasPrefix("http://") {
+                phrefURL = URL(string: href)
+            } else {
+                if relativePath.hasPrefix("/") {
+                    relativePath.remove(at: relativePath.startIndex)
+                }
+                phrefURL = URL(string: relativePath, relativeTo: self.baseURL) ?? self.baseURL
+            }
+            //let hrefURL = URL(string: href)
+            guard let hrefURL = phrefURL else { return nil }
             var status: Int?
             let statusDesc = (node[statustag].string).components(separatedBy: " ")
             if statusDesc.count > 2 {
@@ -531,10 +551,10 @@ internal extension WebDAVFileProvider {
     fileprivate func mapToFileObject(_ davResponse: DavResponse) -> WebDavFileObject {
         var href = davResponse.href
         if href.baseURL == nil {
-            href = absoluteURL(href.path)
+            href = url(of: href.path)
         }
         let name = davResponse.prop["displayname"] ?? (davResponse.hrefString.removingPercentEncoding! as NSString).lastPathComponent
-        let fileObject = WebDavFileObject(absoluteURL: href, name: name, path: href.path)
+        let fileObject = WebDavFileObject(url: href, name: name, path: href.path)
         fileObject.size = Int64(davResponse.prop["getcontentlength"] ?? "-1") ?? NSURLSessionTransferSizeUnknown
         fileObject.creationDate = self.resolve(dateString: davResponse.prop["creationdate"] ?? "")
         fileObject.modifiedDate = self.resolve(dateString: davResponse.prop["getlastmodified"] ?? "")