Merge branch 'release/2.2.5'

Cryptomator/Purchase/PurchaseAlert.swift

@@ -23,10 +23,16 @@ enum PurchaseAlert {
 		return showAlert(title: title, message: message, on: presentingViewController)
 	}
 
-	static func showForNoRestorablePurchases(on presentingViewController: UIViewController) -> Promise<Void> {
-		return showAlert(title: LocalizedString.getValue("purchase.restorePurchase.fullVersionNotFound.alert.title"),
-		                 message: LocalizedString.getValue("purchase.restorePurchase.fullVersionNotFound.alert.message"),
-		                 on: presentingViewController)
+	static func showForNoRestorablePurchases(on presentingViewController: UIViewController, eligibleForUpgrade: Bool) -> Promise<Void> {
+		if eligibleForUpgrade {
+			return showAlert(title: LocalizedString.getValue("purchase.restorePurchase.eligibleForUpgrade.alert.title"),
+			                 message: LocalizedString.getValue("purchase.restorePurchase.eligibleForUpgrade.alert.message"),
+			                 on: presentingViewController)
+		} else {
+			return showAlert(title: LocalizedString.getValue("purchase.restorePurchase.fullVersionNotFound.alert.title"),
+			                 message: LocalizedString.getValue("purchase.restorePurchase.fullVersionNotFound.alert.message"),
+			                 on: presentingViewController)
+		}
 	}
 
 	private static func showAlert(title: String, message: String, on presentingViewController: UIViewController) -> Promise<Void> {

Cryptomator/Purchase/PurchaseCoordinator.swift

@@ -66,7 +66,7 @@ class PurchaseCoordinator: Coordinator {
 				self.unlockedPro()
 			}
 		case .noRestorablePurchases:
-			_ = PurchaseAlert.showForNoRestorablePurchases(on: navigationController)
+			_ = PurchaseAlert.showForNoRestorablePurchases(on: navigationController, eligibleForUpgrade: UpgradeChecker.shared.isEligibleForUpgrade())
 		}
 	}
 

Cryptomator/Settings/SettingsViewModel.swift

@@ -78,7 +78,6 @@ class SettingsViewModel: TableViewModel<SettingsSection> {
 		return elements
 	}
 
-	private let cacheManager: FileProviderCacheManager
 	private let cacheSizeCellViewModel = LoadingWithLabelCellViewModel(title: LocalizedString.getValue("settings.cacheSize"))
 	private let clearCacheButtonCellViewModel = ButtonCellViewModel<SettingsButtonAction>(action: .clearCache, title: LocalizedString.getValue("settings.clearCache"), isEnabled: false)
 
