Improvements (#2616)

Signed-off-by: Marino Faggiana <marino@marinofaggiana.com>

Nextcloud.xcodeproj/project.pbxproj

@@ -4670,7 +4670,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 12;
+				CURRENT_PROJECT_VERSION = 13;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DEVELOPMENT_TEAM = NKUJUXUJ3B;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
@@ -4735,7 +4735,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 12;
+				CURRENT_PROJECT_VERSION = 13;
 				DEVELOPMENT_TEAM = NKUJUXUJ3B;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;

iOSClient/Data/NCManageDatabase+Directory.swift

@@ -52,9 +52,8 @@ extension NCManageDatabase {
             let realm = try Realm()
             try realm.write {
                 var addObject = tableDirectory()
-                let result = realm.objects(tableDirectory.self).filter("ocId == %@", ocId).first
-                if result != nil {
-                    addObject = result!
+                if let result = realm.objects(tableDirectory.self).filter("ocId == %@", ocId).first {
+                    addObject = result
                 } else {
                     addObject.ocId = ocId
                 }

iOSClient/Data/NCManageDatabase+Metadata.swift

@@ -532,7 +532,7 @@ extension NCManageDatabase {
     }
 
     @discardableResult
-    func updateMetadatas(_ metadatas: [tableMetadata], metadatasResult: [tableMetadata], addCompareLivePhoto: Bool = true, addExistsInLocal: Bool = false, addCompareEtagLocal: Bool = false, addDirectorySynchronized: Bool = false) -> (metadatasUpdate: [tableMetadata], metadatasLocalUpdate: [tableMetadata], metadatasDelete: [tableMetadata]) {
+    func updateMetadatas(_ metadatas: [tableMetadata], metadatasResult: [tableMetadata], addCompareLivePhoto: Bool = true, addExistsInLocal: Bool = false, addCompareEtagLocal: Bool = false) -> (metadatasUpdate: [tableMetadata], metadatasLocalUpdate: [tableMetadata], metadatasDelete: [tableMetadata]) {
 
         var ocIdsUdate: [String] = []
         var ocIdsLocalUdate: [String] = []

iOSClient/Main/NCActionCenter.swift

@@ -162,7 +162,7 @@ class NCActionCenter: NSObject, UIDocumentInteractionControllerDelegate, NCSelec
             }
         } else if metadata.directory {
             NCManageDatabase.shared.setDirectory(serverUrl: serverUrl, offline: true, account: appDelegate.account)
-            NCOperationQueue.shared.synchronizationMetadata(metadata, selector: NCGlobal.shared.selectorDownloadAllFile)
+            NCNetworking.shared.synchronizationServerUrl(serverUrl, account: metadata.account, selector: NCGlobal.shared.selectorDownloadFile)
         } else {
             NCNetworking.shared.download(metadata: metadata, selector: NCGlobal.shared.selectorLoadOffline) { _, _ in }
             if let metadataLivePhoto = NCManageDatabase.shared.getMetadataLivePhoto(metadata: metadata) {

iOSClient/NCGlobal.swift

@@ -287,7 +287,6 @@ class NCGlobal: NSObject {
     // Selector
     //
     let selectorDownloadFile                        = "downloadFile"
-    let selectorDownloadAllFile                     = "downloadAllFile"
     let selectorReadFile                            = "readFile"
     let selectorListingFavorite                     = "listingFavorite"
     let selectorLoadFileView                        = "loadFileView"

iOSClient/Networking/NCNetworking.swift

@@ -738,7 +738,7 @@ class NCNetworking: NSObject, NKCommonDelegate {
     func cancel(inBackground: Bool) async {
 
 #if !EXTENSION
-        NCOperationQueue.shared.downloadCancelAll()
+        NCOperationQueue.shared.cancelAllQueue()
 #endif
 
         NextcloudKit.shared.sessionManager.cancelAllRequests()
@@ -925,6 +925,33 @@ class NCNetworking: NSObject, NKCommonDelegate {
         }
     }
 
+    // MARK: - Synchronization ServerUrl
+
+#if !EXTENSION
+    func synchronizationServerUrl(_ serverUrl: String, account: String, selector: String) {
+
+        let options = NKRequestOptions(queue: NextcloudKit.shared.nkCommonInstance.backgroundQueue)
+
+        NextcloudKit.shared.readFileOrFolder(serverUrlFileName: serverUrl, depth: "infinity", showHiddenFiles: CCUtility.getShowHiddenFiles(), options: options) { account, files, _, error in
+            if error == .success {
+                NCManageDatabase.shared.convertFilesToMetadatas(files, useMetadataFolder: true) { metadataFolder, metadatasFolder, metadatas in
+                    NCManageDatabase.shared.addDirectory(encrypted: metadataFolder.e2eEncrypted, favorite: metadataFolder.favorite, ocId: metadataFolder.ocId, fileId: metadataFolder.fileId, etag: metadataFolder.etag, permissions: metadataFolder.permissions, serverUrl: metadataFolder.serverUrl + "/" + metadataFolder.fileName, account: metadataFolder.account)
+                    let metadatasResult = NCManageDatabase.shared.getMetadatas(predicate: NSPredicate(format: "account == %@ AND serverUrl BEGINSWITH %@ AND status == %d", account, serverUrl, NCGlobal.shared.metadataStatusNormal))
+                    NCManageDatabase.shared.updateMetadatas(metadatas, metadatasResult: metadatasResult)
+                    for metadata in metadatas {
+                        if metadata.directory {
+                            let serverUrl = metadata.serverUrl + "/" + metadata.fileName
+                            NCManageDatabase.shared.addDirectory(encrypted: metadata.e2eEncrypted, favorite: metadata.favorite, ocId: metadata.ocId, fileId: metadata.fileId, etag: metadata.etag, permissions: metadata.permissions, serverUrl: serverUrl, account: metadata.account)
+                        } else if selector == NCGlobal.shared.selectorDownloadFile, NCManageDatabase.shared.isDownloadMetadata(metadata, download: true) {
+                            NCOperationQueue.shared.download(metadata: metadata, selector: selector)
+                        }
+                    }
+                }
+            }
+        }
+    }
+#endif
+
     // MARK: - Search
 
     /// WebDAV search
@@ -1342,8 +1369,9 @@ class NCNetworking: NSObject, NKCommonDelegate {
             if error == .success && metadata.account == account {
                 NCManageDatabase.shared.setMetadataFavorite(ocId: metadata.ocId, favorite: favorite)
 #if !EXTENSION
-                if favorite {
-                    NCOperationQueue.shared.synchronizationMetadata(metadata, selector: NCGlobal.shared.selectorReadFile)
+                if favorite, metadata.directory {
+                    let serverUrl = metadata.serverUrl + "/" + metadata.fileName
+                    self.synchronizationServerUrl(serverUrl, account: metadata.account, selector: "")
                 }
 #endif
                 NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterFavoriteFile, userInfo: ["ocId": ocId, "serverUrl": metadata.serverUrl])
@@ -1366,8 +1394,9 @@ class NCNetworking: NSObject, NKCommonDelegate {
                 NCManageDatabase.shared.updateMetadatasFavorite(account: account, metadatas: metadatas)
                 if selector != NCGlobal.shared.selectorListingFavorite {
 #if !EXTENSION
-                    for metadata in metadatas {
-                        NCOperationQueue.shared.synchronizationMetadata(metadata, selector: selector)
+                    for metadata in metadatas where metadata.directory {
+                        let serverUrl = metadata.serverUrl + "/" + metadata.fileName
+                        self.synchronizationServerUrl(serverUrl, account: metadata.account, selector: "")
                     }
 #endif
                 }

iOSClient/Networking/NCOperationQueue.swift

@@ -32,7 +32,6 @@ import NextcloudKit
     }()
 
     private var downloadQueue = Queuer(name: "downloadQueue", maxConcurrentOperationCount: 5, qualityOfService: .default)
-    private let synchronizationQueue = Queuer(name: "synchronizationQueue", maxConcurrentOperationCount: 1, qualityOfService: .default)
     private let downloadThumbnailQueue = Queuer(name: "downloadThumbnailQueue", maxConcurrentOperationCount: 10, qualityOfService: .default)
     private let downloadThumbnailActivityQueue = Queuer(name: "downloadThumbnailActivityQueue", maxConcurrentOperationCount: 10, qualityOfService: .default)
     private let downloadAvatarQueue = Queuer(name: "downloadAvatarQueue", maxConcurrentOperationCount: 10, qualityOfService: .default)
@@ -41,7 +40,6 @@ import NextcloudKit
 
     @objc func cancelAllQueue() {
         downloadCancelAll()
-        synchronizationCancelAll()
         downloadThumbnailCancelAll()
         downloadThumbnailActivityCancelAll()
         downloadAvatarCancelAll()
@@ -73,19 +71,6 @@ import NextcloudKit
         return false
     }
 
-    // MARK: - Synchronization
-
-    func synchronizationMetadata(_ metadata: tableMetadata, selector: String) {
-        for case let operation as NCOperationSynchronization in synchronizationQueue.operations where operation.metadata.ocId == metadata.ocId {
-            return
-        }
-        synchronizationQueue.addOperation(NCOperationSynchronization(metadata: metadata, selector: selector))
-    }
-
-    func synchronizationCancelAll() {
-        synchronizationQueue.cancelAll()
-    }
-
     // MARK: - Download Thumbnail
 
     func downloadThumbnail(metadata: tableMetadata, placeholder: Bool, cell: UIView?, view: UIView?) {
@@ -229,114 +214,6 @@ class NCOperationDownload: ConcurrentOperation {
 
 // MARK: -
 
-class NCOperationSynchronization: ConcurrentOperation {
-
-    var metadata: tableMetadata
-    var selector: String
-    var download: Bool
-
-    init(metadata: tableMetadata, selector: String) {
-        self.metadata = tableMetadata.init(value: metadata)
-        self.selector = selector
-        if selector == NCGlobal.shared.selectorDownloadFile || selector == NCGlobal.shared.selectorDownloadAllFile {
-            self.download = true
-        } else {
-            self.download = false
-        }
-    }
-
-    override func start() {
-        if isCancelled {
-            self.finish()
-        } else {
-            if metadata.directory {
-
-                let serverUrl = metadata.serverUrl + "/" + metadata.fileName
-                let directory = NCManageDatabase.shared.getTableDirectory(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", metadata.account, serverUrl))
-
-                NextcloudKit.shared.readFileOrFolder(serverUrlFileName: serverUrl, depth: "0", showHiddenFiles: CCUtility.getShowHiddenFiles()) { account, files, _, error in
-
-                    if (error == .success) && (directory?.etag != files.first?.etag || self.selector == NCGlobal.shared.selectorDownloadAllFile) {
-
-                        let options = NKRequestOptions(queue: NextcloudKit.shared.nkCommonInstance.backgroundQueue)
-
-                        NextcloudKit.shared.readFileOrFolder(serverUrlFileName: serverUrl, depth: "1", showHiddenFiles: CCUtility.getShowHiddenFiles(), options: options) { account, files, _, error in
-
-                            if error == .success {
-
-                                NCManageDatabase.shared.convertFilesToMetadatas(files, useMetadataFolder: true) { metadataFolder, _, metadatas in
-
-                                    let metadatasResult = NCManageDatabase.shared.getMetadatas(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@ AND status == %d", account, serverUrl, NCGlobal.shared.metadataStatusNormal))
-
-                                    if self.selector == NCGlobal.shared.selectorDownloadAllFile {
-
-                                        NCManageDatabase.shared.updateMetadatas(metadatas, metadatasResult: metadatasResult)
-
-                                        for metadata in metadatas {
-                                            if metadata.directory {
-                                                NCOperationQueue.shared.synchronizationMetadata(metadata, selector: self.selector)
-                                            } else {
-                                                if NCManageDatabase.shared.isDownloadMetadata(metadata, download: true) {
-                                                    NCOperationQueue.shared.download(metadata: metadata, selector: self.selector)
-                                                }
-                                            }
-                                        }
-
-                                    } else {
-
-                                        let metadatasChanged = NCManageDatabase.shared.updateMetadatas(metadatas, metadatasResult: metadatasResult, addExistsInLocal: self.download, addCompareEtagLocal: true, addDirectorySynchronized: true)
-
-                                        for metadata in metadatasChanged.metadatasUpdate {
-                                            if metadata.directory {
-                                                NCOperationQueue.shared.synchronizationMetadata(metadata, selector: self.selector)
-                                            }
-                                        }
-
-                                        for metadata in metadatasChanged.metadatasLocalUpdate {
-                                            NCOperationQueue.shared.download(metadata: metadata, selector: self.selector)
-                                        }
-                                    }
-
-                                    // Update etag directory
-                                    NCManageDatabase.shared.addDirectory(encrypted: metadataFolder.e2eEncrypted, favorite: metadataFolder.favorite, ocId: metadataFolder.ocId, fileId: metadataFolder.fileId, etag: metadataFolder.etag, permissions: metadataFolder.permissions, serverUrl: serverUrl, account: metadataFolder.account)
-                                }
-
-                            } else if error.errorCode == NCGlobal.shared.errorResourceNotFound && self.metadata.directory {
-                                NCManageDatabase.shared.deleteDirectoryAndSubDirectory(serverUrl: self.metadata.serverUrl, account: self.metadata.account)
-                            }
-
-                            self.finish()
-                        }
-
-                    } else {
-
-                        let metadatas = NCManageDatabase.shared.getMetadatas(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl))
-                        for metadata in metadatas {
-                            if metadata.directory {
-                                NCOperationQueue.shared.synchronizationMetadata(metadata, selector: self.selector)
-                            } else {
-                                if NCManageDatabase.shared.isDownloadMetadata(metadata, download: self.download) {
-                                    NCOperationQueue.shared.download(metadata: metadata, selector: self.selector)
-                                }
-                            }
-                        }
-
-                        self.finish()
-                    }
-                }
-
-            } else {
-                if NCManageDatabase.shared.isDownloadMetadata(metadata, download: self.download) {
-                    NCOperationQueue.shared.download(metadata: metadata, selector: self.selector)
-                }
-                self.finish()
-            }
-        }
-    }
-}
-
-// MARK: -
-
 class NCOperationDownloadThumbnail: ConcurrentOperation {
 
     var metadata: tableMetadata

iOSClient/Networking/NCService.swift

@@ -293,7 +293,8 @@ class NCService: NSObject {
                 guard let metadata = NCManageDatabase.shared.getMetadataFromOcId(directory.ocId) else {
                     continue
                 }
-                NCOperationQueue.shared.synchronizationMetadata(metadata, selector: NCGlobal.shared.selectorDownloadFile)
+                let serverUrl = metadata.serverUrl + "/" + metadata.fileName
+                NCNetworking.shared.synchronizationServerUrl(serverUrl, account: metadata.account, selector: NCGlobal.shared.selectorDownloadFile)
             }
         }
 
@@ -303,7 +304,9 @@ class NCService: NSObject {
             guard let metadata = NCManageDatabase.shared.getMetadataFromOcId(file.ocId) else {
                 continue
             }
-            NCOperationQueue.shared.synchronizationMetadata(metadata, selector: NCGlobal.shared.selectorDownloadFile)
+            if NCManageDatabase.shared.isDownloadMetadata(metadata, download: true) {
+                NCOperationQueue.shared.download(metadata: metadata, selector: NCGlobal.shared.selectorDownloadFile)
+            }
         }
     }
 }