Merge remote-tracking branch 'customization/nmc/2023-localization'

Author: Nextcloud GmbH

File Provider Extension/FileProviderData.swift

@@ -173,7 +173,7 @@ class FileProviderData: NSObject {
 
         if error == .success {
             if let metadata = await NCManageDatabase.shared.getMetadataFromOcIdAsync(ocId) {
-                await NCManageDatabase.shared.addLocalFilesAsync(metadatas: [metadata])
+                await NCManageDatabase.shared.addLocalFileAsync(metadata: metadata)
             }
         }
 

iOSClient/Data/NCManageDatabase+LocalFile.swift

@@ -29,50 +29,35 @@ extension NCManageDatabase {
 
     // MARK: - Realm Write
 
-    /// Adds or updates multiple local file entries corresponding to the given metadata array.
-    /// Uses async Realm read + single write transaction. Assumes `tableLocalFile` has a primary key.
     /// - Parameters:
-    ///   - metadatas: Array of `tableMetadata` to map into `tableLocalFile`.
-    ///   - offline: Optional override for the `offline` flag applied to all items.
-    func addLocalFilesAsync(metadatas: [tableMetadata], offline: Bool? = nil) async {
-        guard !metadatas.isEmpty else {
-            return
-        }
-
-        // Extract ocIds for efficient lookup
-        let ocIds = metadatas.compactMap { $0.ocId }
-        guard !ocIds.isEmpty else {
-            return
+    ///   - metadata: The `tableMetadata` containing file details.
+    ///   - offline: Optional flag to mark the file as available offline.
+    /// - Returns: Nothing. Realm write is performed asynchronously.
+    func addLocalFileAsync(metadata: tableMetadata, offline: Bool? = nil) async {
+        // Read (non-blocking): safely detach from Realm thread
+        let existing: tableLocalFile? = performRealmRead { realm in
+            realm.objects(tableLocalFile.self)
+                .filter(NSPredicate(format: "ocId == %@", metadata.ocId))
+                .first
+                .map { tableLocalFile(value: $0) }
         }
 
-        // Preload existing entries to avoid creating duplicates
-        let existingMap: [String: tableLocalFile] = await core.performRealmReadAsync { realm in
-                let existing = realm.objects(tableLocalFile.self)
-                    .filter(NSPredicate(format: "ocId IN %@", ocIds))
-                return Dictionary(uniqueKeysWithValues:
-                    existing.map { ($0.ocId, tableLocalFile(value: $0)) } // detached copy via value init
-                )
-            } ?? [:]
+        await performRealmWriteAsync { realm in
+            let addObject = existing ?? tableLocalFile()
 
-        await core.performRealmWriteAsync { realm in
-            for metadata in metadatas {
-                // Reuse existing object or create a new one
-                let local = existingMap[metadata.ocId] ?? tableLocalFile()
-
-                local.account = metadata.account
-                local.etag = metadata.etag
-                local.exifDate = NSDate()
-                local.exifLatitude = "-1"
-                local.exifLongitude = "-1"
-                local.ocId = metadata.ocId
-                local.fileName = metadata.fileName
-
-                if let offline {
-                    local.offline = offline
-                }
+            addObject.account = metadata.account
+            addObject.etag = metadata.etag
+            addObject.exifDate = NSDate()
+            addObject.exifLatitude = "-1"
+            addObject.exifLongitude = "-1"
+            addObject.ocId = metadata.ocId
+            addObject.fileName = metadata.fileName
 
-                realm.add(local, update: .all)
+            if let offline {
+                addObject.offline = offline
             }
+
+            realm.add(addObject, update: .all)
         }
     }
 

iOSClient/NCBackgroundLocationUploadManager.swift

@@ -102,7 +102,6 @@ class NCBackgroundLocationUploadManager: NSObject, CLLocationManagerDelegate {
     }
 
     func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
-        // Must work only in background
         guard isAppInBackground else {
             return
         }
@@ -119,6 +118,14 @@ class NCBackgroundLocationUploadManager: NSObject, CLLocationManagerDelegate {
 
         Task.detached {
             await NCAutoUpload.shared.autoUploadBackgroundSync()
+        if database.openRealmBackground() {
+            let appDelegate = (UIApplication.shared.delegate as? AppDelegate)!
+            let location = locations.last
+            nkLog(tag: self.global.logTagLocation, emoji: .start, message: "Triggered by location change: \(location?.coordinate.latitude ?? 0), \(location?.coordinate.longitude ?? 0)")
+            
+            Task.detached {
+                await NCAutoUpload.shared.autoUploadBackgroundSync()
+            }
         }
     }
 

iOSClient/NCGlobal.swift

@@ -326,7 +326,6 @@ final class NCGlobal: Sendable {
     let metadataStatusForScreenAwake            = [-1, -2, 1, 2]
     let metadataStatusHideInView                = [1, 2, 3, 11]
     let metadataStatusWaitWebDav                = [10, 11, 12, 13, 14, 15]
-    let metadataStatusTransfers                 = [-2, -3, 2, 3, 10, 11, 12, 13, 14, 15]
 
     let metadatasStatusInWaiting                = [-1, 1, 10, 11, 12, 13, 14, 15]
     let metadatasStatusInProgress               = [-2, 2]
@@ -412,6 +411,8 @@ final class NCGlobal: Sendable {
     let notificationCenterFavoriteFile                          = "favoriteFile"                    // userInfo: ocId, serverUrl
     let notificationCenterFileExists                            = "fileExists"                      // userInfo: ocId, fileExists
 
+    let notificationCenterRenameFile                            = "renameFile"                      // userInfo: serverUrl, account, error
+
     let notificationCenterMenuSearchTextPDF                     = "menuSearchTextPDF"
     let notificationCenterMenuGotToPageInPDF                    = "menuGotToPageInPDF"
 

iOSClient/Networking/E2EE/NCNetworkingE2EEUpload.swift

@@ -219,6 +219,8 @@ class NCNetworkingE2EEUpload: NSObject {
             await self.database.addMetadataAsync(metadata)
             await self.database.addLocalFilesAsync(metadatas: [metadata])
             await self.database.addLocalFileAsync(metadata: metadata)
+//            await self.database.addLocalFileAsync(metadata: metadata)
+
             utility.createImageFileFrom(metadata: metadata)
 
             await NCNetworking.shared.transferDispatcher.notifyAllDelegates { delegate in

iOSClient/Networking/NCConfigServer.swift

@@ -1,6 +1,25 @@
-// SPDX-FileCopyrightText: Nextcloud GmbH
-// SPDX-FileCopyrightText: 2022 Marino Faggiana
-// SPDX-License-Identifier: GPL-3.0-or-later
+//
+//  NCConfigServer.swift
+//  Nextcloud
+//
+//  Created by Marino Faggiana on 05/12/22.
+//  Copyright © 2022 Marino Faggiana. All rights reserved.
+//
+//  Author Marino Faggiana <marino.faggiana@nextcloud.com>
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
 
 import Foundation
 import UIKit

iOSClient/Networking/NCNetworking+Download.swift

@@ -1,6 +1,25 @@
-// SPDX-FileCopyrightText: Nextcloud GmbH
-// SPDX-FileCopyrightText: 2024 Marino Faggiana
-// SPDX-License-Identifier: GPL-3.0-or-later
+//
+//  NCNetworking+Download.swift
+//  Nextcloud
+//
+//  Created by Marino Faggiana on 07/02/24.
+//  Copyright © 2024 Marino Faggiana. All rights reserved.
+//
+//  Author Marino Faggiana <marino.faggiana@nextcloud.com>
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
 
 import UIKit
 import NextcloudKit
@@ -301,23 +320,89 @@ extension NCNetworking {
                     await NCManageDatabase.shared.clearMetadatasSessionAsync(metadatas: metadatas)
                 }
             } else {
-                await NCManageDatabase.shared.setOffLocalFileAsync(ocId: metadata.ocId)
+                nkLog(error: "Downloaded file: " + metadata.serverUrlFileName + ", result: error \(error.errorCode)")
+
+                if error.errorCode == NCGlobal.shared.errorResourceNotFound {
+                    self.utilityFileSystem.removeFile(atPath: self.utilityFileSystem.getDirectoryProviderStorageOcId(metadata.ocId, userId: metadata.userId, urlBase: metadata.urlBase))
+
+                    await NCManageDatabase.shared.deleteLocalFileAsync(id: metadata.ocId)
+                    await NCManageDatabase.shared.deleteMetadataAsync(id: metadata.ocId)
+                } else if error.errorCode == NSURLErrorCancelled || error.errorCode == self.global.errorRequestExplicityCancelled {
+                    if let metadata = await NCManageDatabase.shared.setMetadataSessionAsync(ocId: metadata.ocId,
+                                                                                            session: "",
+                                                                                            sessionTaskIdentifier: 0,
+                                                                                            sessionError: "",
+                                                                                            selector: "",
+                                                                                            status: self.global.metadataStatusNormal) {
+                        await self.transferDispatcher.notifyAllDelegates { delegate in
+                                delegate.transferChange(status: self.global.networkingStatusDownloadCancel,
+                                                        metadata: metadata,
+                                                        error: .success)
+                            }
+                    }
+                } else {
+                    if let metadata = await NCManageDatabase.shared.setMetadataSessionAsync(ocId: metadata.ocId,
+                                                                                            session: "",
+                                                                                            sessionTaskIdentifier: 0,
+                                                                                            sessionError: "",
+                                                                                            selector: "",
+                                                                                            status: self.global.metadataStatusNormal) {
+
+                        await self.transferDispatcher.notifyAllDelegates { delegate in
+                            delegate.transferChange(status: NCGlobal.shared.networkingStatusDownloaded,
+                                                    metadata: metadata,
+                                                    error: error)
+                        }
+                    }
+                }
+                await NCManageDatabase.shared.updateBadge()
             }
-        } else if metadata.directory {
-            await NCManageDatabase.shared.cleanTablesOcIds(account: metadata.account, userId: metadata.userId, urlBase: metadata.urlBase)
-            await NCManageDatabase.shared.setDirectoryAsync(serverUrl: metadata.serverUrlFileName, offline: true, metadata: metadata)
-            await NCNetworking.shared.synchronizationDownload(account: metadata.account, serverUrl: metadata.serverUrlFileName, userId: metadata.userId, urlBase: metadata.urlBase, metadatasInDownload: nil)
-        } else {
-            var metadatasSynchronizationOffline: [tableMetadata] = []
-            metadatasSynchronizationOffline.append(metadata)
-            if let metadata = await NCManageDatabase.shared.getMetadataLivePhotoAsync(metadata: metadata) {
-                metadatasSynchronizationOffline.append(metadata)
+        }
+    }
+
+    // MARK: - Download NextcloudKitDelegate
+
+    func downloadingFinish(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        if let httpResponse = (downloadTask.response as? HTTPURLResponse) {
+            if httpResponse.statusCode >= 200 && httpResponse.statusCode < 300,
+               let url = downloadTask.currentRequest?.url,
+               var serverUrl = url.deletingLastPathComponent().absoluteString.removingPercentEncoding {
+                let fileName = url.lastPathComponent
+                if serverUrl.hasSuffix("/") { serverUrl = String(serverUrl.dropLast()) }
+                if let metadata = NCManageDatabase.shared.getMetadata(predicate: NSPredicate(format: "serverUrl == %@ AND fileName == %@", serverUrl, fileName)) {
+                    let destinationFilePath = utilityFileSystem.getDirectoryProviderStorageOcId(metadata.ocId, fileName: metadata.fileName, userId: metadata.userId, urlBase: metadata.urlBase)
+                    do {
+                        if FileManager.default.fileExists(atPath: destinationFilePath) {
+                            try FileManager.default.removeItem(atPath: destinationFilePath)
+                        }
+                        try FileManager.default.copyItem(at: location, to: NSURL.fileURL(withPath: destinationFilePath))
+                    } catch {
+                        print(error)
+                    }
+                }
             }
-            await NCManageDatabase.shared.addLocalFilesAsync(metadatas: [metadata], offline: true)
-            for metadata in metadatasSynchronizationOffline {
-                await NCManageDatabase.shared.setMetadataSessionInWaitDownloadAsync(ocId: metadata.ocId,
-                                                                                    session: NCNetworking.shared.sessionDownloadBackground,
-                                                                                    selector: NCGlobal.shared.selectorSynchronizationOffline)
+        }
+    }
+
+    func downloadProgress(_ progress: Float,
+                          totalBytes: Int64,
+                          totalBytesExpected: Int64,
+                          fileName: String,
+                          serverUrl: String,
+                          session: URLSession,
+                          task: URLSessionTask) {
+
+        Task {
+            guard await progressQuantizer.shouldEmit(serverUrlFileName: serverUrl + "/" + fileName, fraction: Double(progress)) else {
+                return
+            }
+            await NCManageDatabase.shared.setMetadataProgress(fileName: fileName, serverUrl: serverUrl, taskIdentifier: task.taskIdentifier, progress: Double(progress))
+            await self.transferDispatcher.notifyAllDelegates { delegate in
+                delegate.transferProgressDidUpdate(progress: progress,
+                                                   totalBytes: totalBytes,
+                                                   totalBytesExpected: totalBytesExpected,
+                                                   fileName: fileName,
+                                                   serverUrl: serverUrl)
             }
         }
 
@@ -327,3 +412,40 @@ extension NCNetworking {
         }
     }
 }
+
+class NCOperationDownload: ConcurrentOperation, @unchecked Sendable {
+    var metadata: tableMetadata
+    var selector: String
+
+    init(metadata: tableMetadata, selector: String) {
+        self.metadata = tableMetadata.init(value: metadata)
+        self.selector = selector
+    }
+
+    override func start() {
+        guard !isCancelled else { return self.finish() }
+
+        metadata.session = NCNetworking.shared.sessionDownload
+        metadata.sessionError = ""
+        metadata.sessionSelector = selector
+        metadata.sessionTaskIdentifier = 0
+        metadata.status = NCGlobal.shared.metadataStatusWaitDownload
+
+//        let metadata = NCManageDatabase.shared.addMetadata(metadata)
+
+//        NCNetworking.shared.download(metadata: metadata, withNotificationProgressTask: true) {
+//        } completion: { _, _ in
+//            self.finish()
+//        }
+        Task {
+            await download(withSelector: self.selector)
+        }
+    }
+    
+    private func download(withSelector selector: String = "") async {
+        await NCNetworking.shared.downloadFile(metadata: metadata) { _ in
+            self.finish()
+        } taskHandler: { _ in }
+
+    }
+}

iOSClient/Networking/NCNetworking+LivePhoto.swift

@@ -1,6 +1,25 @@
-// SPDX-FileCopyrightText: Nextcloud GmbH
-// SPDX-FileCopyrightText: 2024 Marino Faggiana
-// SPDX-License-Identifier: GPL-3.0-or-later
+//
+//  NCNetworking+LivePhoto.swift
+//  Nextcloud
+//
+//  Created by Marino Faggiana on 07/02/24.
+//  Copyright © 2024 Marino Faggiana. All rights reserved.
+//
+//  Author Marino Faggiana <marino.faggiana@nextcloud.com>
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
 
 import UIKit
 import NextcloudKit