@@ -93,9 +92,8 @@ class SettingsViewModel: TableViewModel<SettingsSection> {
 	private var subscribers = Set<AnyCancellable>()
 	private lazy var showDebugModeWarningPublisher = PassthroughSubject<Void, Never>()
 
-	init(cacheManager: FileProviderCacheManager = FileProviderCacheManager(), cryptomatorSetttings: CryptomatorSettings = CryptomatorUserDefaults.shared, fileProviderConnector: FileProviderConnector = FileProviderXPCConnector.shared) {
-		self.cacheManager = cacheManager
-		self.cryptomatorSettings = cryptomatorSetttings
+	init(cryptomatorSettings: CryptomatorSettings = CryptomatorUserDefaults.shared, fileProviderConnector: FileProviderConnector = FileProviderXPCConnector.shared) {
+		self.cryptomatorSettings = cryptomatorSettings
 		self.fileProviderConnector = fileProviderConnector
 	}
 
@@ -107,7 +105,11 @@ class SettingsViewModel: TableViewModel<SettingsSection> {
 				self.clearCacheButtonCellViewModel.isEnabled.value = false
 			}
 		}
-		return cacheManager.getTotalLocalCacheSizeInBytes().then { totalCacheSizeInBytes -> Void in
+		let getXPCPromise: Promise<XPC<CacheManaging>> = fileProviderConnector.getXPC(serviceName: .cacheManaging, domain: nil)
+		return getXPCPromise.then { xpc in
+			xpc.proxy.getLocalCacheSizeInBytes()
+		}.then { receivedCacheSizeInBytes -> Void in
+			let totalCacheSizeInBytes = receivedCacheSizeInBytes?.intValue ?? 0
 			loading = false
 			self.cacheSizeCellViewModel.isLoading.value = false
 			self.clearCacheButtonCellViewModel.isEnabled.value = totalCacheSizeInBytes > 0
@@ -117,7 +119,10 @@ class SettingsViewModel: TableViewModel<SettingsSection> {
 	}
 
 	func clearCache() -> Promise<Void> {
-		return cacheManager.clearCache().then {
+		let getXPCPromise: Promise<XPC<CacheManaging>> = fileProviderConnector.getXPC(serviceName: .cacheManaging, domain: nil)
+		return getXPCPromise.then { xpc in
+			xpc.proxy.clearCache()
+		}.then {
 			self.refreshCacheSize()
 		}
 	}
@@ -152,7 +157,7 @@ class SettingsViewModel: TableViewModel<SettingsSection> {
 	}
 
 	private func notifyFileProviderAboutLogLevelUpdate() {
-		let getXPCPromise: Promise<XPC<LogLevelUpdating>> = fileProviderConnector.getXPC(serviceName: LogLevelUpdatingService.name, domain: nil)
+		let getXPCPromise: Promise<XPC<LogLevelUpdating>> = fileProviderConnector.getXPC(serviceName: .logLevelUpdating, domain: nil)
 		getXPCPromise.then { xpc in
 			xpc.proxy.logLevelUpdated()
 		}.always {

Cryptomator/VaultDetail/ChangePassword/ChangePasswordViewModel.swift

@@ -169,7 +169,7 @@ class ChangePasswordViewModel: TableViewModel<ChangePasswordSection>, ChangePass
 
 	private func lockVault() -> Promise<Void> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vaultAccount.vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 		return getXPCPromise.then { xpc -> Void in
 			xpc.proxy.lockVault(domainIdentifier: domainIdentifier)
 		}.always {

Cryptomator/VaultDetail/KeepUnlocked/VaultKeepUnlockedViewModel.swift

@@ -82,7 +82,7 @@ class VaultKeepUnlockedViewModel: TableViewModel<VaultKeepUnlockedSection>, Vaul
 
 	func gracefulLockVault() -> Promise<Void> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 		return getXPCPromise.then { xpc in
 			xpc.proxy.gracefulLockVault(domainIdentifier: domainIdentifier)
 		}.then {
@@ -118,7 +118,7 @@ class VaultKeepUnlockedViewModel: TableViewModel<VaultKeepUnlockedSection>, Vaul
 
 	private func getVaultIsUnlocked() -> Promise<Bool> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 		return getXPCPromise.then { xpc in
 			return xpc.proxy.getIsUnlockedVault(domainIdentifier: domainIdentifier)
 		}.always {

Cryptomator/VaultDetail/MoveVault/MoveVaultViewModel.swift

@@ -73,7 +73,7 @@ class MoveVaultViewModel: ChooseFolderViewModel, MoveVaultViewModelProtocol {
 
 	private func lockVault() -> Promise<Void> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vaultInfo.vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 		return getXPCPromise.then { xpc -> Void in
 			xpc.proxy.lockVault(domainIdentifier: domainIdentifier)
 			self.fileProviderConnector.invalidateXPC(xpc)

Cryptomator/VaultDetail/VaultDetailViewModel.swift

@@ -215,7 +215,7 @@ class VaultDetailViewModel: VaultDetailViewModelProtocol {
 
 	func lockVault() -> Promise<Void> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 
 		return getXPCPromise.then { xpc -> Void in
 			xpc.proxy.lockVault(domainIdentifier: domainIdentifier)
@@ -225,7 +225,7 @@ class VaultDetailViewModel: VaultDetailViewModelProtocol {
 
 	func refreshVaultStatus() -> Promise<Void> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 		switchCellViewModel?.isOn.value = biometricalUnlockEnabled
 		return getXPCPromise.then { xpc in
 			return wrap { handler in

Cryptomator/VaultList/VaultCellViewModel.swift

@@ -42,7 +42,7 @@ class VaultCellViewModel: TableViewCellViewModel, VaultCellViewModelProtocol {
 
 	func lockVault() -> Promise<Void> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vault.vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 		return getXPCPromise.then { xpc in
 			xpc.proxy.lockVault(domainIdentifier: domainIdentifier)
 		}.then {

Cryptomator/VaultList/VaultListViewModel.swift

@@ -93,7 +93,7 @@ class VaultListViewModel: ViewModel, VaultListViewModelProtocol {
 
 	func lockVault(_ vaultInfo: VaultInfo) -> Promise<Void> {
 		let domainIdentifier = NSFileProviderDomainIdentifier(vaultInfo.vaultUID)
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domainIdentifier: domainIdentifier)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domainIdentifier: domainIdentifier)
 		return getXPCPromise.then { xpc in
 			xpc.proxy.lockVault(domainIdentifier: domainIdentifier)
 		}.then {
@@ -104,7 +104,7 @@ class VaultListViewModel: ViewModel, VaultListViewModelProtocol {
 	}
 
 	func refreshVaultLockStates() -> Promise<Void> {
-		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: VaultLockingService.name, domain: nil)
+		let getXPCPromise: Promise<XPC<VaultLocking>> = fileProviderConnector.getXPC(serviceName: .vaultLocking, domain: nil)
 
 		return getXPCPromise.then { xpc in
 			return wrap { handler in

CryptomatorCommon/Sources/CryptomatorCommonCore/FileProviderXPC/CacheManaging.swift

@@ -0,0 +1,99 @@
+//
+//  CacheManaging.swift
+//  CryptomatorCommonCore
+//
+//  Created by Philipp Schmid on 10.05.22.
+//  Copyright © 2022 Skymatic GmbH. All rights reserved.
+//
+
+import FileProvider
+import Foundation
+import Promises
+
+@objc public protocol CacheManaging: NSFileProviderServiceSource {
+	/**
+	 Evicts the local file belonging to the given `identifier` from the cache.
+
+	 A file gets evicted from the cache only if there is no pending (or failed) upload for that file.
+
+	 `Reply` will be called with `nil` if the call was successful, otherwise the error will be passed as an `NSError`.
+	 "Because communication over XPC is asynchronous, all methods in the protocol must have a return type of void. If you need to return data, you can define a reply block [...]" see: https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPSystemStartup/Chapters/CreatingXPCServices.html
+	 */
+	func evictFileFromCache(with identifier: NSFileProviderItemIdentifier, reply: @escaping (NSError?) -> Void)
+
+	/**
+	 Clears the entire cache of all FileProviderDomains.
+
+	 Only files that do not have a pending or failed upload are removed from the cache.
+
+	 `Reply` will be called with `nil` if the call was successful, otherwise the error will be passed as an `NSError`.
+	 "Because communication over XPC is asynchronous, all methods in the protocol must have a return type of void. If you need to return data, you can define a reply block [...]" see: https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPSystemStartup/Chapters/CreatingXPCServices.html
+	 */
+	func clearCache(reply: @escaping (NSError?) -> Void)
+
+	/**
+	 Returns the total local cache size in bytes currently used by all FileProviderDomains.
+
+	 - Note: Only files that do not have a pending or failed upload are counted towards the cache.
+
+	 `Reply` will be called with the size of the local cache size in bytes if the call was successful, otherwise the error will be passed as an `NSError`.
+	 "Because communication over XPC is asynchronous, all methods in the protocol must have a return type of void. If you need to return data, you can define a reply block [...]" see: https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPSystemStartup/Chapters/CreatingXPCServices.html
+	 */
+	func getLocalCacheSizeInBytes(reply: @escaping (NSNumber?, NSError?) -> Void)
+}
+
+public extension CacheManaging {
+	/**
+	 Evicts the local file belonging to the given `identifier` from the cache.
+
+	 A file gets evicted from the cache only if there is no pending (or failed) upload for that file.
+	 */
+	func evictFileFromCache(with itemIdentifier: NSFileProviderItemIdentifier) -> Promise<Void> {
+		return wrap {
+			self.evictFileFromCache(with: itemIdentifier, reply: $0)
+		}.then { error -> Void in
+			if let error = error {
+				throw error
+			}
+		}
+	}
+
+	func evictFilesFromCache(with itemIdentifiers: [NSFileProviderItemIdentifier]) -> Promise<Void> {
+		guard let itemIdentifier = itemIdentifiers.first else {
+			return Promise(())
+		}
+		return evictFileFromCache(with: itemIdentifier).then {
+			self.evictFilesFromCache(with: Array(itemIdentifiers.dropFirst()))
+		}
+	}
+
+	/**
+	 Clears the entire cache of all FileProviderDomains.
+
+	 Only files that do not have a pending or failed upload are removed from the cache.
+	 */
+	func clearCache() -> Promise<Void> {
+		return wrap {
+			self.clearCache(reply: $0)
+		}.then { error -> Void in
+			if let error = error {
+				throw error
+			}
+		}
+	}
+
+	/**
+	 Returns the total local cache size in bytes currently used by all FileProviderDomains.
+
+	 - Note: Only files that do not have a pending or failed upload are counted towards the cache.
+	 */
+	func getLocalCacheSizeInBytes() -> Promise<NSNumber?> {
+		return wrap {
+			self.getLocalCacheSizeInBytes(reply: $0)
+		}
+	}
+}
+
+public extension NSFileProviderServiceName {
+	static let cacheManaging = NSFileProviderServiceName("org.cryptomator.ios.cache-managing")
+}

CryptomatorCommon/Sources/CryptomatorCommonCore/FileProviderXPC/FileProviderConnector.swift

@@ -51,15 +51,6 @@ public class FileProviderXPCConnector: FileProviderConnector {
 
 	public static let shared = FileProviderXPCConnector()
 
-	public func getProxy<T>(serviceName: NSFileProviderServiceName, domainIdentifier: NSFileProviderDomainIdentifier) -> Promise<T> {
-		return NSFileProviderManager.getDomains().then { domains in
-			guard let domain = domains.first(where: { $0.identifier == domainIdentifier }) else {
-				throw FileProviderXPCConnectorError.domainNotFound
-			}
-			return self.getProxy(serviceName: serviceName, domain: domain)
-		}
-	}
-
 	public func getXPC<T>(serviceName: NSFileProviderServiceName, domain: NSFileProviderDomain?) -> Promise<XPC<T>> {
 		var url = NSFileProviderManager.default.documentStorageURL
 		if let domain = domain {
@@ -93,38 +84,6 @@ public class FileProviderXPCConnector: FileProviderConnector {
 			})
 		}
 	}
-
-	public func getProxy<T>(serviceName: NSFileProviderServiceName, domain: NSFileProviderDomain?) -> Promise<T> {
-		var url = NSFileProviderManager.default.documentStorageURL
-		if let domain = domain {
-			url.appendPathComponent(domain.pathRelativeToDocumentStorage)
-		}
-		return wrap { handler in
-			FileManager.default.getFileProviderServicesForItem(at: url, completionHandler: handler)
-		}.then { services -> Promise<NSXPCConnection?> in
-			if let desiredService = services?[serviceName] {
-				return desiredService.getFileProviderConnection()
-			} else {
-				return Promise(FileProviderXPCConnectorError.serviceNotSupported)
-			}
-		}.then { connection -> T in
-			guard let connection = connection else {
-				throw FileProviderXPCConnectorError.connectionIsNil
-			}
-			guard let type = T.self as AnyObject as? Protocol else {
-				throw FileProviderXPCConnectorError.typeMismatch
-			}
-			connection.remoteObjectInterface = NSXPCInterface(with: type)
-			connection.resume()
-			let rawProxy = connection.remoteObjectProxyWithErrorHandler { errorAccessingRemoteObject in
-				DDLogError("remoteObjectProxy failed with error: \(errorAccessingRemoteObject)")
-			}
-			guard let proxy = rawProxy as? T else {
-				throw FileProviderXPCConnectorError.rawProxyCastingFailed
-			}
-			return proxy
-		}
-	}
 }
 
 extension NSFileProviderService {

CryptomatorCommon/Sources/CryptomatorCommonCore/FileProviderXPC/LogLevelUpdating.swift

@@ -12,8 +12,6 @@ import Foundation
 	func logLevelUpdated()
 }
 
-public enum LogLevelUpdatingService {
-	public static var name: NSFileProviderServiceName {
-		return NSFileProviderServiceName("org.cryptomator.ios.log-level-updating")
-	}
+public extension NSFileProviderServiceName {
+	static let logLevelUpdating = NSFileProviderServiceName("org.cryptomator.ios.log-level-updating")
 }

CryptomatorCommon/Sources/CryptomatorCommonCore/FileProviderXPC/UploadRetrying.swift

@@ -0,0 +1,23 @@
+//
+//  UploadRetrying.swift
+//  CryptomatorCommonCore
+//
+//  Created by Philipp Schmid on 03.05.22.
+//  Copyright © 2021 Skymatic GmbH. All rights reserved.
+//
+
+import FileProvider
+import Foundation
+
+@objc public protocol UploadRetrying: NSFileProviderServiceSource {
+	/**
+	 Retries the upload for the given item identifiers.
+	  */
+	func retryUpload(for itemIdentifiers: [NSFileProviderItemIdentifier], reply: @escaping (Error?) -> Void)
+
+	func getCurrentFractionalUploadProgress(for itemIdentifier: NSFileProviderItemIdentifier, reply: @escaping (NSNumber?) -> Void)
+}
+
+public extension NSFileProviderServiceName {
+	static let uploadRetryingService = NSFileProviderServiceName("org.cryptomator.ios.upload-retrying")
+}

CryptomatorCommon/Sources/CryptomatorCommonCore/FileProviderXPC/VaultLocking.swift

@@ -17,10 +17,8 @@ import Promises
 	func getUnlockedVaultDomainIdentifiers(reply: @escaping ([NSFileProviderDomainIdentifier]) -> Void)
 }
 
-public enum VaultLockingService {
-	public static var name: NSFileProviderServiceName {
-		return NSFileProviderServiceName("org.cryptomator.ios.vault-locking")
-	}
+public extension NSFileProviderServiceName {
+	static let vaultLocking = NSFileProviderServiceName("org.cryptomator.ios.vault-locking")
 }
 
 // MARK: Convenience

CryptomatorCommon/Sources/CryptomatorCommonCore/FileProviderXPC/VaultUnlocking.swift

@@ -15,8 +15,6 @@ import Foundation
 	func endBiometricalUnlock()
 }
 
-public enum VaultUnlockingService {
-	public static var name: NSFileProviderServiceName {
-		return NSFileProviderServiceName("org.cryptomator.ios.vault-unlocking")
-	}
+public extension NSFileProviderServiceName {
+	static let vaultUnlocking = NSFileProviderServiceName("org.cryptomator.ios.vault-unlocking")
 }

CryptomatorCommon/Sources/CryptomatorCommonCore/Manager/VaultDBManager.swift

@@ -518,6 +518,17 @@ public extension NSFileProviderManager {
 
 public extension NSFileProviderDomain {
 	convenience init(vaultUID: String, displayName: String) {
-		self.init(identifier: NSFileProviderDomainIdentifier(vaultUID), displayName: displayName, pathRelativeToDocumentStorage: vaultUID)
+		self.init(identifier: NSFileProviderDomainIdentifier(vaultUID), displayName: displayName)
+	}
+
+	convenience init(identifier: NSFileProviderDomainIdentifier, displayName: String) {
+		self.init(identifier: identifier, displayName: displayName, pathRelativeToDocumentStorage: identifier.rawValue)
+	}
+
+	/**
+	 Creates a NSFileProviderDomain from a `NSFileProviderDomainIdentifier` where the `pathRelativeToDocumentStorage` equals to the raw value of the given `identifier` and an empty `displayName`.
+	 */
+	convenience init(identifier: NSFileProviderDomainIdentifier) {
+		self.init(identifier: identifier, displayName: "")
 	}
 }